]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
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 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_wxTGAHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTIFFHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTextCtrl swig_types[158]
2625 #define SWIGTYPE_p_wxTextDataObject swig_types[159]
2626 #define SWIGTYPE_p_wxTimeSpan swig_types[160]
2627 #define SWIGTYPE_p_wxTimer swig_types[161]
2628 #define SWIGTYPE_p_wxTimerEvent swig_types[162]
2629 #define SWIGTYPE_p_wxTimerRunner swig_types[163]
2630 #define SWIGTYPE_p_wxTipProvider swig_types[164]
2631 #define SWIGTYPE_p_wxToolTip swig_types[165]
2632 #define SWIGTYPE_p_wxURLDataObject swig_types[166]
2633 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[167]
2634 #define SWIGTYPE_p_wxValidator swig_types[168]
2635 #define SWIGTYPE_p_wxVideoMode swig_types[169]
2636 #define SWIGTYPE_p_wxWindow swig_types[170]
2637 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDisabler swig_types[173]
2640 #define SWIGTYPE_p_wxXPMHandler swig_types[174]
2641 static swig_type_info *swig_types[176];
2642 static swig_module_info swig_module = {swig_types, 175, 0, 0, 0, 0};
2643 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2644 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2645
2646 /* -------- TYPES TABLE (END) -------- */
2647
2648 #if (PY_VERSION_HEX <= 0x02000000)
2649 # if !defined(SWIG_PYTHON_CLASSIC)
2650 # error "This python version requires to use swig with the '-classic' option"
2651 # endif
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodern' option"
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodernargs' option"
2658 #endif
2659 #ifndef METH_O
2660 # error "This python version requires to use swig with the '-nofastunpack' option"
2661 #endif
2662
2663 /*-----------------------------------------------
2664 @(target):= _misc_.so
2665 ------------------------------------------------*/
2666 #define SWIG_init init_misc_
2667
2668 #define SWIG_name "_misc_"
2669
2670 #define SWIGVERSION 0x010329
2671
2672
2673 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2674 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2675
2676
2677 #include <stdexcept>
2678
2679
2680 namespace swig {
2681 class PyObject_ptr {
2682 protected:
2683 PyObject *_obj;
2684
2685 public:
2686 PyObject_ptr() :_obj(0)
2687 {
2688 }
2689
2690 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2691 {
2692 Py_XINCREF(_obj);
2693 }
2694
2695 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2696 {
2697 if (initial_ref) Py_XINCREF(_obj);
2698 }
2699
2700 PyObject_ptr & operator=(const PyObject_ptr& item)
2701 {
2702 Py_XINCREF(item._obj);
2703 Py_XDECREF(_obj);
2704 _obj = item._obj;
2705 return *this;
2706 }
2707
2708 ~PyObject_ptr()
2709 {
2710 Py_XDECREF(_obj);
2711 }
2712
2713 operator PyObject *() const
2714 {
2715 return _obj;
2716 }
2717
2718 PyObject *operator->() const
2719 {
2720 return _obj;
2721 }
2722 };
2723 }
2724
2725
2726 namespace swig {
2727 struct PyObject_var : PyObject_ptr {
2728 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2729
2730 PyObject_var & operator = (PyObject* obj)
2731 {
2732 Py_XDECREF(_obj);
2733 _obj = obj;
2734 return *this;
2735 }
2736 };
2737 }
2738
2739
2740 #include "wx/wxPython/wxPython.h"
2741 #include "wx/wxPython/pyclasses.h"
2742 #include "wx/wxPython/pyistream.h"
2743
2744 static const wxString wxPyEmptyString(wxEmptyString);
2745
2746
2747
2748 #define SWIG_From_long PyInt_FromLong
2749
2750
2751 SWIGINTERNINLINE PyObject *
2752 SWIG_From_int (int value)
2753 {
2754 return SWIG_From_long (value);
2755 }
2756
2757
2758 #include <limits.h>
2759 #ifndef LLONG_MIN
2760 # define LLONG_MIN LONG_LONG_MIN
2761 #endif
2762 #ifndef LLONG_MAX
2763 # define LLONG_MAX LONG_LONG_MAX
2764 #endif
2765 #ifndef ULLONG_MAX
2766 # define ULLONG_MAX ULONG_LONG_MAX
2767 #endif
2768
2769
2770 SWIGINTERN int
2771 SWIG_AsVal_long (PyObject* obj, long* val)
2772 {
2773 if (PyNumber_Check(obj)) {
2774 if (val) *val = PyInt_AsLong(obj);
2775 return SWIG_OK;
2776 }
2777 return SWIG_TypeError;
2778 }
2779
2780
2781 SWIGINTERN int
2782 SWIG_AsVal_int (PyObject * obj, int *val)
2783 {
2784 long v;
2785 int res = SWIG_AsVal_long (obj, &v);
2786 if (SWIG_IsOK(res)) {
2787 if ((v < INT_MIN || v > INT_MAX)) {
2788 return SWIG_OverflowError;
2789 } else {
2790 if (val) *val = static_cast< int >(v);
2791 }
2792 }
2793 return res;
2794 }
2795
2796 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2797
2798 #include <wx/stockitem.h>
2799
2800 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2801 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2802 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2803
2804 SWIGINTERN int
2805 SWIG_AsVal_bool (PyObject *obj, bool *val)
2806 {
2807 if (obj == Py_True) {
2808 if (val) *val = true;
2809 return SWIG_OK;
2810 } else if (obj == Py_False) {
2811 if (val) *val = false;
2812 return SWIG_OK;
2813 } else {
2814 long v = 0;
2815 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2816 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2817 return res;
2818 }
2819 }
2820
2821
2822 SWIGINTERN int
2823 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2824 {
2825 long v = 0;
2826 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2827 return SWIG_TypeError;
2828 }
2829 else if (val)
2830 *val = (unsigned long)v;
2831 return SWIG_OK;
2832 }
2833
2834
2835 SWIGINTERNINLINE PyObject*
2836 SWIG_From_unsigned_SS_long (unsigned long value)
2837 {
2838 return (value > LONG_MAX) ?
2839 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2840 }
2841
2842
2843 void* wxGetXDisplay()
2844 {
2845 #ifdef __WXGTK__
2846 return wxGetDisplay();
2847 #else
2848 return NULL;
2849 #endif
2850 }
2851
2852
2853 wxWindow* FindWindowAtPointer() {
2854 wxPoint unused;
2855 return wxFindWindowAtPointer(unused);
2856 }
2857
2858
2859 bool wxThread_IsMain() {
2860 #ifdef WXP_WITH_THREAD
2861 return wxThread::IsMain();
2862 #else
2863 return true;
2864 #endif
2865 }
2866
2867 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2868 delete self;
2869 }
2870
2871 #include <wx/snglinst.h>
2872
2873
2874 #ifdef __WXMSW__
2875 #include <wx/msw/private.h>
2876 #include <wx/dynload.h>
2877 #endif
2878
2879
2880
2881 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2882 #if 0
2883 , int method
2884 #endif
2885 )
2886 {
2887 #ifdef __WXMSW__
2888 #if 0
2889 switch (method)
2890 {
2891 case 1:
2892 // This one only partially works. Appears to be an undocumented
2893 // "standard" convention that not all widgets adhear to. For
2894 // example, for some widgets backgrounds or non-client areas may
2895 // not be painted.
2896 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2897 break;
2898
2899 case 2:
2900 #endif
2901 // This one works much better, nearly all widgets and their
2902 // children are captured correctly[**]. Prior to the big
2903 // background erase changes that Vadim did in 2004-2005 this
2904 // method failed badly on XP with Themes activated, most native
2905 // widgets draw only partially, if at all. Without themes it
2906 // worked just like on Win2k. After those changes this method
2907 // works very well.
2908 //
2909 // ** For example the radio buttons in a wxRadioBox are not its
2910 // children by default, but you can capture it via the panel
2911 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2912 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2913 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2914 PRF_ERASEBKGND | PRF_OWNED );
2915 return true;
2916 #if 0
2917 break;
2918
2919 case 3:
2920 // This one is only defined in the latest SDK and is only
2921 // available on XP. MSDN says it is similar to sending WM_PRINT
2922 // so I expect that it will work similar to the above. Since it
2923 // is avaialble only on XP, it can't be compiled like this and
2924 // will have to be loaded dynamically.
2925 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2926
2927 // fall through
2928
2929 case 4:
2930 // Use PrintWindow if available, or fallback to WM_PRINT
2931 // otherwise. Unfortunately using PrintWindow is even worse than
2932 // WM_PRINT. For most native widgets nothing is drawn to the dc
2933 // at all, with or without Themes.
2934 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2935 static bool s_triedToLoad = false;
2936 static PrintWindow_t pfnPrintWindow = NULL;
2937 if ( !s_triedToLoad )
2938 {
2939
2940 s_triedToLoad = true;
2941 wxDynamicLibrary dllUser32(_T("user32.dll"));
2942 if ( dllUser32.IsLoaded() )
2943 {
2944 wxLogNull nolog; // Don't report errors here
2945 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2946 }
2947 }
2948 if (pfnPrintWindow)
2949 {
2950 //printf("Using PrintWindow\n");
2951 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2952 }
2953 else
2954 {
2955 //printf("Using WM_PRINT\n");
2956 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2957 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2958 PRF_ERASEBKGND | PRF_OWNED );
2959 }
2960 }
2961 #endif // 0
2962 #else
2963 return false;
2964 #endif // __WXMSW__
2965 }
2966
2967
2968
2969 #include <wx/tipdlg.h>
2970
2971
2972 SWIGINTERNINLINE PyObject *
2973 SWIG_From_size_t (size_t value)
2974 {
2975 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2976 }
2977
2978
2979 class wxPyTipProvider : public wxTipProvider {
2980 public:
2981 wxPyTipProvider(size_t currentTip)
2982 : wxTipProvider(currentTip) {}
2983
2984 DEC_PYCALLBACK_STRING__pure(GetTip);
2985 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2986 PYPRIVATE;
2987 };
2988
2989 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2990 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2991
2992
2993 SWIGINTERNINLINE int
2994 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2995 {
2996 unsigned long v;
2997 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2998 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2999 return res;
3000 }
3001
3002
3003 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3004
3005 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3006
3007 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3008 : wxTimer(owner, id)
3009 {
3010 if (owner == NULL)
3011 SetOwner(this);
3012 }
3013
3014
3015 SWIGINTERN swig_type_info*
3016 SWIG_pchar_descriptor()
3017 {
3018 static int init = 0;
3019 static swig_type_info* info = 0;
3020 if (!init) {
3021 info = SWIG_TypeQuery("_p_char");
3022 init = 1;
3023 }
3024 return info;
3025 }
3026
3027
3028 SWIGINTERNINLINE PyObject *
3029 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3030 {
3031 if (carray) {
3032 if (size > INT_MAX) {
3033 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3034 return pchar_descriptor ?
3035 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3036 } else {
3037 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3038 }
3039 } else {
3040 return SWIG_Py_Void();
3041 }
3042 }
3043
3044
3045 SWIGINTERNINLINE PyObject *
3046 SWIG_FromCharPtr(const char *cptr)
3047 {
3048 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3049 }
3050
3051
3052 SWIGINTERN int
3053 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3054 {
3055 unsigned long v;
3056 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3057 if (SWIG_IsOK(res)) {
3058 if ((v > UINT_MAX)) {
3059 return SWIG_OverflowError;
3060 } else {
3061 if (val) *val = static_cast< unsigned int >(v);
3062 }
3063 }
3064 return res;
3065 }
3066
3067 SWIGINTERN wxString wxLog_TimeStamp(){
3068 wxString msg;
3069 wxLog::TimeStamp(&msg);
3070 return msg;
3071 }
3072 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3073 // Make some wrappers that double any % signs so they are 'escaped'
3074 void wxPyLogFatalError(const wxString& msg)
3075 {
3076 wxString m(msg);
3077 m.Replace(wxT("%"), wxT("%%"));
3078 wxLogFatalError(m);
3079 }
3080
3081 void wxPyLogError(const wxString& msg)
3082 {
3083 wxString m(msg);
3084 m.Replace(wxT("%"), wxT("%%"));
3085 wxLogError(m);
3086 }
3087
3088 void wxPyLogWarning(const wxString& msg)
3089 {
3090 wxString m(msg);
3091 m.Replace(wxT("%"), wxT("%%"));
3092 wxLogWarning(m);
3093 }
3094
3095 void wxPyLogMessage(const wxString& msg)
3096 {
3097 wxString m(msg);
3098 m.Replace(wxT("%"), wxT("%%"));
3099 wxLogMessage(m);
3100 }
3101
3102 void wxPyLogInfo(const wxString& msg)
3103 {
3104 wxString m(msg);
3105 m.Replace(wxT("%"), wxT("%%"));
3106 wxLogInfo(m);
3107 }
3108
3109 void wxPyLogDebug(const wxString& msg)
3110 {
3111 wxString m(msg);
3112 m.Replace(wxT("%"), wxT("%%"));
3113 wxLogDebug(m);
3114 }
3115
3116 void wxPyLogVerbose(const wxString& msg)
3117 {
3118 wxString m(msg);
3119 m.Replace(wxT("%"), wxT("%%"));
3120 wxLogVerbose(m);
3121 }
3122
3123 void wxPyLogStatus(const wxString& msg)
3124 {
3125 wxString m(msg);
3126 m.Replace(wxT("%"), wxT("%%"));
3127 wxLogStatus(m);
3128 }
3129
3130 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3131 {
3132 wxString m(msg);
3133 m.Replace(wxT("%"), wxT("%%"));
3134 wxLogStatus(pFrame, m);
3135 }
3136
3137 void wxPyLogSysError(const wxString& msg)
3138 {
3139 wxString m(msg);
3140 m.Replace(wxT("%"), wxT("%%"));
3141 wxLogSysError(m);
3142 }
3143
3144 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3145 {
3146 wxString m(msg);
3147 m.Replace(wxT("%"), wxT("%%"));
3148 wxLogGeneric(level, m);
3149 }
3150
3151 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3152 {
3153 wxString m(msg);
3154 m.Replace(wxT("%"), wxT("%%"));
3155 wxLogTrace(mask, m);
3156 }
3157
3158 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3159 {
3160 wxString m(msg);
3161 m.Replace(wxT("%"), wxT("%%"));
3162 wxLogTrace(mask, m);
3163 }
3164
3165
3166
3167 // A wxLog class that can be derived from in wxPython
3168 class wxPyLog : public wxLog {
3169 public:
3170 wxPyLog() : wxLog() {}
3171
3172 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3173 bool found;
3174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3175 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3176 PyObject* s = wx2PyString(szString);
3177 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3178 Py_DECREF(s);
3179 }
3180 wxPyEndBlockThreads(blocked);
3181 if (! found)
3182 wxLog::DoLog(level, szString, t);
3183 }
3184
3185 virtual void DoLogString(const wxChar *szString, time_t t) {
3186 bool found;
3187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3188 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3189 PyObject* s = wx2PyString(szString);
3190 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3191 Py_DECREF(s);
3192 }
3193 wxPyEndBlockThreads(blocked);
3194 if (! found)
3195 wxLog::DoLogString(szString, t);
3196 }
3197
3198 DEC_PYCALLBACK_VOID_(Flush);
3199 PYPRIVATE;
3200 };
3201 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3202
3203
3204
3205
3206 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3207
3208
3209 #include <wx/joystick.h>
3210
3211
3212 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3213 // A C++ stub class for wxJoystick for platforms that don't have it.
3214 class wxJoystick : public wxObject {
3215 public:
3216 wxJoystick(int joystick = wxJOYSTICK1) {
3217 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3218 PyErr_SetString(PyExc_NotImplementedError,
3219 "wxJoystick is not available on this platform.");
3220 wxPyEndBlockThreads(blocked);
3221 }
3222 wxPoint GetPosition() { return wxPoint(-1,-1); }
3223 int GetZPosition() { return -1; }
3224 int GetButtonState() { return -1; }
3225 int GetPOVPosition() { return -1; }
3226 int GetPOVCTSPosition() { return -1; }
3227 int GetRudderPosition() { return -1; }
3228 int GetUPosition() { return -1; }
3229 int GetVPosition() { return -1; }
3230 int GetMovementThreshold() { return -1; }
3231 void SetMovementThreshold(int threshold) {}
3232
3233 bool IsOk(void) { return false; }
3234 int GetNumberJoysticks() { return -1; }
3235 int GetManufacturerId() { return -1; }
3236 int GetProductId() { return -1; }
3237 wxString GetProductName() { return wxEmptyString; }
3238 int GetXMin() { return -1; }
3239 int GetYMin() { return -1; }
3240 int GetZMin() { return -1; }
3241 int GetXMax() { return -1; }
3242 int GetYMax() { return -1; }
3243 int GetZMax() { return -1; }
3244 int GetNumberButtons() { return -1; }
3245 int GetNumberAxes() { return -1; }
3246 int GetMaxButtons() { return -1; }
3247 int GetMaxAxes() { return -1; }
3248 int GetPollingMin() { return -1; }
3249 int GetPollingMax() { return -1; }
3250 int GetRudderMin() { return -1; }
3251 int GetRudderMax() { return -1; }
3252 int GetUMin() { return -1; }
3253 int GetUMax() { return -1; }
3254 int GetVMin() { return -1; }
3255 int GetVMax() { return -1; }
3256
3257 bool HasRudder() { return false; }
3258 bool HasZ() { return false; }
3259 bool HasU() { return false; }
3260 bool HasV() { return false; }
3261 bool HasPOV() { return false; }
3262 bool HasPOV4Dir() { return false; }
3263 bool HasPOVCTS() { return false; }
3264
3265 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3266 bool ReleaseCapture() { return false; }
3267 };
3268 #endif
3269
3270
3271 #include <wx/sound.h>
3272
3273
3274 #if !wxUSE_SOUND
3275 // A C++ stub class for wxWave for platforms that don't have it.
3276 class wxSound : public wxObject
3277 {
3278 public:
3279 wxSound() {
3280 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3281 PyErr_SetString(PyExc_NotImplementedError,
3282 "wxSound is not available on this platform.");
3283 wxPyEndBlockThreads(blocked);
3284 }
3285 wxSound(const wxString&/*, bool*/) {
3286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3287 PyErr_SetString(PyExc_NotImplementedError,
3288 "wxSound is not available on this platform.");
3289 wxPyEndBlockThreads(blocked);
3290 }
3291 wxSound(int, const wxByte*) {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297
3298 ~wxSound() {};
3299
3300 bool Create(const wxString&/*, bool*/) { return false; }
3301 bool Create(int, const wxByte*) { return false; };
3302 bool IsOk() { return false; };
3303 bool Play(unsigned) const { return false; }
3304 static bool Play(const wxString&, unsigned) { return false; }
3305 static void Stop() {}
3306 };
3307
3308 #endif
3309
3310 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3311 if (fileName.Length() == 0)
3312 return new wxSound;
3313 else
3314 return new wxSound(fileName);
3315 }
3316 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3317 unsigned char* buffer; int size;
3318 wxSound *sound = NULL;
3319
3320 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3321 if (!PyArg_Parse(data, "t#", &buffer, &size))
3322 goto done;
3323 sound = new wxSound(size, buffer);
3324 done:
3325 wxPyEndBlockThreads(blocked);
3326 return sound;
3327 }
3328 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3329 #ifndef __WXMAC__
3330 unsigned char* buffer;
3331 int size;
3332 bool rv = false;
3333
3334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3335 if (!PyArg_Parse(data, "t#", &buffer, &size))
3336 goto done;
3337 rv = self->Create(size, buffer);
3338 done:
3339 wxPyEndBlockThreads(blocked);
3340 return rv;
3341 #else
3342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3343 PyErr_SetString(PyExc_NotImplementedError,
3344 "Create from data is not available on this platform.");
3345 wxPyEndBlockThreads(blocked);
3346 return false;
3347 #endif
3348 }
3349
3350 #include <wx/mimetype.h>
3351
3352 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3353 wxString str;
3354 if (self->GetMimeType(&str))
3355 return wx2PyString(str);
3356 else
3357 RETURN_NONE();
3358 }
3359 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3360 wxArrayString arr;
3361 if (self->GetMimeTypes(arr))
3362 return wxArrayString2PyList_helper(arr);
3363 else
3364 RETURN_NONE();
3365 }
3366 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3367 wxArrayString arr;
3368 if (self->GetExtensions(arr))
3369 return wxArrayString2PyList_helper(arr);
3370 else
3371 RETURN_NONE();
3372 }
3373 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3374 wxIconLocation loc;
3375 if (self->GetIcon(&loc))
3376 return new wxIcon(loc);
3377 else
3378 return NULL;
3379 }
3380 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3381 wxIconLocation loc;
3382 if (self->GetIcon(&loc)) {
3383 wxString iconFile = loc.GetFileName();
3384 int iconIndex = -1;
3385
3386
3387
3388 // Make a tuple and put the values in it
3389 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3390 PyObject* tuple = PyTuple_New(3);
3391 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3392 wxT("wxIcon"), true));
3393 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3394 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3395 wxPyEndBlockThreads(blocked);
3396 return tuple;
3397 }
3398 else
3399 RETURN_NONE();
3400 }
3401 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3402 wxString str;
3403 if (self->GetDescription(&str))
3404 return wx2PyString(str);
3405 else
3406 RETURN_NONE();
3407 }
3408 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3409 wxString str;
3410 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3411 return wx2PyString(str);
3412 else
3413 RETURN_NONE();
3414 }
3415 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3416 wxString str;
3417 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3418 return wx2PyString(str);
3419 else
3420 RETURN_NONE();
3421 }
3422 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3423 wxArrayString verbs;
3424 wxArrayString commands;
3425 if (self->GetAllCommands(&verbs, &commands,
3426 wxFileType::MessageParameters(filename, mimetype))) {
3427 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3428 PyObject* tuple = PyTuple_New(2);
3429 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3430 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3431 wxPyEndBlockThreads(blocked);
3432 return tuple;
3433 }
3434 else
3435 RETURN_NONE();
3436 }
3437 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3438 return wxFileType::ExpandCommand(command,
3439 wxFileType::MessageParameters(filename, mimetype));
3440 }
3441 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3442 wxArrayString arr;
3443 self->EnumAllFileTypes(arr);
3444 return wxArrayString2PyList_helper(arr);
3445 }
3446
3447 #include <wx/artprov.h>
3448
3449 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3450 static const wxString wxPyART_MENU(wxART_MENU);
3451 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3452 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3453 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3454 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3455 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3456 static const wxString wxPyART_OTHER(wxART_OTHER);
3457 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3458 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3459 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3460 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3461 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3462 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3463 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3464 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3465 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3466 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3467 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3468 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3469 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3470 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3471 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3472 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3473 static const wxString wxPyART_PRINT(wxART_PRINT);
3474 static const wxString wxPyART_HELP(wxART_HELP);
3475 static const wxString wxPyART_TIP(wxART_TIP);
3476 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3477 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3478 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3479 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3480 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3481 static const wxString wxPyART_CDROM(wxART_CDROM);
3482 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3483 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3484 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3485 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3486 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3487 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3488 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3489 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3490 static const wxString wxPyART_ERROR(wxART_ERROR);
3491 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3492 static const wxString wxPyART_WARNING(wxART_WARNING);
3493 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3494 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3495 static const wxString wxPyART_COPY(wxART_COPY);
3496 static const wxString wxPyART_CUT(wxART_CUT);
3497 static const wxString wxPyART_PASTE(wxART_PASTE);
3498 static const wxString wxPyART_DELETE(wxART_DELETE);
3499 static const wxString wxPyART_NEW(wxART_NEW);
3500 static const wxString wxPyART_UNDO(wxART_UNDO);
3501 static const wxString wxPyART_REDO(wxART_REDO);
3502 static const wxString wxPyART_QUIT(wxART_QUIT);
3503 static const wxString wxPyART_FIND(wxART_FIND);
3504 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3505 // Python aware wxArtProvider
3506 class wxPyArtProvider : public wxArtProvider {
3507 public:
3508
3509 virtual wxBitmap CreateBitmap(const wxArtID& id,
3510 const wxArtClient& client,
3511 const wxSize& size) {
3512 wxBitmap rval = wxNullBitmap;
3513 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3514 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3515 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3516 PyObject* ro;
3517 wxBitmap* ptr;
3518 PyObject* s1, *s2;
3519 s1 = wx2PyString(id);
3520 s2 = wx2PyString(client);
3521 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3522 Py_DECREF(so);
3523 Py_DECREF(s1);
3524 Py_DECREF(s2);
3525 if (ro) {
3526 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3527 rval = *ptr;
3528 Py_DECREF(ro);
3529 }
3530 }
3531 wxPyEndBlockThreads(blocked);
3532 return rval;
3533 }
3534
3535 PYPRIVATE;
3536 };
3537
3538 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3539
3540
3541
3542 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3543 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3544 PyObject* ret = PyTuple_New(3);
3545 if (ret) {
3546 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3547 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3548 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3549 }
3550 wxPyEndBlockThreads(blocked);
3551 return ret;
3552 }
3553
3554 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3555 bool cont;
3556 long index = 0;
3557 wxString value;
3558
3559 cont = self->GetFirstGroup(value, index);
3560 return __EnumerationHelper(cont, value, index);
3561 }
3562 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3563 bool cont;
3564 wxString value;
3565
3566 cont = self->GetNextGroup(value, index);
3567 return __EnumerationHelper(cont, value, index);
3568 }
3569 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3570 bool cont;
3571 long index = 0;
3572 wxString value;
3573
3574 cont = self->GetFirstEntry(value, index);
3575 return __EnumerationHelper(cont, value, index);
3576 }
3577 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3578 bool cont;
3579 wxString value;
3580
3581 cont = self->GetNextEntry(value, index);
3582 return __EnumerationHelper(cont, value, index);
3583 }
3584 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3585 long rv;
3586 self->Read(key, &rv, defaultVal);
3587 return rv;
3588 }
3589
3590 SWIGINTERN int
3591 SWIG_AsVal_double (PyObject *obj, double* val)
3592 {
3593 if (PyNumber_Check(obj)) {
3594 if (val) *val = PyFloat_AsDouble(obj);
3595 return SWIG_OK;
3596 }
3597 return SWIG_TypeError;
3598 }
3599
3600 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3601 double rv;
3602 self->Read(key, &rv, defaultVal);
3603 return rv;
3604 }
3605
3606 #define SWIG_From_double PyFloat_FromDouble
3607
3608 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3609 bool rv;
3610 self->Read(key, &rv, defaultVal);
3611 return rv;
3612 }
3613
3614 #include <wx/datetime.h>
3615
3616 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3617 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3618
3619 #define LOCAL_TZ wxDateTime::Local
3620
3621 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3622 wxString am;
3623 wxString pm;
3624 wxDateTime::GetAmPmStrings(&am, &pm);
3625 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3626 PyObject* tup = PyTuple_New(2);
3627 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3628 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3629 wxPyEndBlockThreads(blocked);
3630 return tup;
3631 }
3632
3633 SWIGINTERNINLINE PyObject *
3634 SWIG_From_unsigned_SS_int (unsigned int value)
3635 {
3636 return SWIG_From_unsigned_SS_long (value);
3637 }
3638
3639 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3640 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3641 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3642 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3643 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3644 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3645 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3646 return (*self < *other);
3647 }
3648 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3649 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3650 return (*self <= *other);
3651 }
3652 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3653 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3654 return (*self > *other);
3655 }
3656 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3658 return (*self >= *other);
3659 }
3660 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3662 return (*self == *other);
3663 }
3664 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3665 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3666 return (*self != *other);
3667 }
3668 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3669 const wxChar* rv;
3670 const wxChar* _date = date;
3671 rv = self->ParseRfc822Date(_date);
3672 if (rv == NULL) return -1;
3673 return rv - _date;
3674 }
3675 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3676 const wxChar* rv;
3677 const wxChar* _date = date;
3678 rv = self->ParseFormat(_date, format, dateDef);
3679 if (rv == NULL) return -1;
3680 return rv - _date;
3681 }
3682 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3683 const wxChar* rv;
3684 const wxChar* _datetime = datetime;
3685 rv = self->ParseDateTime(_datetime);
3686 if (rv == NULL) return -1;
3687 return rv - _datetime;
3688 }
3689 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3690 const wxChar* rv;
3691 const wxChar* _date = date;
3692 rv = self->ParseDate(_date);
3693 if (rv == NULL) return -1;
3694 return rv - _date;
3695 }
3696 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3697 const wxChar* rv;
3698 const wxChar* _time = time;
3699 rv = self->ParseTime(_time);
3700 if (rv == NULL) return -1;
3701 return rv - _time;
3702 }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3705 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3706 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3707 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3709 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3710 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3711 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3712 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3713 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3714 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3715 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3716 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3717 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3718 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3719
3720 #include <wx/dataobj.h>
3721
3722 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3723 size_t count = self->GetFormatCount(dir);
3724 wxDataFormat* formats = new wxDataFormat[count];
3725 self->GetAllFormats(formats, dir);
3726
3727 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3728 PyObject* list = PyList_New(count);
3729 for (size_t i=0; i<count; i++) {
3730 wxDataFormat* format = new wxDataFormat(formats[i]);
3731 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3732 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3733 }
3734 wxPyEndBlockThreads(blocked);
3735 delete [] formats;
3736 return list;
3737 }
3738 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3739 PyObject* rval = NULL;
3740 size_t size = self->GetDataSize(format);
3741 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3742 if (size) {
3743 char* buf = new char[size];
3744 if (self->GetDataHere(format, buf))
3745 rval = PyString_FromStringAndSize(buf, size);
3746 delete [] buf;
3747 }
3748 if (! rval) {
3749 rval = Py_None;
3750 Py_INCREF(rval);
3751 }
3752 wxPyEndBlockThreads(blocked);
3753 return rval;
3754 }
3755 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3756 bool rval;
3757 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3758 if (PyString_Check(data)) {
3759 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3760 }
3761 else {
3762 // raise a TypeError if not a string
3763 PyErr_SetString(PyExc_TypeError, "String expected.");
3764 rval = false;
3765 }
3766 wxPyEndBlockThreads(blocked);
3767 return rval;
3768 }
3769 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3770 PyObject* rval = NULL;
3771 size_t size = self->GetDataSize();
3772 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3773 if (size) {
3774 char* buf = new char[size];
3775 if (self->GetDataHere(buf))
3776 rval = PyString_FromStringAndSize(buf, size);
3777 delete [] buf;
3778 }
3779 if (! rval) {
3780 rval = Py_None;
3781 Py_INCREF(rval);
3782 }
3783 wxPyEndBlockThreads(blocked);
3784 return rval;
3785 }
3786 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3787 bool rval;
3788 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3789 if (PyString_Check(data)) {
3790 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3791 }
3792 else {
3793 // raise a TypeError if not a string
3794 PyErr_SetString(PyExc_TypeError, "String expected.");
3795 rval = false;
3796 }
3797 wxPyEndBlockThreads(blocked);
3798 return rval;
3799 }
3800 // Create a new class for wxPython to use
3801 class wxPyDataObjectSimple : public wxDataObjectSimple {
3802 public:
3803 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3804 : wxDataObjectSimple(format) {}
3805
3806 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3807 bool GetDataHere(void *buf) const;
3808 bool SetData(size_t len, const void *buf);
3809 PYPRIVATE;
3810 };
3811
3812 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3813
3814 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3815 // We need to get the data for this object and write it to buf. I think
3816 // the best way to do this for wxPython is to have the Python method
3817 // return either a string or None and then act appropriately with the
3818 // C++ version.
3819
3820 bool rval = false;
3821 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3822 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3823 PyObject* ro;
3824 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3825 if (ro) {
3826 rval = (ro != Py_None && PyString_Check(ro));
3827 if (rval)
3828 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3829 Py_DECREF(ro);
3830 }
3831 }
3832 wxPyEndBlockThreads(blocked);
3833 return rval;
3834 }
3835
3836 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3837 // For this one we simply need to make a string from buf and len
3838 // and send it to the Python method.
3839 bool rval = false;
3840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3841 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3842 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3843 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3844 Py_DECREF(data);
3845 }
3846 wxPyEndBlockThreads(blocked);
3847 return rval;
3848 }
3849
3850 // Create a new class for wxPython to use
3851 class wxPyTextDataObject : public wxTextDataObject {
3852 public:
3853 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3854 : wxTextDataObject(text) {}
3855
3856 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3857 DEC_PYCALLBACK_STRING__const(GetText);
3858 DEC_PYCALLBACK__STRING(SetText);
3859 PYPRIVATE;
3860 };
3861
3862 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3863 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3864 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3865
3866
3867 // Create a new class for wxPython to use
3868 class wxPyBitmapDataObject : public wxBitmapDataObject {
3869 public:
3870 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3871 : wxBitmapDataObject(bitmap) {}
3872
3873 wxBitmap GetBitmap() const;
3874 void SetBitmap(const wxBitmap& bitmap);
3875 PYPRIVATE;
3876 };
3877
3878 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3879 wxBitmap* rval = &wxNullBitmap;
3880 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3881 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3882 PyObject* ro;
3883 wxBitmap* ptr;
3884 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3885 if (ro) {
3886 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3887 rval = ptr;
3888 Py_DECREF(ro);
3889 }
3890 }
3891 wxPyEndBlockThreads(blocked);
3892 return *rval;
3893 }
3894
3895 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3896 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3897 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3898 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3899 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3900 Py_DECREF(bo);
3901 }
3902 wxPyEndBlockThreads(blocked);
3903 }
3904
3905 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3906 return new wxCustomDataObject(wxDataFormat(formatName));
3907 }
3908 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3909 bool rval;
3910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3911 if (PyString_Check(data)) {
3912 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3913 }
3914 else {
3915 // raise a TypeError if not a string
3916 PyErr_SetString(PyExc_TypeError, "String expected.");
3917 rval = false;
3918 }
3919 wxPyEndBlockThreads(blocked);
3920 return rval;
3921 }
3922 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3923 PyObject* obj;
3924 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3925 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3926 wxPyEndBlockThreads(blocked);
3927 return obj;
3928 }
3929
3930 #include <wx/metafile.h>
3931
3932
3933 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3934
3935
3936 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3937 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3938 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3939 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3940 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3941
3942
3943 class wxPyTextDropTarget : public wxTextDropTarget {
3944 public:
3945 wxPyTextDropTarget() {}
3946
3947 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3948
3949 DEC_PYCALLBACK__(OnLeave);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3951 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3952 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3953 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3954
3955 PYPRIVATE;
3956 };
3957
3958 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3959 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3961 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3962 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3963 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3964
3965
3966
3967 class wxPyFileDropTarget : public wxFileDropTarget {
3968 public:
3969 wxPyFileDropTarget() {}
3970
3971 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3972
3973 DEC_PYCALLBACK__(OnLeave);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3975 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3976 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3977 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3978
3979 PYPRIVATE;
3980 };
3981
3982 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3983 const wxArrayString& filenames) {
3984 bool rval = false;
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3987 PyObject* list = wxArrayString2PyList_helper(filenames);
3988 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3989 Py_DECREF(list);
3990 }
3991 wxPyEndBlockThreads(blocked);
3992 return rval;
3993 }
3994
3995
3996
3997 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3999 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4000 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4001 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4002
4003
4004
4005
4006 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4007
4008 #include <wx/display.h>
4009 #include <wx/vidmode.h>
4010
4011 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4012 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4013
4014 #if !wxUSE_DISPLAY
4015 const wxVideoMode wxDefaultVideoMode;
4016 #endif
4017
4018 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4019 #if wxUSE_DISPLAY
4020 PyObject* pyList = NULL;
4021 wxArrayVideoModes arr = self->GetModes(mode);
4022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4023 pyList = PyList_New(0);
4024 for (size_t i=0; i < arr.GetCount(); i++)
4025 {
4026 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4027 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4028 PyList_Append(pyList, pyObj);
4029 Py_DECREF(pyObj);
4030 }
4031 wxPyEndBlockThreads(blocked);
4032 return pyList;
4033 #else
4034 wxPyRaiseNotImplemented();
4035 return NULL;
4036 #endif
4037 }
4038 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4039 #if wxUSE_DISPLAY
4040 return self->GetCurrentMode();
4041 #else
4042 wxPyRaiseNotImplemented();
4043 return wxDefaultVideoMode;
4044 #endif
4045 }
4046 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4047 #if wxUSE_DISPLAY
4048 return self->ChangeMode(mode);
4049 #else
4050 wxPyRaiseNotImplemented();
4051 return false;
4052 #endif
4053 }
4054 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4055 #if wxUSE_DISPLAY
4056 self->ResetMode();
4057 #else
4058 wxPyRaiseNotImplemented();
4059 #endif
4060 }
4061
4062 #include <wx/stdpaths.h>
4063
4064 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4065 return (wxStandardPaths*) &wxStandardPaths::Get();
4066 }
4067 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4068 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4069
4070 #ifndef wxHAS_POWER_EVENTS
4071 // Dummy class and other definitions for platforms that don't have them
4072
4073 // See wxPython_int.h for wxPowerEvent
4074
4075 enum {
4076 wxEVT_POWER_SUSPENDING,
4077 wxEVT_POWER_SUSPENDED,
4078 wxEVT_POWER_SUSPEND_CANCEL,
4079 wxEVT_POWER_RESUME,
4080 };
4081
4082 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4083 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4084
4085 #endif
4086
4087
4088 #include <wx/aboutdlg.h>
4089
4090 #ifdef __cplusplus
4091 extern "C" {
4092 #endif
4093 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj = 0;
4095 wxSystemColour arg1 ;
4096 wxColour result;
4097 int val1 ;
4098 int ecode1 = 0 ;
4099 PyObject * obj0 = 0 ;
4100 char * kwnames[] = {
4101 (char *) "index", NULL
4102 };
4103
4104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4105 ecode1 = SWIG_AsVal_int(obj0, &val1);
4106 if (!SWIG_IsOK(ecode1)) {
4107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4108 }
4109 arg1 = static_cast< wxSystemColour >(val1);
4110 {
4111 if (!wxPyCheckForApp()) SWIG_fail;
4112 PyThreadState* __tstate = wxPyBeginAllowThreads();
4113 result = wxSystemSettings::GetColour(arg1);
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj = 0;
4126 wxSystemFont arg1 ;
4127 wxFont result;
4128 int val1 ;
4129 int ecode1 = 0 ;
4130 PyObject * obj0 = 0 ;
4131 char * kwnames[] = {
4132 (char *) "index", NULL
4133 };
4134
4135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4136 ecode1 = SWIG_AsVal_int(obj0, &val1);
4137 if (!SWIG_IsOK(ecode1)) {
4138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4139 }
4140 arg1 = static_cast< wxSystemFont >(val1);
4141 {
4142 if (!wxPyCheckForApp()) SWIG_fail;
4143 PyThreadState* __tstate = wxPyBeginAllowThreads();
4144 result = wxSystemSettings::GetFont(arg1);
4145 wxPyEndAllowThreads(__tstate);
4146 if (PyErr_Occurred()) SWIG_fail;
4147 }
4148 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4149 return resultobj;
4150 fail:
4151 return NULL;
4152 }
4153
4154
4155 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4156 PyObject *resultobj = 0;
4157 wxSystemMetric arg1 ;
4158 wxWindow *arg2 = (wxWindow *) NULL ;
4159 int result;
4160 int val1 ;
4161 int ecode1 = 0 ;
4162 void *argp2 = 0 ;
4163 int res2 = 0 ;
4164 PyObject * obj0 = 0 ;
4165 PyObject * obj1 = 0 ;
4166 char * kwnames[] = {
4167 (char *) "index",(char *) "win", NULL
4168 };
4169
4170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4171 ecode1 = SWIG_AsVal_int(obj0, &val1);
4172 if (!SWIG_IsOK(ecode1)) {
4173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4174 }
4175 arg1 = static_cast< wxSystemMetric >(val1);
4176 if (obj1) {
4177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4178 if (!SWIG_IsOK(res2)) {
4179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4180 }
4181 arg2 = reinterpret_cast< wxWindow * >(argp2);
4182 }
4183 {
4184 if (!wxPyCheckForApp()) SWIG_fail;
4185 PyThreadState* __tstate = wxPyBeginAllowThreads();
4186 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4187 wxPyEndAllowThreads(__tstate);
4188 if (PyErr_Occurred()) SWIG_fail;
4189 }
4190 resultobj = SWIG_From_int(static_cast< int >(result));
4191 return resultobj;
4192 fail:
4193 return NULL;
4194 }
4195
4196
4197 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4198 PyObject *resultobj = 0;
4199 wxSystemFeature arg1 ;
4200 bool result;
4201 int val1 ;
4202 int ecode1 = 0 ;
4203 PyObject * obj0 = 0 ;
4204 char * kwnames[] = {
4205 (char *) "index", NULL
4206 };
4207
4208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4209 ecode1 = SWIG_AsVal_int(obj0, &val1);
4210 if (!SWIG_IsOK(ecode1)) {
4211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4212 }
4213 arg1 = static_cast< wxSystemFeature >(val1);
4214 {
4215 if (!wxPyCheckForApp()) SWIG_fail;
4216 PyThreadState* __tstate = wxPyBeginAllowThreads();
4217 result = (bool)wxSystemSettings::HasFeature(arg1);
4218 wxPyEndAllowThreads(__tstate);
4219 if (PyErr_Occurred()) SWIG_fail;
4220 }
4221 {
4222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4223 }
4224 return resultobj;
4225 fail:
4226 return NULL;
4227 }
4228
4229
4230 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4231 PyObject *resultobj = 0;
4232 wxSystemScreenType result;
4233
4234 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4235 {
4236 if (!wxPyCheckForApp()) SWIG_fail;
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4239 wxPyEndAllowThreads(__tstate);
4240 if (PyErr_Occurred()) SWIG_fail;
4241 }
4242 resultobj = SWIG_From_int(static_cast< int >(result));
4243 return resultobj;
4244 fail:
4245 return NULL;
4246 }
4247
4248
4249 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4250 PyObject *resultobj = 0;
4251 wxSystemScreenType arg1 ;
4252 int val1 ;
4253 int ecode1 = 0 ;
4254 PyObject * obj0 = 0 ;
4255 char * kwnames[] = {
4256 (char *) "screen", NULL
4257 };
4258
4259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4260 ecode1 = SWIG_AsVal_int(obj0, &val1);
4261 if (!SWIG_IsOK(ecode1)) {
4262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4263 }
4264 arg1 = static_cast< wxSystemScreenType >(val1);
4265 {
4266 if (!wxPyCheckForApp()) SWIG_fail;
4267 PyThreadState* __tstate = wxPyBeginAllowThreads();
4268 wxSystemSettings::SetScreenType(arg1);
4269 wxPyEndAllowThreads(__tstate);
4270 if (PyErr_Occurred()) SWIG_fail;
4271 }
4272 resultobj = SWIG_Py_Void();
4273 return resultobj;
4274 fail:
4275 return NULL;
4276 }
4277
4278
4279 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4280 PyObject *obj;
4281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4282 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4283 return SWIG_Py_Void();
4284 }
4285
4286 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4287 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4288 return 1;
4289 }
4290
4291
4292 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4293 PyObject *pyobj = 0;
4294
4295 {
4296 #if wxUSE_UNICODE
4297 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4298 #else
4299 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4300 #endif
4301 }
4302 return pyobj;
4303 }
4304
4305
4306 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4307 PyObject *resultobj = 0;
4308 wxSystemOptions *result = 0 ;
4309
4310 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 result = (wxSystemOptions *)new wxSystemOptions();
4314 wxPyEndAllowThreads(__tstate);
4315 if (PyErr_Occurred()) SWIG_fail;
4316 }
4317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
4324 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4325 PyObject *resultobj = 0;
4326 wxString *arg1 = 0 ;
4327 wxString *arg2 = 0 ;
4328 bool temp1 = false ;
4329 bool temp2 = false ;
4330 PyObject * obj0 = 0 ;
4331 PyObject * obj1 = 0 ;
4332 char * kwnames[] = {
4333 (char *) "name",(char *) "value", NULL
4334 };
4335
4336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4337 {
4338 arg1 = wxString_in_helper(obj0);
4339 if (arg1 == NULL) SWIG_fail;
4340 temp1 = true;
4341 }
4342 {
4343 arg2 = wxString_in_helper(obj1);
4344 if (arg2 == NULL) SWIG_fail;
4345 temp2 = true;
4346 }
4347 {
4348 PyThreadState* __tstate = wxPyBeginAllowThreads();
4349 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4350 wxPyEndAllowThreads(__tstate);
4351 if (PyErr_Occurred()) SWIG_fail;
4352 }
4353 resultobj = SWIG_Py_Void();
4354 {
4355 if (temp1)
4356 delete arg1;
4357 }
4358 {
4359 if (temp2)
4360 delete arg2;
4361 }
4362 return resultobj;
4363 fail:
4364 {
4365 if (temp1)
4366 delete arg1;
4367 }
4368 {
4369 if (temp2)
4370 delete arg2;
4371 }
4372 return NULL;
4373 }
4374
4375
4376 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj = 0;
4378 wxString *arg1 = 0 ;
4379 int arg2 ;
4380 bool temp1 = false ;
4381 int val2 ;
4382 int ecode2 = 0 ;
4383 PyObject * obj0 = 0 ;
4384 PyObject * obj1 = 0 ;
4385 char * kwnames[] = {
4386 (char *) "name",(char *) "value", NULL
4387 };
4388
4389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4390 {
4391 arg1 = wxString_in_helper(obj0);
4392 if (arg1 == NULL) SWIG_fail;
4393 temp1 = true;
4394 }
4395 ecode2 = SWIG_AsVal_int(obj1, &val2);
4396 if (!SWIG_IsOK(ecode2)) {
4397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4398 }
4399 arg2 = static_cast< int >(val2);
4400 {
4401 PyThreadState* __tstate = wxPyBeginAllowThreads();
4402 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4403 wxPyEndAllowThreads(__tstate);
4404 if (PyErr_Occurred()) SWIG_fail;
4405 }
4406 resultobj = SWIG_Py_Void();
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return resultobj;
4412 fail:
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return NULL;
4418 }
4419
4420
4421 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj = 0;
4423 wxString *arg1 = 0 ;
4424 wxString result;
4425 bool temp1 = false ;
4426 PyObject * obj0 = 0 ;
4427 char * kwnames[] = {
4428 (char *) "name", NULL
4429 };
4430
4431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4432 {
4433 arg1 = wxString_in_helper(obj0);
4434 if (arg1 == NULL) SWIG_fail;
4435 temp1 = true;
4436 }
4437 {
4438 PyThreadState* __tstate = wxPyBeginAllowThreads();
4439 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 {
4444 #if wxUSE_UNICODE
4445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4446 #else
4447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4448 #endif
4449 }
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return resultobj;
4455 fail:
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return NULL;
4461 }
4462
4463
4464 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4465 PyObject *resultobj = 0;
4466 wxString *arg1 = 0 ;
4467 int result;
4468 bool temp1 = false ;
4469 PyObject * obj0 = 0 ;
4470 char * kwnames[] = {
4471 (char *) "name", NULL
4472 };
4473
4474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4475 {
4476 arg1 = wxString_in_helper(obj0);
4477 if (arg1 == NULL) SWIG_fail;
4478 temp1 = true;
4479 }
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4483 wxPyEndAllowThreads(__tstate);
4484 if (PyErr_Occurred()) SWIG_fail;
4485 }
4486 resultobj = SWIG_From_int(static_cast< int >(result));
4487 {
4488 if (temp1)
4489 delete arg1;
4490 }
4491 return resultobj;
4492 fail:
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return NULL;
4498 }
4499
4500
4501 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4502 PyObject *resultobj = 0;
4503 wxString *arg1 = 0 ;
4504 bool result;
4505 bool temp1 = false ;
4506 PyObject * obj0 = 0 ;
4507 char * kwnames[] = {
4508 (char *) "name", NULL
4509 };
4510
4511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4512 {
4513 arg1 = wxString_in_helper(obj0);
4514 if (arg1 == NULL) SWIG_fail;
4515 temp1 = true;
4516 }
4517 {
4518 PyThreadState* __tstate = wxPyBeginAllowThreads();
4519 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4520 wxPyEndAllowThreads(__tstate);
4521 if (PyErr_Occurred()) SWIG_fail;
4522 }
4523 {
4524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4525 }
4526 {
4527 if (temp1)
4528 delete arg1;
4529 }
4530 return resultobj;
4531 fail:
4532 {
4533 if (temp1)
4534 delete arg1;
4535 }
4536 return NULL;
4537 }
4538
4539
4540 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4541 PyObject *resultobj = 0;
4542 wxString *arg1 = 0 ;
4543 bool result;
4544 bool temp1 = false ;
4545 PyObject * obj0 = 0 ;
4546 char * kwnames[] = {
4547 (char *) "name", NULL
4548 };
4549
4550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4551 {
4552 arg1 = wxString_in_helper(obj0);
4553 if (arg1 == NULL) SWIG_fail;
4554 temp1 = true;
4555 }
4556 {
4557 PyThreadState* __tstate = wxPyBeginAllowThreads();
4558 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4559 wxPyEndAllowThreads(__tstate);
4560 if (PyErr_Occurred()) SWIG_fail;
4561 }
4562 {
4563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4564 }
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 return resultobj;
4570 fail:
4571 {
4572 if (temp1)
4573 delete arg1;
4574 }
4575 return NULL;
4576 }
4577
4578
4579 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580 PyObject *obj;
4581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4582 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4583 return SWIG_Py_Void();
4584 }
4585
4586 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4587 return SWIG_Python_InitShadowInstance(args);
4588 }
4589
4590 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4591 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4592 return 1;
4593 }
4594
4595
4596 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4597 PyObject *pyobj = 0;
4598
4599 {
4600 #if wxUSE_UNICODE
4601 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4602 #else
4603 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4604 #endif
4605 }
4606 return pyobj;
4607 }
4608
4609
4610 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4611 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4612 return 1;
4613 }
4614
4615
4616 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4617 PyObject *pyobj = 0;
4618
4619 {
4620 #if wxUSE_UNICODE
4621 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4622 #else
4623 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4624 #endif
4625 }
4626 return pyobj;
4627 }
4628
4629
4630 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4631 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4632 return 1;
4633 }
4634
4635
4636 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4637 PyObject *pyobj = 0;
4638
4639 {
4640 #if wxUSE_UNICODE
4641 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4642 #else
4643 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4644 #endif
4645 }
4646 return pyobj;
4647 }
4648
4649
4650 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4651 PyObject *resultobj = 0;
4652 long result;
4653
4654 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4655 {
4656 PyThreadState* __tstate = wxPyBeginAllowThreads();
4657 result = (long)wxNewId();
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_From_long(static_cast< long >(result));
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj = 0;
4670 long arg1 ;
4671 long val1 ;
4672 int ecode1 = 0 ;
4673 PyObject * obj0 = 0 ;
4674 char * kwnames[] = {
4675 (char *) "id", NULL
4676 };
4677
4678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4679 ecode1 = SWIG_AsVal_long(obj0, &val1);
4680 if (!SWIG_IsOK(ecode1)) {
4681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4682 }
4683 arg1 = static_cast< long >(val1);
4684 {
4685 PyThreadState* __tstate = wxPyBeginAllowThreads();
4686 wxRegisterId(arg1);
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 resultobj = SWIG_Py_Void();
4691 return resultobj;
4692 fail:
4693 return NULL;
4694 }
4695
4696
4697 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4698 PyObject *resultobj = 0;
4699 long result;
4700
4701 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4702 {
4703 PyThreadState* __tstate = wxPyBeginAllowThreads();
4704 result = (long)wxGetCurrentId();
4705 wxPyEndAllowThreads(__tstate);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 resultobj = SWIG_From_long(static_cast< long >(result));
4709 return resultobj;
4710 fail:
4711 return NULL;
4712 }
4713
4714
4715 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4716 PyObject *resultobj = 0;
4717 int arg1 ;
4718 bool result;
4719 int val1 ;
4720 int ecode1 = 0 ;
4721 PyObject * obj0 = 0 ;
4722 char * kwnames[] = {
4723 (char *) "id", NULL
4724 };
4725
4726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4727 ecode1 = SWIG_AsVal_int(obj0, &val1);
4728 if (!SWIG_IsOK(ecode1)) {
4729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4730 }
4731 arg1 = static_cast< int >(val1);
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (bool)wxIsStockID(arg1);
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 {
4739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4740 }
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4748 PyObject *resultobj = 0;
4749 int arg1 ;
4750 wxString *arg2 = 0 ;
4751 bool result;
4752 int val1 ;
4753 int ecode1 = 0 ;
4754 bool temp2 = false ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 char * kwnames[] = {
4758 (char *) "id",(char *) "label", NULL
4759 };
4760
4761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4762 ecode1 = SWIG_AsVal_int(obj0, &val1);
4763 if (!SWIG_IsOK(ecode1)) {
4764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4765 }
4766 arg1 = static_cast< int >(val1);
4767 {
4768 arg2 = wxString_in_helper(obj1);
4769 if (arg2 == NULL) SWIG_fail;
4770 temp2 = true;
4771 }
4772 {
4773 PyThreadState* __tstate = wxPyBeginAllowThreads();
4774 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4775 wxPyEndAllowThreads(__tstate);
4776 if (PyErr_Occurred()) SWIG_fail;
4777 }
4778 {
4779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4780 }
4781 {
4782 if (temp2)
4783 delete arg2;
4784 }
4785 return resultobj;
4786 fail:
4787 {
4788 if (temp2)
4789 delete arg2;
4790 }
4791 return NULL;
4792 }
4793
4794
4795 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4796 PyObject *resultobj = 0;
4797 int arg1 ;
4798 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4799 wxString result;
4800 int val1 ;
4801 int ecode1 = 0 ;
4802 long val2 ;
4803 int ecode2 = 0 ;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 char * kwnames[] = {
4807 (char *) "id",(char *) "flags", NULL
4808 };
4809
4810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4811 ecode1 = SWIG_AsVal_int(obj0, &val1);
4812 if (!SWIG_IsOK(ecode1)) {
4813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4814 }
4815 arg1 = static_cast< int >(val1);
4816 if (obj1) {
4817 ecode2 = SWIG_AsVal_long(obj1, &val2);
4818 if (!SWIG_IsOK(ecode2)) {
4819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4820 }
4821 arg2 = static_cast< long >(val2);
4822 }
4823 {
4824 PyThreadState* __tstate = wxPyBeginAllowThreads();
4825 result = wxGetStockLabel(arg1,arg2);
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 {
4830 #if wxUSE_UNICODE
4831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4832 #else
4833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4834 #endif
4835 }
4836 return resultobj;
4837 fail:
4838 return NULL;
4839 }
4840
4841
4842 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4843 PyObject *resultobj = 0;
4844 int arg1 ;
4845 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4846 wxString result;
4847 int val1 ;
4848 int ecode1 = 0 ;
4849 int val2 ;
4850 int ecode2 = 0 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 char * kwnames[] = {
4854 (char *) "id",(char *) "client", NULL
4855 };
4856
4857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4858 ecode1 = SWIG_AsVal_int(obj0, &val1);
4859 if (!SWIG_IsOK(ecode1)) {
4860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4861 }
4862 arg1 = static_cast< int >(val1);
4863 if (obj1) {
4864 ecode2 = SWIG_AsVal_int(obj1, &val2);
4865 if (!SWIG_IsOK(ecode2)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4867 }
4868 arg2 = static_cast< wxStockHelpStringClient >(val2);
4869 }
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 result = wxGetStockHelpString(arg1,arg2);
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 {
4877 #if wxUSE_UNICODE
4878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4879 #else
4880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4881 #endif
4882 }
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4890 PyObject *resultobj = 0;
4891
4892 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4893 {
4894 if (!wxPyCheckForApp()) SWIG_fail;
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 wxBell();
4897 wxPyEndAllowThreads(__tstate);
4898 if (PyErr_Occurred()) SWIG_fail;
4899 }
4900 resultobj = SWIG_Py_Void();
4901 return resultobj;
4902 fail:
4903 return NULL;
4904 }
4905
4906
4907 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4908 PyObject *resultobj = 0;
4909
4910 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4911 {
4912 if (!wxPyCheckForApp()) SWIG_fail;
4913 PyThreadState* __tstate = wxPyBeginAllowThreads();
4914 wxEndBusyCursor();
4915 wxPyEndAllowThreads(__tstate);
4916 if (PyErr_Occurred()) SWIG_fail;
4917 }
4918 resultobj = SWIG_Py_Void();
4919 return resultobj;
4920 fail:
4921 return NULL;
4922 }
4923
4924
4925 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4926 PyObject *resultobj = 0;
4927 bool arg1 = (bool) true ;
4928 long result;
4929 bool val1 ;
4930 int ecode1 = 0 ;
4931 PyObject * obj0 = 0 ;
4932 char * kwnames[] = {
4933 (char *) "resetTimer", NULL
4934 };
4935
4936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4937 if (obj0) {
4938 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4939 if (!SWIG_IsOK(ecode1)) {
4940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4941 }
4942 arg1 = static_cast< bool >(val1);
4943 }
4944 {
4945 PyThreadState* __tstate = wxPyBeginAllowThreads();
4946 result = (long)wxGetElapsedTime(arg1);
4947 wxPyEndAllowThreads(__tstate);
4948 if (PyErr_Occurred()) SWIG_fail;
4949 }
4950 resultobj = SWIG_From_long(static_cast< long >(result));
4951 return resultobj;
4952 fail:
4953 return NULL;
4954 }
4955
4956
4957 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4958 PyObject *resultobj = 0;
4959 bool result;
4960
4961 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4962 {
4963 PyThreadState* __tstate = wxPyBeginAllowThreads();
4964 result = (bool)wxIsBusy();
4965 wxPyEndAllowThreads(__tstate);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 {
4969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4970 }
4971 return resultobj;
4972 fail:
4973 return NULL;
4974 }
4975
4976
4977 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4978 PyObject *resultobj = 0;
4979 wxString result;
4980
4981 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4982 {
4983 PyThreadState* __tstate = wxPyBeginAllowThreads();
4984 result = wxNow();
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 {
4989 #if wxUSE_UNICODE
4990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4991 #else
4992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4993 #endif
4994 }
4995 return resultobj;
4996 fail:
4997 return NULL;
4998 }
4999
5000
5001 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5002 PyObject *resultobj = 0;
5003 wxString const &arg1_defvalue = wxPyEmptyString ;
5004 wxString *arg1 = (wxString *) &arg1_defvalue ;
5005 bool result;
5006 bool temp1 = false ;
5007 PyObject * obj0 = 0 ;
5008 char * kwnames[] = {
5009 (char *) "command", NULL
5010 };
5011
5012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5013 if (obj0) {
5014 {
5015 arg1 = wxString_in_helper(obj0);
5016 if (arg1 == NULL) SWIG_fail;
5017 temp1 = true;
5018 }
5019 }
5020 {
5021 PyThreadState* __tstate = wxPyBeginAllowThreads();
5022 result = (bool)wxShell((wxString const &)*arg1);
5023 wxPyEndAllowThreads(__tstate);
5024 if (PyErr_Occurred()) SWIG_fail;
5025 }
5026 {
5027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5028 }
5029 {
5030 if (temp1)
5031 delete arg1;
5032 }
5033 return resultobj;
5034 fail:
5035 {
5036 if (temp1)
5037 delete arg1;
5038 }
5039 return NULL;
5040 }
5041
5042
5043 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5044 PyObject *resultobj = 0;
5045
5046 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5047 {
5048 PyThreadState* __tstate = wxPyBeginAllowThreads();
5049 wxStartTimer();
5050 wxPyEndAllowThreads(__tstate);
5051 if (PyErr_Occurred()) SWIG_fail;
5052 }
5053 resultobj = SWIG_Py_Void();
5054 return resultobj;
5055 fail:
5056 return NULL;
5057 }
5058
5059
5060 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5061 PyObject *resultobj = 0;
5062 int *arg1 = (int *) 0 ;
5063 int *arg2 = (int *) 0 ;
5064 int result;
5065 int temp1 ;
5066 int res1 = SWIG_TMPOBJ ;
5067 int temp2 ;
5068 int res2 = SWIG_TMPOBJ ;
5069
5070 arg1 = &temp1;
5071 arg2 = &temp2;
5072 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5073 {
5074 PyThreadState* __tstate = wxPyBeginAllowThreads();
5075 result = (int)wxGetOsVersion(arg1,arg2);
5076 wxPyEndAllowThreads(__tstate);
5077 if (PyErr_Occurred()) SWIG_fail;
5078 }
5079 resultobj = SWIG_From_int(static_cast< int >(result));
5080 if (SWIG_IsTmpObj(res1)) {
5081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5082 } else {
5083 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5085 }
5086 if (SWIG_IsTmpObj(res2)) {
5087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5088 } else {
5089 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5091 }
5092 return resultobj;
5093 fail:
5094 return NULL;
5095 }
5096
5097
5098 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5099 PyObject *resultobj = 0;
5100 wxString result;
5101
5102 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5103 {
5104 PyThreadState* __tstate = wxPyBeginAllowThreads();
5105 result = wxGetOsDescription();
5106 wxPyEndAllowThreads(__tstate);
5107 if (PyErr_Occurred()) SWIG_fail;
5108 }
5109 {
5110 #if wxUSE_UNICODE
5111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5112 #else
5113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5114 #endif
5115 }
5116 return resultobj;
5117 fail:
5118 return NULL;
5119 }
5120
5121
5122 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5123 PyObject *resultobj = 0;
5124 bool result;
5125
5126 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 result = (bool)wxIsPlatformLittleEndian();
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 {
5134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5135 }
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5143 PyObject *resultobj = 0;
5144 bool result;
5145
5146 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5147 {
5148 PyThreadState* __tstate = wxPyBeginAllowThreads();
5149 result = (bool)wxIsPlatform64Bit();
5150 wxPyEndAllowThreads(__tstate);
5151 if (PyErr_Occurred()) SWIG_fail;
5152 }
5153 {
5154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5155 }
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxMemorySize result;
5165
5166 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5167 {
5168 PyThreadState* __tstate = wxPyBeginAllowThreads();
5169 result = wxGetFreeMemory();
5170 wxPyEndAllowThreads(__tstate);
5171 if (PyErr_Occurred()) SWIG_fail;
5172 }
5173 {
5174 #if wxUSE_LONGLONG
5175 resultobj = PyLong_FromLongLong((&result)->GetValue());
5176 #else
5177 resultobj = PyInt_FromLong(result);
5178 #endif
5179 }
5180 return resultobj;
5181 fail:
5182 return NULL;
5183 }
5184
5185
5186 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5187 PyObject *resultobj = 0;
5188 wxShutdownFlags arg1 ;
5189 bool result;
5190 int val1 ;
5191 int ecode1 = 0 ;
5192 PyObject * obj0 = 0 ;
5193 char * kwnames[] = {
5194 (char *) "wFlags", NULL
5195 };
5196
5197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5198 ecode1 = SWIG_AsVal_int(obj0, &val1);
5199 if (!SWIG_IsOK(ecode1)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5201 }
5202 arg1 = static_cast< wxShutdownFlags >(val1);
5203 {
5204 if (!wxPyCheckForApp()) SWIG_fail;
5205 PyThreadState* __tstate = wxPyBeginAllowThreads();
5206 result = (bool)wxShutdown(arg1);
5207 wxPyEndAllowThreads(__tstate);
5208 if (PyErr_Occurred()) SWIG_fail;
5209 }
5210 {
5211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5212 }
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5220 PyObject *resultobj = 0;
5221 int arg1 ;
5222 int val1 ;
5223 int ecode1 = 0 ;
5224 PyObject * obj0 = 0 ;
5225 char * kwnames[] = {
5226 (char *) "secs", NULL
5227 };
5228
5229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5230 ecode1 = SWIG_AsVal_int(obj0, &val1);
5231 if (!SWIG_IsOK(ecode1)) {
5232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5233 }
5234 arg1 = static_cast< int >(val1);
5235 {
5236 PyThreadState* __tstate = wxPyBeginAllowThreads();
5237 wxSleep(arg1);
5238 wxPyEndAllowThreads(__tstate);
5239 if (PyErr_Occurred()) SWIG_fail;
5240 }
5241 resultobj = SWIG_Py_Void();
5242 return resultobj;
5243 fail:
5244 return NULL;
5245 }
5246
5247
5248 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5249 PyObject *resultobj = 0;
5250 unsigned long arg1 ;
5251 unsigned long val1 ;
5252 int ecode1 = 0 ;
5253 PyObject * obj0 = 0 ;
5254 char * kwnames[] = {
5255 (char *) "milliseconds", NULL
5256 };
5257
5258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5259 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5260 if (!SWIG_IsOK(ecode1)) {
5261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5262 }
5263 arg1 = static_cast< unsigned long >(val1);
5264 {
5265 PyThreadState* __tstate = wxPyBeginAllowThreads();
5266 wxMilliSleep(arg1);
5267 wxPyEndAllowThreads(__tstate);
5268 if (PyErr_Occurred()) SWIG_fail;
5269 }
5270 resultobj = SWIG_Py_Void();
5271 return resultobj;
5272 fail:
5273 return NULL;
5274 }
5275
5276
5277 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5278 PyObject *resultobj = 0;
5279 unsigned long arg1 ;
5280 unsigned long val1 ;
5281 int ecode1 = 0 ;
5282 PyObject * obj0 = 0 ;
5283 char * kwnames[] = {
5284 (char *) "microseconds", NULL
5285 };
5286
5287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5288 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5289 if (!SWIG_IsOK(ecode1)) {
5290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5291 }
5292 arg1 = static_cast< unsigned long >(val1);
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 wxMicroSleep(arg1);
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 resultobj = SWIG_Py_Void();
5300 return resultobj;
5301 fail:
5302 return NULL;
5303 }
5304
5305
5306 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj = 0;
5308 bool arg1 ;
5309 bool val1 ;
5310 int ecode1 = 0 ;
5311 PyObject * obj0 = 0 ;
5312 char * kwnames[] = {
5313 (char *) "enable", NULL
5314 };
5315
5316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5317 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5318 if (!SWIG_IsOK(ecode1)) {
5319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5320 }
5321 arg1 = static_cast< bool >(val1);
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 wxEnableTopLevelWindows(arg1);
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 resultobj = SWIG_Py_Void();
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj = 0;
5337 wxString *arg1 = 0 ;
5338 wxString result;
5339 bool temp1 = false ;
5340 PyObject * obj0 = 0 ;
5341 char * kwnames[] = {
5342 (char *) "in", NULL
5343 };
5344
5345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5346 {
5347 arg1 = wxString_in_helper(obj0);
5348 if (arg1 == NULL) SWIG_fail;
5349 temp1 = true;
5350 }
5351 {
5352 PyThreadState* __tstate = wxPyBeginAllowThreads();
5353 result = wxStripMenuCodes((wxString const &)*arg1);
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 {
5358 #if wxUSE_UNICODE
5359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5360 #else
5361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5362 #endif
5363 }
5364 {
5365 if (temp1)
5366 delete arg1;
5367 }
5368 return resultobj;
5369 fail:
5370 {
5371 if (temp1)
5372 delete arg1;
5373 }
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5379 PyObject *resultobj = 0;
5380 wxString result;
5381
5382 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5383 {
5384 PyThreadState* __tstate = wxPyBeginAllowThreads();
5385 result = wxGetEmailAddress();
5386 wxPyEndAllowThreads(__tstate);
5387 if (PyErr_Occurred()) SWIG_fail;
5388 }
5389 {
5390 #if wxUSE_UNICODE
5391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5392 #else
5393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5394 #endif
5395 }
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5403 PyObject *resultobj = 0;
5404 wxString result;
5405
5406 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5407 {
5408 PyThreadState* __tstate = wxPyBeginAllowThreads();
5409 result = wxGetHostName();
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 {
5414 #if wxUSE_UNICODE
5415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5416 #else
5417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5418 #endif
5419 }
5420 return resultobj;
5421 fail:
5422 return NULL;
5423 }
5424
5425
5426 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5427 PyObject *resultobj = 0;
5428 wxString result;
5429
5430 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5431 {
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 result = wxGetFullHostName();
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 {
5438 #if wxUSE_UNICODE
5439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5440 #else
5441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5442 #endif
5443 }
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5451 PyObject *resultobj = 0;
5452 wxString result;
5453
5454 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5455 {
5456 PyThreadState* __tstate = wxPyBeginAllowThreads();
5457 result = wxGetUserId();
5458 wxPyEndAllowThreads(__tstate);
5459 if (PyErr_Occurred()) SWIG_fail;
5460 }
5461 {
5462 #if wxUSE_UNICODE
5463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5464 #else
5465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5466 #endif
5467 }
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5475 PyObject *resultobj = 0;
5476 wxString result;
5477
5478 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5479 {
5480 PyThreadState* __tstate = wxPyBeginAllowThreads();
5481 result = wxGetUserName();
5482 wxPyEndAllowThreads(__tstate);
5483 if (PyErr_Occurred()) SWIG_fail;
5484 }
5485 {
5486 #if wxUSE_UNICODE
5487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5488 #else
5489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5490 #endif
5491 }
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5499 PyObject *resultobj = 0;
5500 wxString result;
5501
5502 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5503 {
5504 PyThreadState* __tstate = wxPyBeginAllowThreads();
5505 result = wxGetHomeDir();
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 {
5510 #if wxUSE_UNICODE
5511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5512 #else
5513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5514 #endif
5515 }
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj = 0;
5524 wxString const &arg1_defvalue = wxPyEmptyString ;
5525 wxString *arg1 = (wxString *) &arg1_defvalue ;
5526 wxString result;
5527 bool temp1 = false ;
5528 PyObject * obj0 = 0 ;
5529 char * kwnames[] = {
5530 (char *) "user", NULL
5531 };
5532
5533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5534 if (obj0) {
5535 {
5536 arg1 = wxString_in_helper(obj0);
5537 if (arg1 == NULL) SWIG_fail;
5538 temp1 = true;
5539 }
5540 }
5541 {
5542 PyThreadState* __tstate = wxPyBeginAllowThreads();
5543 result = wxGetUserHome((wxString const &)*arg1);
5544 wxPyEndAllowThreads(__tstate);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 {
5548 #if wxUSE_UNICODE
5549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5550 #else
5551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5552 #endif
5553 }
5554 {
5555 if (temp1)
5556 delete arg1;
5557 }
5558 return resultobj;
5559 fail:
5560 {
5561 if (temp1)
5562 delete arg1;
5563 }
5564 return NULL;
5565 }
5566
5567
5568 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5569 PyObject *resultobj = 0;
5570 unsigned long result;
5571
5572 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5573 {
5574 PyThreadState* __tstate = wxPyBeginAllowThreads();
5575 result = (unsigned long)wxGetProcessId();
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5580 return resultobj;
5581 fail:
5582 return NULL;
5583 }
5584
5585
5586 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5587 PyObject *resultobj = 0;
5588
5589 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5590 {
5591 PyThreadState* __tstate = wxPyBeginAllowThreads();
5592 wxTrap();
5593 wxPyEndAllowThreads(__tstate);
5594 if (PyErr_Occurred()) SWIG_fail;
5595 }
5596 resultobj = SWIG_Py_Void();
5597 return resultobj;
5598 fail:
5599 return NULL;
5600 }
5601
5602
5603 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj = 0;
5605 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5606 wxString *arg1 = (wxString *) &arg1_defvalue ;
5607 wxString const &arg2_defvalue = wxPyEmptyString ;
5608 wxString *arg2 = (wxString *) &arg2_defvalue ;
5609 wxString const &arg3_defvalue = wxPyEmptyString ;
5610 wxString *arg3 = (wxString *) &arg3_defvalue ;
5611 wxString const &arg4_defvalue = wxPyEmptyString ;
5612 wxString *arg4 = (wxString *) &arg4_defvalue ;
5613 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5614 wxString *arg5 = (wxString *) &arg5_defvalue ;
5615 int arg6 = (int) 0 ;
5616 wxWindow *arg7 = (wxWindow *) NULL ;
5617 int arg8 = (int) -1 ;
5618 int arg9 = (int) -1 ;
5619 wxString result;
5620 bool temp1 = false ;
5621 bool temp2 = false ;
5622 bool temp3 = false ;
5623 bool temp4 = false ;
5624 bool temp5 = false ;
5625 int val6 ;
5626 int ecode6 = 0 ;
5627 void *argp7 = 0 ;
5628 int res7 = 0 ;
5629 int val8 ;
5630 int ecode8 = 0 ;
5631 int val9 ;
5632 int ecode9 = 0 ;
5633 PyObject * obj0 = 0 ;
5634 PyObject * obj1 = 0 ;
5635 PyObject * obj2 = 0 ;
5636 PyObject * obj3 = 0 ;
5637 PyObject * obj4 = 0 ;
5638 PyObject * obj5 = 0 ;
5639 PyObject * obj6 = 0 ;
5640 PyObject * obj7 = 0 ;
5641 PyObject * obj8 = 0 ;
5642 char * kwnames[] = {
5643 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5644 };
5645
5646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5647 if (obj0) {
5648 {
5649 arg1 = wxString_in_helper(obj0);
5650 if (arg1 == NULL) SWIG_fail;
5651 temp1 = true;
5652 }
5653 }
5654 if (obj1) {
5655 {
5656 arg2 = wxString_in_helper(obj1);
5657 if (arg2 == NULL) SWIG_fail;
5658 temp2 = true;
5659 }
5660 }
5661 if (obj2) {
5662 {
5663 arg3 = wxString_in_helper(obj2);
5664 if (arg3 == NULL) SWIG_fail;
5665 temp3 = true;
5666 }
5667 }
5668 if (obj3) {
5669 {
5670 arg4 = wxString_in_helper(obj3);
5671 if (arg4 == NULL) SWIG_fail;
5672 temp4 = true;
5673 }
5674 }
5675 if (obj4) {
5676 {
5677 arg5 = wxString_in_helper(obj4);
5678 if (arg5 == NULL) SWIG_fail;
5679 temp5 = true;
5680 }
5681 }
5682 if (obj5) {
5683 ecode6 = SWIG_AsVal_int(obj5, &val6);
5684 if (!SWIG_IsOK(ecode6)) {
5685 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5686 }
5687 arg6 = static_cast< int >(val6);
5688 }
5689 if (obj6) {
5690 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5691 if (!SWIG_IsOK(res7)) {
5692 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5693 }
5694 arg7 = reinterpret_cast< wxWindow * >(argp7);
5695 }
5696 if (obj7) {
5697 ecode8 = SWIG_AsVal_int(obj7, &val8);
5698 if (!SWIG_IsOK(ecode8)) {
5699 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5700 }
5701 arg8 = static_cast< int >(val8);
5702 }
5703 if (obj8) {
5704 ecode9 = SWIG_AsVal_int(obj8, &val9);
5705 if (!SWIG_IsOK(ecode9)) {
5706 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5707 }
5708 arg9 = static_cast< int >(val9);
5709 }
5710 {
5711 if (!wxPyCheckForApp()) SWIG_fail;
5712 PyThreadState* __tstate = wxPyBeginAllowThreads();
5713 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5714 wxPyEndAllowThreads(__tstate);
5715 if (PyErr_Occurred()) SWIG_fail;
5716 }
5717 {
5718 #if wxUSE_UNICODE
5719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5720 #else
5721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5722 #endif
5723 }
5724 {
5725 if (temp1)
5726 delete arg1;
5727 }
5728 {
5729 if (temp2)
5730 delete arg2;
5731 }
5732 {
5733 if (temp3)
5734 delete arg3;
5735 }
5736 {
5737 if (temp4)
5738 delete arg4;
5739 }
5740 {
5741 if (temp5)
5742 delete arg5;
5743 }
5744 return resultobj;
5745 fail:
5746 {
5747 if (temp1)
5748 delete arg1;
5749 }
5750 {
5751 if (temp2)
5752 delete arg2;
5753 }
5754 {
5755 if (temp3)
5756 delete arg3;
5757 }
5758 {
5759 if (temp4)
5760 delete arg4;
5761 }
5762 {
5763 if (temp5)
5764 delete arg5;
5765 }
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj = 0;
5772 wxString *arg1 = 0 ;
5773 wxString *arg2 = 0 ;
5774 wxString const &arg3_defvalue = wxPyEmptyString ;
5775 wxString *arg3 = (wxString *) &arg3_defvalue ;
5776 wxWindow *arg4 = (wxWindow *) NULL ;
5777 wxString result;
5778 bool temp1 = false ;
5779 bool temp2 = false ;
5780 bool temp3 = false ;
5781 void *argp4 = 0 ;
5782 int res4 = 0 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 PyObject * obj2 = 0 ;
5786 PyObject * obj3 = 0 ;
5787 char * kwnames[] = {
5788 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5789 };
5790
5791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5792 {
5793 arg1 = wxString_in_helper(obj0);
5794 if (arg1 == NULL) SWIG_fail;
5795 temp1 = true;
5796 }
5797 {
5798 arg2 = wxString_in_helper(obj1);
5799 if (arg2 == NULL) SWIG_fail;
5800 temp2 = true;
5801 }
5802 if (obj2) {
5803 {
5804 arg3 = wxString_in_helper(obj2);
5805 if (arg3 == NULL) SWIG_fail;
5806 temp3 = true;
5807 }
5808 }
5809 if (obj3) {
5810 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5811 if (!SWIG_IsOK(res4)) {
5812 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5813 }
5814 arg4 = reinterpret_cast< wxWindow * >(argp4);
5815 }
5816 {
5817 if (!wxPyCheckForApp()) SWIG_fail;
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 {
5824 #if wxUSE_UNICODE
5825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5826 #else
5827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5828 #endif
5829 }
5830 {
5831 if (temp1)
5832 delete arg1;
5833 }
5834 {
5835 if (temp2)
5836 delete arg2;
5837 }
5838 {
5839 if (temp3)
5840 delete arg3;
5841 }
5842 return resultobj;
5843 fail:
5844 {
5845 if (temp1)
5846 delete arg1;
5847 }
5848 {
5849 if (temp2)
5850 delete arg2;
5851 }
5852 {
5853 if (temp3)
5854 delete arg3;
5855 }
5856 return NULL;
5857 }
5858
5859
5860 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5861 PyObject *resultobj = 0;
5862 wxString *arg1 = 0 ;
5863 wxString *arg2 = 0 ;
5864 wxString const &arg3_defvalue = wxPyEmptyString ;
5865 wxString *arg3 = (wxString *) &arg3_defvalue ;
5866 wxWindow *arg4 = (wxWindow *) NULL ;
5867 wxString result;
5868 bool temp1 = false ;
5869 bool temp2 = false ;
5870 bool temp3 = false ;
5871 void *argp4 = 0 ;
5872 int res4 = 0 ;
5873 PyObject * obj0 = 0 ;
5874 PyObject * obj1 = 0 ;
5875 PyObject * obj2 = 0 ;
5876 PyObject * obj3 = 0 ;
5877 char * kwnames[] = {
5878 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5879 };
5880
5881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5882 {
5883 arg1 = wxString_in_helper(obj0);
5884 if (arg1 == NULL) SWIG_fail;
5885 temp1 = true;
5886 }
5887 {
5888 arg2 = wxString_in_helper(obj1);
5889 if (arg2 == NULL) SWIG_fail;
5890 temp2 = true;
5891 }
5892 if (obj2) {
5893 {
5894 arg3 = wxString_in_helper(obj2);
5895 if (arg3 == NULL) SWIG_fail;
5896 temp3 = true;
5897 }
5898 }
5899 if (obj3) {
5900 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5901 if (!SWIG_IsOK(res4)) {
5902 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5903 }
5904 arg4 = reinterpret_cast< wxWindow * >(argp4);
5905 }
5906 {
5907 if (!wxPyCheckForApp()) SWIG_fail;
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 {
5914 #if wxUSE_UNICODE
5915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5916 #else
5917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5918 #endif
5919 }
5920 {
5921 if (temp1)
5922 delete arg1;
5923 }
5924 {
5925 if (temp2)
5926 delete arg2;
5927 }
5928 {
5929 if (temp3)
5930 delete arg3;
5931 }
5932 return resultobj;
5933 fail:
5934 {
5935 if (temp1)
5936 delete arg1;
5937 }
5938 {
5939 if (temp2)
5940 delete arg2;
5941 }
5942 {
5943 if (temp3)
5944 delete arg3;
5945 }
5946 return NULL;
5947 }
5948
5949
5950 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5951 PyObject *resultobj = 0;
5952 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5953 wxString *arg1 = (wxString *) &arg1_defvalue ;
5954 wxString const &arg2_defvalue = wxPyEmptyString ;
5955 wxString *arg2 = (wxString *) &arg2_defvalue ;
5956 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5957 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5958 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5959 wxWindow *arg5 = (wxWindow *) NULL ;
5960 wxString result;
5961 bool temp1 = false ;
5962 bool temp2 = false ;
5963 long val3 ;
5964 int ecode3 = 0 ;
5965 wxPoint temp4 ;
5966 void *argp5 = 0 ;
5967 int res5 = 0 ;
5968 PyObject * obj0 = 0 ;
5969 PyObject * obj1 = 0 ;
5970 PyObject * obj2 = 0 ;
5971 PyObject * obj3 = 0 ;
5972 PyObject * obj4 = 0 ;
5973 char * kwnames[] = {
5974 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5975 };
5976
5977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5978 if (obj0) {
5979 {
5980 arg1 = wxString_in_helper(obj0);
5981 if (arg1 == NULL) SWIG_fail;
5982 temp1 = true;
5983 }
5984 }
5985 if (obj1) {
5986 {
5987 arg2 = wxString_in_helper(obj1);
5988 if (arg2 == NULL) SWIG_fail;
5989 temp2 = true;
5990 }
5991 }
5992 if (obj2) {
5993 ecode3 = SWIG_AsVal_long(obj2, &val3);
5994 if (!SWIG_IsOK(ecode3)) {
5995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5996 }
5997 arg3 = static_cast< long >(val3);
5998 }
5999 if (obj3) {
6000 {
6001 arg4 = &temp4;
6002 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6003 }
6004 }
6005 if (obj4) {
6006 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6007 if (!SWIG_IsOK(res5)) {
6008 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6009 }
6010 arg5 = reinterpret_cast< wxWindow * >(argp5);
6011 }
6012 {
6013 if (!wxPyCheckForApp()) SWIG_fail;
6014 PyThreadState* __tstate = wxPyBeginAllowThreads();
6015 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6016 wxPyEndAllowThreads(__tstate);
6017 if (PyErr_Occurred()) SWIG_fail;
6018 }
6019 {
6020 #if wxUSE_UNICODE
6021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6022 #else
6023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6024 #endif
6025 }
6026 {
6027 if (temp1)
6028 delete arg1;
6029 }
6030 {
6031 if (temp2)
6032 delete arg2;
6033 }
6034 return resultobj;
6035 fail:
6036 {
6037 if (temp1)
6038 delete arg1;
6039 }
6040 {
6041 if (temp2)
6042 delete arg2;
6043 }
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj = 0;
6050 wxString *arg1 = 0 ;
6051 wxString const &arg2_defvalue = wxPyEmptyString ;
6052 wxString *arg2 = (wxString *) &arg2_defvalue ;
6053 wxString const &arg3_defvalue = wxPyEmptyString ;
6054 wxString *arg3 = (wxString *) &arg3_defvalue ;
6055 wxWindow *arg4 = (wxWindow *) NULL ;
6056 int arg5 = (int) -1 ;
6057 int arg6 = (int) -1 ;
6058 bool arg7 = (bool) true ;
6059 wxString result;
6060 bool temp1 = false ;
6061 bool temp2 = false ;
6062 bool temp3 = false ;
6063 void *argp4 = 0 ;
6064 int res4 = 0 ;
6065 int val5 ;
6066 int ecode5 = 0 ;
6067 int val6 ;
6068 int ecode6 = 0 ;
6069 bool val7 ;
6070 int ecode7 = 0 ;
6071 PyObject * obj0 = 0 ;
6072 PyObject * obj1 = 0 ;
6073 PyObject * obj2 = 0 ;
6074 PyObject * obj3 = 0 ;
6075 PyObject * obj4 = 0 ;
6076 PyObject * obj5 = 0 ;
6077 PyObject * obj6 = 0 ;
6078 char * kwnames[] = {
6079 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6080 };
6081
6082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6083 {
6084 arg1 = wxString_in_helper(obj0);
6085 if (arg1 == NULL) SWIG_fail;
6086 temp1 = true;
6087 }
6088 if (obj1) {
6089 {
6090 arg2 = wxString_in_helper(obj1);
6091 if (arg2 == NULL) SWIG_fail;
6092 temp2 = true;
6093 }
6094 }
6095 if (obj2) {
6096 {
6097 arg3 = wxString_in_helper(obj2);
6098 if (arg3 == NULL) SWIG_fail;
6099 temp3 = true;
6100 }
6101 }
6102 if (obj3) {
6103 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6104 if (!SWIG_IsOK(res4)) {
6105 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6106 }
6107 arg4 = reinterpret_cast< wxWindow * >(argp4);
6108 }
6109 if (obj4) {
6110 ecode5 = SWIG_AsVal_int(obj4, &val5);
6111 if (!SWIG_IsOK(ecode5)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6113 }
6114 arg5 = static_cast< int >(val5);
6115 }
6116 if (obj5) {
6117 ecode6 = SWIG_AsVal_int(obj5, &val6);
6118 if (!SWIG_IsOK(ecode6)) {
6119 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6120 }
6121 arg6 = static_cast< int >(val6);
6122 }
6123 if (obj6) {
6124 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6125 if (!SWIG_IsOK(ecode7)) {
6126 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6127 }
6128 arg7 = static_cast< bool >(val7);
6129 }
6130 {
6131 if (!wxPyCheckForApp()) SWIG_fail;
6132 PyThreadState* __tstate = wxPyBeginAllowThreads();
6133 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6134 wxPyEndAllowThreads(__tstate);
6135 if (PyErr_Occurred()) SWIG_fail;
6136 }
6137 {
6138 #if wxUSE_UNICODE
6139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6140 #else
6141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6142 #endif
6143 }
6144 {
6145 if (temp1)
6146 delete arg1;
6147 }
6148 {
6149 if (temp2)
6150 delete arg2;
6151 }
6152 {
6153 if (temp3)
6154 delete arg3;
6155 }
6156 return resultobj;
6157 fail:
6158 {
6159 if (temp1)
6160 delete arg1;
6161 }
6162 {
6163 if (temp2)
6164 delete arg2;
6165 }
6166 {
6167 if (temp3)
6168 delete arg3;
6169 }
6170 return NULL;
6171 }
6172
6173
6174 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6175 PyObject *resultobj = 0;
6176 wxString *arg1 = 0 ;
6177 wxString const &arg2_defvalue = wxPyEmptyString ;
6178 wxString *arg2 = (wxString *) &arg2_defvalue ;
6179 wxString const &arg3_defvalue = wxPyEmptyString ;
6180 wxString *arg3 = (wxString *) &arg3_defvalue ;
6181 wxWindow *arg4 = (wxWindow *) NULL ;
6182 wxString result;
6183 bool temp1 = false ;
6184 bool temp2 = false ;
6185 bool temp3 = false ;
6186 void *argp4 = 0 ;
6187 int res4 = 0 ;
6188 PyObject * obj0 = 0 ;
6189 PyObject * obj1 = 0 ;
6190 PyObject * obj2 = 0 ;
6191 PyObject * obj3 = 0 ;
6192 char * kwnames[] = {
6193 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6194 };
6195
6196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6197 {
6198 arg1 = wxString_in_helper(obj0);
6199 if (arg1 == NULL) SWIG_fail;
6200 temp1 = true;
6201 }
6202 if (obj1) {
6203 {
6204 arg2 = wxString_in_helper(obj1);
6205 if (arg2 == NULL) SWIG_fail;
6206 temp2 = true;
6207 }
6208 }
6209 if (obj2) {
6210 {
6211 arg3 = wxString_in_helper(obj2);
6212 if (arg3 == NULL) SWIG_fail;
6213 temp3 = true;
6214 }
6215 }
6216 if (obj3) {
6217 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6218 if (!SWIG_IsOK(res4)) {
6219 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6220 }
6221 arg4 = reinterpret_cast< wxWindow * >(argp4);
6222 }
6223 {
6224 if (!wxPyCheckForApp()) SWIG_fail;
6225 PyThreadState* __tstate = wxPyBeginAllowThreads();
6226 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6227 wxPyEndAllowThreads(__tstate);
6228 if (PyErr_Occurred()) SWIG_fail;
6229 }
6230 {
6231 #if wxUSE_UNICODE
6232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6233 #else
6234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6235 #endif
6236 }
6237 {
6238 if (temp1)
6239 delete arg1;
6240 }
6241 {
6242 if (temp2)
6243 delete arg2;
6244 }
6245 {
6246 if (temp3)
6247 delete arg3;
6248 }
6249 return resultobj;
6250 fail:
6251 {
6252 if (temp1)
6253 delete arg1;
6254 }
6255 {
6256 if (temp2)
6257 delete arg2;
6258 }
6259 {
6260 if (temp3)
6261 delete arg3;
6262 }
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj = 0;
6269 wxString *arg1 = 0 ;
6270 wxString *arg2 = 0 ;
6271 int arg3 ;
6272 wxString *arg4 = (wxString *) 0 ;
6273 wxWindow *arg5 = (wxWindow *) NULL ;
6274 int arg6 = (int) -1 ;
6275 int arg7 = (int) -1 ;
6276 bool arg8 = (bool) true ;
6277 int arg9 = (int) 150 ;
6278 int arg10 = (int) 200 ;
6279 wxString result;
6280 bool temp1 = false ;
6281 bool temp2 = false ;
6282 void *argp5 = 0 ;
6283 int res5 = 0 ;
6284 int val6 ;
6285 int ecode6 = 0 ;
6286 int val7 ;
6287 int ecode7 = 0 ;
6288 bool val8 ;
6289 int ecode8 = 0 ;
6290 int val9 ;
6291 int ecode9 = 0 ;
6292 int val10 ;
6293 int ecode10 = 0 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 PyObject * obj2 = 0 ;
6297 PyObject * obj3 = 0 ;
6298 PyObject * obj4 = 0 ;
6299 PyObject * obj5 = 0 ;
6300 PyObject * obj6 = 0 ;
6301 PyObject * obj7 = 0 ;
6302 PyObject * obj8 = 0 ;
6303 char * kwnames[] = {
6304 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6305 };
6306
6307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6308 {
6309 arg1 = wxString_in_helper(obj0);
6310 if (arg1 == NULL) SWIG_fail;
6311 temp1 = true;
6312 }
6313 {
6314 arg2 = wxString_in_helper(obj1);
6315 if (arg2 == NULL) SWIG_fail;
6316 temp2 = true;
6317 }
6318 {
6319 arg3 = PyList_Size(obj2);
6320 arg4 = wxString_LIST_helper(obj2);
6321 if (arg4 == NULL) SWIG_fail;
6322 }
6323 if (obj3) {
6324 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6325 if (!SWIG_IsOK(res5)) {
6326 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6327 }
6328 arg5 = reinterpret_cast< wxWindow * >(argp5);
6329 }
6330 if (obj4) {
6331 ecode6 = SWIG_AsVal_int(obj4, &val6);
6332 if (!SWIG_IsOK(ecode6)) {
6333 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6334 }
6335 arg6 = static_cast< int >(val6);
6336 }
6337 if (obj5) {
6338 ecode7 = SWIG_AsVal_int(obj5, &val7);
6339 if (!SWIG_IsOK(ecode7)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6341 }
6342 arg7 = static_cast< int >(val7);
6343 }
6344 if (obj6) {
6345 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6346 if (!SWIG_IsOK(ecode8)) {
6347 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6348 }
6349 arg8 = static_cast< bool >(val8);
6350 }
6351 if (obj7) {
6352 ecode9 = SWIG_AsVal_int(obj7, &val9);
6353 if (!SWIG_IsOK(ecode9)) {
6354 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6355 }
6356 arg9 = static_cast< int >(val9);
6357 }
6358 if (obj8) {
6359 ecode10 = SWIG_AsVal_int(obj8, &val10);
6360 if (!SWIG_IsOK(ecode10)) {
6361 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6362 }
6363 arg10 = static_cast< int >(val10);
6364 }
6365 {
6366 if (!wxPyCheckForApp()) SWIG_fail;
6367 PyThreadState* __tstate = wxPyBeginAllowThreads();
6368 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6369 wxPyEndAllowThreads(__tstate);
6370 if (PyErr_Occurred()) SWIG_fail;
6371 }
6372 {
6373 #if wxUSE_UNICODE
6374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6375 #else
6376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6377 #endif
6378 }
6379 {
6380 if (temp1)
6381 delete arg1;
6382 }
6383 {
6384 if (temp2)
6385 delete arg2;
6386 }
6387 {
6388 if (arg4) delete [] arg4;
6389 }
6390 return resultobj;
6391 fail:
6392 {
6393 if (temp1)
6394 delete arg1;
6395 }
6396 {
6397 if (temp2)
6398 delete arg2;
6399 }
6400 {
6401 if (arg4) delete [] arg4;
6402 }
6403 return NULL;
6404 }
6405
6406
6407 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6408 PyObject *resultobj = 0;
6409 wxString *arg1 = 0 ;
6410 wxString *arg2 = 0 ;
6411 int arg3 ;
6412 wxString *arg4 = (wxString *) 0 ;
6413 wxWindow *arg5 = (wxWindow *) NULL ;
6414 int arg6 = (int) -1 ;
6415 int arg7 = (int) -1 ;
6416 bool arg8 = (bool) true ;
6417 int arg9 = (int) 150 ;
6418 int arg10 = (int) 200 ;
6419 int result;
6420 bool temp1 = false ;
6421 bool temp2 = false ;
6422 void *argp5 = 0 ;
6423 int res5 = 0 ;
6424 int val6 ;
6425 int ecode6 = 0 ;
6426 int val7 ;
6427 int ecode7 = 0 ;
6428 bool val8 ;
6429 int ecode8 = 0 ;
6430 int val9 ;
6431 int ecode9 = 0 ;
6432 int val10 ;
6433 int ecode10 = 0 ;
6434 PyObject * obj0 = 0 ;
6435 PyObject * obj1 = 0 ;
6436 PyObject * obj2 = 0 ;
6437 PyObject * obj3 = 0 ;
6438 PyObject * obj4 = 0 ;
6439 PyObject * obj5 = 0 ;
6440 PyObject * obj6 = 0 ;
6441 PyObject * obj7 = 0 ;
6442 PyObject * obj8 = 0 ;
6443 char * kwnames[] = {
6444 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6445 };
6446
6447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6448 {
6449 arg1 = wxString_in_helper(obj0);
6450 if (arg1 == NULL) SWIG_fail;
6451 temp1 = true;
6452 }
6453 {
6454 arg2 = wxString_in_helper(obj1);
6455 if (arg2 == NULL) SWIG_fail;
6456 temp2 = true;
6457 }
6458 {
6459 arg3 = PyList_Size(obj2);
6460 arg4 = wxString_LIST_helper(obj2);
6461 if (arg4 == NULL) SWIG_fail;
6462 }
6463 if (obj3) {
6464 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6465 if (!SWIG_IsOK(res5)) {
6466 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6467 }
6468 arg5 = reinterpret_cast< wxWindow * >(argp5);
6469 }
6470 if (obj4) {
6471 ecode6 = SWIG_AsVal_int(obj4, &val6);
6472 if (!SWIG_IsOK(ecode6)) {
6473 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6474 }
6475 arg6 = static_cast< int >(val6);
6476 }
6477 if (obj5) {
6478 ecode7 = SWIG_AsVal_int(obj5, &val7);
6479 if (!SWIG_IsOK(ecode7)) {
6480 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6481 }
6482 arg7 = static_cast< int >(val7);
6483 }
6484 if (obj6) {
6485 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6486 if (!SWIG_IsOK(ecode8)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6488 }
6489 arg8 = static_cast< bool >(val8);
6490 }
6491 if (obj7) {
6492 ecode9 = SWIG_AsVal_int(obj7, &val9);
6493 if (!SWIG_IsOK(ecode9)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6495 }
6496 arg9 = static_cast< int >(val9);
6497 }
6498 if (obj8) {
6499 ecode10 = SWIG_AsVal_int(obj8, &val10);
6500 if (!SWIG_IsOK(ecode10)) {
6501 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6502 }
6503 arg10 = static_cast< int >(val10);
6504 }
6505 {
6506 if (!wxPyCheckForApp()) SWIG_fail;
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_From_int(static_cast< int >(result));
6513 {
6514 if (temp1)
6515 delete arg1;
6516 }
6517 {
6518 if (temp2)
6519 delete arg2;
6520 }
6521 {
6522 if (arg4) delete [] arg4;
6523 }
6524 return resultobj;
6525 fail:
6526 {
6527 if (temp1)
6528 delete arg1;
6529 }
6530 {
6531 if (temp2)
6532 delete arg2;
6533 }
6534 {
6535 if (arg4) delete [] arg4;
6536 }
6537 return NULL;
6538 }
6539
6540
6541 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6542 PyObject *resultobj = 0;
6543 wxString *arg1 = 0 ;
6544 wxString const &arg2_defvalue = wxPyEmptyString ;
6545 wxString *arg2 = (wxString *) &arg2_defvalue ;
6546 int arg3 = (int) wxOK|wxCENTRE ;
6547 wxWindow *arg4 = (wxWindow *) NULL ;
6548 int arg5 = (int) -1 ;
6549 int arg6 = (int) -1 ;
6550 int result;
6551 bool temp1 = false ;
6552 bool temp2 = false ;
6553 int val3 ;
6554 int ecode3 = 0 ;
6555 void *argp4 = 0 ;
6556 int res4 = 0 ;
6557 int val5 ;
6558 int ecode5 = 0 ;
6559 int val6 ;
6560 int ecode6 = 0 ;
6561 PyObject * obj0 = 0 ;
6562 PyObject * obj1 = 0 ;
6563 PyObject * obj2 = 0 ;
6564 PyObject * obj3 = 0 ;
6565 PyObject * obj4 = 0 ;
6566 PyObject * obj5 = 0 ;
6567 char * kwnames[] = {
6568 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6569 };
6570
6571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6572 {
6573 arg1 = wxString_in_helper(obj0);
6574 if (arg1 == NULL) SWIG_fail;
6575 temp1 = true;
6576 }
6577 if (obj1) {
6578 {
6579 arg2 = wxString_in_helper(obj1);
6580 if (arg2 == NULL) SWIG_fail;
6581 temp2 = true;
6582 }
6583 }
6584 if (obj2) {
6585 ecode3 = SWIG_AsVal_int(obj2, &val3);
6586 if (!SWIG_IsOK(ecode3)) {
6587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6588 }
6589 arg3 = static_cast< int >(val3);
6590 }
6591 if (obj3) {
6592 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6593 if (!SWIG_IsOK(res4)) {
6594 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6595 }
6596 arg4 = reinterpret_cast< wxWindow * >(argp4);
6597 }
6598 if (obj4) {
6599 ecode5 = SWIG_AsVal_int(obj4, &val5);
6600 if (!SWIG_IsOK(ecode5)) {
6601 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6602 }
6603 arg5 = static_cast< int >(val5);
6604 }
6605 if (obj5) {
6606 ecode6 = SWIG_AsVal_int(obj5, &val6);
6607 if (!SWIG_IsOK(ecode6)) {
6608 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6609 }
6610 arg6 = static_cast< int >(val6);
6611 }
6612 {
6613 if (!wxPyCheckForApp()) SWIG_fail;
6614 PyThreadState* __tstate = wxPyBeginAllowThreads();
6615 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 resultobj = SWIG_From_int(static_cast< int >(result));
6620 {
6621 if (temp1)
6622 delete arg1;
6623 }
6624 {
6625 if (temp2)
6626 delete arg2;
6627 }
6628 return resultobj;
6629 fail:
6630 {
6631 if (temp1)
6632 delete arg1;
6633 }
6634 {
6635 if (temp2)
6636 delete arg2;
6637 }
6638 return NULL;
6639 }
6640
6641
6642 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6643 PyObject *resultobj = 0;
6644 wxString *arg1 = 0 ;
6645 wxString *arg2 = 0 ;
6646 wxString *arg3 = 0 ;
6647 long arg4 ;
6648 long arg5 = (long) 0 ;
6649 long arg6 = (long) 100 ;
6650 wxWindow *arg7 = (wxWindow *) NULL ;
6651 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6652 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6653 long result;
6654 bool temp1 = false ;
6655 bool temp2 = false ;
6656 bool temp3 = false ;
6657 long val4 ;
6658 int ecode4 = 0 ;
6659 long val5 ;
6660 int ecode5 = 0 ;
6661 long val6 ;
6662 int ecode6 = 0 ;
6663 void *argp7 = 0 ;
6664 int res7 = 0 ;
6665 wxPoint temp8 ;
6666 PyObject * obj0 = 0 ;
6667 PyObject * obj1 = 0 ;
6668 PyObject * obj2 = 0 ;
6669 PyObject * obj3 = 0 ;
6670 PyObject * obj4 = 0 ;
6671 PyObject * obj5 = 0 ;
6672 PyObject * obj6 = 0 ;
6673 PyObject * obj7 = 0 ;
6674 char * kwnames[] = {
6675 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6676 };
6677
6678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6679 {
6680 arg1 = wxString_in_helper(obj0);
6681 if (arg1 == NULL) SWIG_fail;
6682 temp1 = true;
6683 }
6684 {
6685 arg2 = wxString_in_helper(obj1);
6686 if (arg2 == NULL) SWIG_fail;
6687 temp2 = true;
6688 }
6689 {
6690 arg3 = wxString_in_helper(obj2);
6691 if (arg3 == NULL) SWIG_fail;
6692 temp3 = true;
6693 }
6694 ecode4 = SWIG_AsVal_long(obj3, &val4);
6695 if (!SWIG_IsOK(ecode4)) {
6696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6697 }
6698 arg4 = static_cast< long >(val4);
6699 if (obj4) {
6700 ecode5 = SWIG_AsVal_long(obj4, &val5);
6701 if (!SWIG_IsOK(ecode5)) {
6702 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6703 }
6704 arg5 = static_cast< long >(val5);
6705 }
6706 if (obj5) {
6707 ecode6 = SWIG_AsVal_long(obj5, &val6);
6708 if (!SWIG_IsOK(ecode6)) {
6709 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6710 }
6711 arg6 = static_cast< long >(val6);
6712 }
6713 if (obj6) {
6714 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6715 if (!SWIG_IsOK(res7)) {
6716 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6717 }
6718 arg7 = reinterpret_cast< wxWindow * >(argp7);
6719 }
6720 if (obj7) {
6721 {
6722 arg8 = &temp8;
6723 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6724 }
6725 }
6726 {
6727 if (!wxPyCheckForApp()) SWIG_fail;
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 resultobj = SWIG_From_long(static_cast< long >(result));
6734 {
6735 if (temp1)
6736 delete arg1;
6737 }
6738 {
6739 if (temp2)
6740 delete arg2;
6741 }
6742 {
6743 if (temp3)
6744 delete arg3;
6745 }
6746 return resultobj;
6747 fail:
6748 {
6749 if (temp1)
6750 delete arg1;
6751 }
6752 {
6753 if (temp2)
6754 delete arg2;
6755 }
6756 {
6757 if (temp3)
6758 delete arg3;
6759 }
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 bool result;
6767
6768 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6769 {
6770 if (!wxPyCheckForApp()) SWIG_fail;
6771 PyThreadState* __tstate = wxPyBeginAllowThreads();
6772 result = (bool)wxColourDisplay();
6773 wxPyEndAllowThreads(__tstate);
6774 if (PyErr_Occurred()) SWIG_fail;
6775 }
6776 {
6777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6778 }
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6786 PyObject *resultobj = 0;
6787 int result;
6788
6789 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6790 {
6791 if (!wxPyCheckForApp()) SWIG_fail;
6792 PyThreadState* __tstate = wxPyBeginAllowThreads();
6793 result = (int)wxDisplayDepth();
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 resultobj = SWIG_From_int(static_cast< int >(result));
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6805 PyObject *resultobj = 0;
6806 int result;
6807
6808 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6809 {
6810 if (!wxPyCheckForApp()) SWIG_fail;
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 result = (int)wxGetDisplayDepth();
6813 wxPyEndAllowThreads(__tstate);
6814 if (PyErr_Occurred()) SWIG_fail;
6815 }
6816 resultobj = SWIG_From_int(static_cast< int >(result));
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6824 PyObject *resultobj = 0;
6825 int *arg1 = (int *) 0 ;
6826 int *arg2 = (int *) 0 ;
6827 int temp1 ;
6828 int res1 = SWIG_TMPOBJ ;
6829 int temp2 ;
6830 int res2 = SWIG_TMPOBJ ;
6831
6832 arg1 = &temp1;
6833 arg2 = &temp2;
6834 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6835 {
6836 if (!wxPyCheckForApp()) SWIG_fail;
6837 PyThreadState* __tstate = wxPyBeginAllowThreads();
6838 wxDisplaySize(arg1,arg2);
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 resultobj = SWIG_Py_Void();
6843 if (SWIG_IsTmpObj(res1)) {
6844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6845 } else {
6846 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6848 }
6849 if (SWIG_IsTmpObj(res2)) {
6850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6851 } else {
6852 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6854 }
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6862 PyObject *resultobj = 0;
6863 wxSize result;
6864
6865 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6866 {
6867 if (!wxPyCheckForApp()) SWIG_fail;
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 result = wxGetDisplaySize();
6870 wxPyEndAllowThreads(__tstate);
6871 if (PyErr_Occurred()) SWIG_fail;
6872 }
6873 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6874 return resultobj;
6875 fail:
6876 return NULL;
6877 }
6878
6879
6880 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6881 PyObject *resultobj = 0;
6882 int *arg1 = (int *) 0 ;
6883 int *arg2 = (int *) 0 ;
6884 int temp1 ;
6885 int res1 = SWIG_TMPOBJ ;
6886 int temp2 ;
6887 int res2 = SWIG_TMPOBJ ;
6888
6889 arg1 = &temp1;
6890 arg2 = &temp2;
6891 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6892 {
6893 if (!wxPyCheckForApp()) SWIG_fail;
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 wxDisplaySizeMM(arg1,arg2);
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 resultobj = SWIG_Py_Void();
6900 if (SWIG_IsTmpObj(res1)) {
6901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6902 } else {
6903 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6905 }
6906 if (SWIG_IsTmpObj(res2)) {
6907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6908 } else {
6909 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6911 }
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6919 PyObject *resultobj = 0;
6920 wxSize result;
6921
6922 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6923 {
6924 if (!wxPyCheckForApp()) SWIG_fail;
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 result = wxGetDisplaySizeMM();
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6938 PyObject *resultobj = 0;
6939 int *arg1 = (int *) 0 ;
6940 int *arg2 = (int *) 0 ;
6941 int *arg3 = (int *) 0 ;
6942 int *arg4 = (int *) 0 ;
6943 int temp1 ;
6944 int res1 = SWIG_TMPOBJ ;
6945 int temp2 ;
6946 int res2 = SWIG_TMPOBJ ;
6947 int temp3 ;
6948 int res3 = SWIG_TMPOBJ ;
6949 int temp4 ;
6950 int res4 = SWIG_TMPOBJ ;
6951
6952 arg1 = &temp1;
6953 arg2 = &temp2;
6954 arg3 = &temp3;
6955 arg4 = &temp4;
6956 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6957 {
6958 if (!wxPyCheckForApp()) SWIG_fail;
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6961 wxPyEndAllowThreads(__tstate);
6962 if (PyErr_Occurred()) SWIG_fail;
6963 }
6964 resultobj = SWIG_Py_Void();
6965 if (SWIG_IsTmpObj(res1)) {
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6967 } else {
6968 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6970 }
6971 if (SWIG_IsTmpObj(res2)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6976 }
6977 if (SWIG_IsTmpObj(res3)) {
6978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6979 } else {
6980 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6982 }
6983 if (SWIG_IsTmpObj(res4)) {
6984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6985 } else {
6986 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6988 }
6989 return resultobj;
6990 fail:
6991 return NULL;
6992 }
6993
6994
6995 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6996 PyObject *resultobj = 0;
6997 wxRect result;
6998
6999 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7000 {
7001 if (!wxPyCheckForApp()) SWIG_fail;
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 result = wxGetClientDisplayRect();
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7008 return resultobj;
7009 fail:
7010 return NULL;
7011 }
7012
7013
7014 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7015 PyObject *resultobj = 0;
7016 wxCursor *arg1 = 0 ;
7017 void *argp1 = 0 ;
7018 int res1 = 0 ;
7019 PyObject * obj0 = 0 ;
7020 char * kwnames[] = {
7021 (char *) "cursor", NULL
7022 };
7023
7024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7025 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7026 if (!SWIG_IsOK(res1)) {
7027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7028 }
7029 if (!argp1) {
7030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7031 }
7032 arg1 = reinterpret_cast< wxCursor * >(argp1);
7033 {
7034 if (!wxPyCheckForApp()) SWIG_fail;
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 wxSetCursor(*arg1);
7037 wxPyEndAllowThreads(__tstate);
7038 if (PyErr_Occurred()) SWIG_fail;
7039 }
7040 resultobj = SWIG_Py_Void();
7041 return resultobj;
7042 fail:
7043 return NULL;
7044 }
7045
7046
7047 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7048 PyObject *resultobj = 0;
7049 void *result = 0 ;
7050
7051 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7052 {
7053 if (!wxPyCheckForApp()) SWIG_fail;
7054 PyThreadState* __tstate = wxPyBeginAllowThreads();
7055 result = (void *)wxGetXDisplay();
7056 wxPyEndAllowThreads(__tstate);
7057 if (PyErr_Occurred()) SWIG_fail;
7058 }
7059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7060 return resultobj;
7061 fail:
7062 return NULL;
7063 }
7064
7065
7066 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj = 0;
7068 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7069 void *argp1 = 0 ;
7070 int res1 = 0 ;
7071 PyObject * obj0 = 0 ;
7072 char * kwnames[] = {
7073 (char *) "cursor", NULL
7074 };
7075
7076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7077 if (obj0) {
7078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7079 if (!SWIG_IsOK(res1)) {
7080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7081 }
7082 arg1 = reinterpret_cast< wxCursor * >(argp1);
7083 }
7084 {
7085 if (!wxPyCheckForApp()) SWIG_fail;
7086 PyThreadState* __tstate = wxPyBeginAllowThreads();
7087 wxBeginBusyCursor(arg1);
7088 wxPyEndAllowThreads(__tstate);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 resultobj = SWIG_Py_Void();
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7099 PyObject *resultobj = 0;
7100 wxPoint result;
7101
7102 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7103 {
7104 if (!wxPyCheckForApp()) SWIG_fail;
7105 PyThreadState* __tstate = wxPyBeginAllowThreads();
7106 result = wxGetMousePosition();
7107 wxPyEndAllowThreads(__tstate);
7108 if (PyErr_Occurred()) SWIG_fail;
7109 }
7110 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7111 return resultobj;
7112 fail:
7113 return NULL;
7114 }
7115
7116
7117 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7118 PyObject *resultobj = 0;
7119 wxWindow *result = 0 ;
7120
7121 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7122 {
7123 if (!wxPyCheckForApp()) SWIG_fail;
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (wxWindow *)FindWindowAtPointer();
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 {
7130 resultobj = wxPyMake_wxObject(result, 0);
7131 }
7132 return resultobj;
7133 fail:
7134 return NULL;
7135 }
7136
7137
7138 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7139 PyObject *resultobj = 0;
7140 wxWindow *result = 0 ;
7141
7142 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7143 {
7144 if (!wxPyCheckForApp()) SWIG_fail;
7145 PyThreadState* __tstate = wxPyBeginAllowThreads();
7146 result = (wxWindow *)wxGetActiveWindow();
7147 wxPyEndAllowThreads(__tstate);
7148 if (PyErr_Occurred()) SWIG_fail;
7149 }
7150 {
7151 resultobj = wxPyMake_wxObject(result, 0);
7152 }
7153 return resultobj;
7154 fail:
7155 return NULL;
7156 }
7157
7158
7159 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7160 PyObject *resultobj = 0;
7161 wxPoint *arg1 = 0 ;
7162 wxWindow *result = 0 ;
7163 wxPoint temp1 ;
7164 PyObject * obj0 = 0 ;
7165 char * kwnames[] = {
7166 (char *) "pt", NULL
7167 };
7168
7169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7170 {
7171 arg1 = &temp1;
7172 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7173 }
7174 {
7175 if (!wxPyCheckForApp()) SWIG_fail;
7176 PyThreadState* __tstate = wxPyBeginAllowThreads();
7177 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7178 wxPyEndAllowThreads(__tstate);
7179 if (PyErr_Occurred()) SWIG_fail;
7180 }
7181 {
7182 resultobj = wxPyMake_wxObject(result, 0);
7183 }
7184 return resultobj;
7185 fail:
7186 return NULL;
7187 }
7188
7189
7190 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7191 PyObject *resultobj = 0;
7192 wxPoint *arg1 = 0 ;
7193 wxWindow *result = 0 ;
7194 wxPoint temp1 ;
7195 PyObject * obj0 = 0 ;
7196 char * kwnames[] = {
7197 (char *) "pt", NULL
7198 };
7199
7200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7201 {
7202 arg1 = &temp1;
7203 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7204 }
7205 {
7206 if (!wxPyCheckForApp()) SWIG_fail;
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 {
7213 resultobj = wxPyMake_wxObject(result, 0);
7214 }
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = 0;
7223 wxWindow *arg1 = (wxWindow *) 0 ;
7224 wxWindow *result = 0 ;
7225 void *argp1 = 0 ;
7226 int res1 = 0 ;
7227 PyObject * obj0 = 0 ;
7228 char * kwnames[] = {
7229 (char *) "win", NULL
7230 };
7231
7232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7234 if (!SWIG_IsOK(res1)) {
7235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7236 }
7237 arg1 = reinterpret_cast< wxWindow * >(argp1);
7238 {
7239 if (!wxPyCheckForApp()) SWIG_fail;
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 result = (wxWindow *)wxGetTopLevelParent(arg1);
7242 wxPyEndAllowThreads(__tstate);
7243 if (PyErr_Occurred()) SWIG_fail;
7244 }
7245 {
7246 resultobj = wxPyMake_wxObject(result, 0);
7247 }
7248 return resultobj;
7249 fail:
7250 return NULL;
7251 }
7252
7253
7254 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7255 PyObject *resultobj = 0;
7256 wxString *arg1 = 0 ;
7257 bool result;
7258 bool temp1 = false ;
7259 PyObject * obj0 = 0 ;
7260 char * kwnames[] = {
7261 (char *) "url", NULL
7262 };
7263
7264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7265 {
7266 arg1 = wxString_in_helper(obj0);
7267 if (arg1 == NULL) SWIG_fail;
7268 temp1 = true;
7269 }
7270 {
7271 PyThreadState* __tstate = wxPyBeginAllowThreads();
7272 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7273 wxPyEndAllowThreads(__tstate);
7274 if (PyErr_Occurred()) SWIG_fail;
7275 }
7276 {
7277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7278 }
7279 {
7280 if (temp1)
7281 delete arg1;
7282 }
7283 return resultobj;
7284 fail:
7285 {
7286 if (temp1)
7287 delete arg1;
7288 }
7289 return NULL;
7290 }
7291
7292
7293 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7294 PyObject *resultobj = 0;
7295 wxKeyCode arg1 ;
7296 bool result;
7297 int val1 ;
7298 int ecode1 = 0 ;
7299 PyObject * obj0 = 0 ;
7300 char * kwnames[] = {
7301 (char *) "key", NULL
7302 };
7303
7304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7305 ecode1 = SWIG_AsVal_int(obj0, &val1);
7306 if (!SWIG_IsOK(ecode1)) {
7307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7308 }
7309 arg1 = static_cast< wxKeyCode >(val1);
7310 {
7311 if (!wxPyCheckForApp()) SWIG_fail;
7312 PyThreadState* __tstate = wxPyBeginAllowThreads();
7313 result = (bool)wxGetKeyState(arg1);
7314 wxPyEndAllowThreads(__tstate);
7315 if (PyErr_Occurred()) SWIG_fail;
7316 }
7317 {
7318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7319 }
7320 return resultobj;
7321 fail:
7322 return NULL;
7323 }
7324
7325
7326 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7327 PyObject *resultobj = 0;
7328 wxMouseState *result = 0 ;
7329
7330 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 result = (wxMouseState *)new wxMouseState();
7334 wxPyEndAllowThreads(__tstate);
7335 if (PyErr_Occurred()) SWIG_fail;
7336 }
7337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7345 PyObject *resultobj = 0;
7346 wxMouseState *arg1 = (wxMouseState *) 0 ;
7347 void *argp1 = 0 ;
7348 int res1 = 0 ;
7349 PyObject *swig_obj[1] ;
7350
7351 if (!args) SWIG_fail;
7352 swig_obj[0] = args;
7353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7354 if (!SWIG_IsOK(res1)) {
7355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7356 }
7357 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 delete arg1;
7361
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 resultobj = SWIG_Py_Void();
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7373 PyObject *resultobj = 0;
7374 wxMouseState *arg1 = (wxMouseState *) 0 ;
7375 int result;
7376 void *argp1 = 0 ;
7377 int res1 = 0 ;
7378 PyObject *swig_obj[1] ;
7379
7380 if (!args) SWIG_fail;
7381 swig_obj[0] = args;
7382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7383 if (!SWIG_IsOK(res1)) {
7384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7385 }
7386 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7387 {
7388 PyThreadState* __tstate = wxPyBeginAllowThreads();
7389 result = (int)(arg1)->GetX();
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 resultobj = SWIG_From_int(static_cast< int >(result));
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7401 PyObject *resultobj = 0;
7402 wxMouseState *arg1 = (wxMouseState *) 0 ;
7403 int result;
7404 void *argp1 = 0 ;
7405 int res1 = 0 ;
7406 PyObject *swig_obj[1] ;
7407
7408 if (!args) SWIG_fail;
7409 swig_obj[0] = args;
7410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7411 if (!SWIG_IsOK(res1)) {
7412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7413 }
7414 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7415 {
7416 PyThreadState* __tstate = wxPyBeginAllowThreads();
7417 result = (int)(arg1)->GetY();
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 resultobj = SWIG_From_int(static_cast< int >(result));
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7429 PyObject *resultobj = 0;
7430 wxMouseState *arg1 = (wxMouseState *) 0 ;
7431 bool result;
7432 void *argp1 = 0 ;
7433 int res1 = 0 ;
7434 PyObject *swig_obj[1] ;
7435
7436 if (!args) SWIG_fail;
7437 swig_obj[0] = args;
7438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7439 if (!SWIG_IsOK(res1)) {
7440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7441 }
7442 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7443 {
7444 PyThreadState* __tstate = wxPyBeginAllowThreads();
7445 result = (bool)(arg1)->LeftDown();
7446 wxPyEndAllowThreads(__tstate);
7447 if (PyErr_Occurred()) SWIG_fail;
7448 }
7449 {
7450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7451 }
7452 return resultobj;
7453 fail:
7454 return NULL;
7455 }
7456
7457
7458 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7459 PyObject *resultobj = 0;
7460 wxMouseState *arg1 = (wxMouseState *) 0 ;
7461 bool result;
7462 void *argp1 = 0 ;
7463 int res1 = 0 ;
7464 PyObject *swig_obj[1] ;
7465
7466 if (!args) SWIG_fail;
7467 swig_obj[0] = args;
7468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7469 if (!SWIG_IsOK(res1)) {
7470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7471 }
7472 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7473 {
7474 PyThreadState* __tstate = wxPyBeginAllowThreads();
7475 result = (bool)(arg1)->MiddleDown();
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 {
7480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7481 }
7482 return resultobj;
7483 fail:
7484 return NULL;
7485 }
7486
7487
7488 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7489 PyObject *resultobj = 0;
7490 wxMouseState *arg1 = (wxMouseState *) 0 ;
7491 bool result;
7492 void *argp1 = 0 ;
7493 int res1 = 0 ;
7494 PyObject *swig_obj[1] ;
7495
7496 if (!args) SWIG_fail;
7497 swig_obj[0] = args;
7498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7501 }
7502 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7503 {
7504 PyThreadState* __tstate = wxPyBeginAllowThreads();
7505 result = (bool)(arg1)->RightDown();
7506 wxPyEndAllowThreads(__tstate);
7507 if (PyErr_Occurred()) SWIG_fail;
7508 }
7509 {
7510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7511 }
7512 return resultobj;
7513 fail:
7514 return NULL;
7515 }
7516
7517
7518 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7519 PyObject *resultobj = 0;
7520 wxMouseState *arg1 = (wxMouseState *) 0 ;
7521 bool result;
7522 void *argp1 = 0 ;
7523 int res1 = 0 ;
7524 PyObject *swig_obj[1] ;
7525
7526 if (!args) SWIG_fail;
7527 swig_obj[0] = args;
7528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7529 if (!SWIG_IsOK(res1)) {
7530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7531 }
7532 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7533 {
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 result = (bool)(arg1)->ControlDown();
7536 wxPyEndAllowThreads(__tstate);
7537 if (PyErr_Occurred()) SWIG_fail;
7538 }
7539 {
7540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7541 }
7542 return resultobj;
7543 fail:
7544 return NULL;
7545 }
7546
7547
7548 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7549 PyObject *resultobj = 0;
7550 wxMouseState *arg1 = (wxMouseState *) 0 ;
7551 bool result;
7552 void *argp1 = 0 ;
7553 int res1 = 0 ;
7554 PyObject *swig_obj[1] ;
7555
7556 if (!args) SWIG_fail;
7557 swig_obj[0] = args;
7558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7561 }
7562 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7563 {
7564 PyThreadState* __tstate = wxPyBeginAllowThreads();
7565 result = (bool)(arg1)->ShiftDown();
7566 wxPyEndAllowThreads(__tstate);
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 {
7570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7571 }
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7579 PyObject *resultobj = 0;
7580 wxMouseState *arg1 = (wxMouseState *) 0 ;
7581 bool result;
7582 void *argp1 = 0 ;
7583 int res1 = 0 ;
7584 PyObject *swig_obj[1] ;
7585
7586 if (!args) SWIG_fail;
7587 swig_obj[0] = args;
7588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7589 if (!SWIG_IsOK(res1)) {
7590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7591 }
7592 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7593 {
7594 PyThreadState* __tstate = wxPyBeginAllowThreads();
7595 result = (bool)(arg1)->AltDown();
7596 wxPyEndAllowThreads(__tstate);
7597 if (PyErr_Occurred()) SWIG_fail;
7598 }
7599 {
7600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7601 }
7602 return resultobj;
7603 fail:
7604 return NULL;
7605 }
7606
7607
7608 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7609 PyObject *resultobj = 0;
7610 wxMouseState *arg1 = (wxMouseState *) 0 ;
7611 bool result;
7612 void *argp1 = 0 ;
7613 int res1 = 0 ;
7614 PyObject *swig_obj[1] ;
7615
7616 if (!args) SWIG_fail;
7617 swig_obj[0] = args;
7618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7619 if (!SWIG_IsOK(res1)) {
7620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7621 }
7622 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7623 {
7624 PyThreadState* __tstate = wxPyBeginAllowThreads();
7625 result = (bool)(arg1)->MetaDown();
7626 wxPyEndAllowThreads(__tstate);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 {
7630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7631 }
7632 return resultobj;
7633 fail:
7634 return NULL;
7635 }
7636
7637
7638 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7639 PyObject *resultobj = 0;
7640 wxMouseState *arg1 = (wxMouseState *) 0 ;
7641 bool result;
7642 void *argp1 = 0 ;
7643 int res1 = 0 ;
7644 PyObject *swig_obj[1] ;
7645
7646 if (!args) SWIG_fail;
7647 swig_obj[0] = args;
7648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7649 if (!SWIG_IsOK(res1)) {
7650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7651 }
7652 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7653 {
7654 PyThreadState* __tstate = wxPyBeginAllowThreads();
7655 result = (bool)(arg1)->CmdDown();
7656 wxPyEndAllowThreads(__tstate);
7657 if (PyErr_Occurred()) SWIG_fail;
7658 }
7659 {
7660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7661 }
7662 return resultobj;
7663 fail:
7664 return NULL;
7665 }
7666
7667
7668 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7669 PyObject *resultobj = 0;
7670 wxMouseState *arg1 = (wxMouseState *) 0 ;
7671 int arg2 ;
7672 void *argp1 = 0 ;
7673 int res1 = 0 ;
7674 int val2 ;
7675 int ecode2 = 0 ;
7676 PyObject * obj0 = 0 ;
7677 PyObject * obj1 = 0 ;
7678 char * kwnames[] = {
7679 (char *) "self",(char *) "x", NULL
7680 };
7681
7682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7686 }
7687 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7688 ecode2 = SWIG_AsVal_int(obj1, &val2);
7689 if (!SWIG_IsOK(ecode2)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7691 }
7692 arg2 = static_cast< int >(val2);
7693 {
7694 PyThreadState* __tstate = wxPyBeginAllowThreads();
7695 (arg1)->SetX(arg2);
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 resultobj = SWIG_Py_Void();
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj = 0;
7708 wxMouseState *arg1 = (wxMouseState *) 0 ;
7709 int arg2 ;
7710 void *argp1 = 0 ;
7711 int res1 = 0 ;
7712 int val2 ;
7713 int ecode2 = 0 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 char * kwnames[] = {
7717 (char *) "self",(char *) "y", NULL
7718 };
7719
7720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7724 }
7725 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7726 ecode2 = SWIG_AsVal_int(obj1, &val2);
7727 if (!SWIG_IsOK(ecode2)) {
7728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7729 }
7730 arg2 = static_cast< int >(val2);
7731 {
7732 PyThreadState* __tstate = wxPyBeginAllowThreads();
7733 (arg1)->SetY(arg2);
7734 wxPyEndAllowThreads(__tstate);
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 resultobj = SWIG_Py_Void();
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj = 0;
7746 wxMouseState *arg1 = (wxMouseState *) 0 ;
7747 bool arg2 ;
7748 void *argp1 = 0 ;
7749 int res1 = 0 ;
7750 bool val2 ;
7751 int ecode2 = 0 ;
7752 PyObject * obj0 = 0 ;
7753 PyObject * obj1 = 0 ;
7754 char * kwnames[] = {
7755 (char *) "self",(char *) "down", NULL
7756 };
7757
7758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7760 if (!SWIG_IsOK(res1)) {
7761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7762 }
7763 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7765 if (!SWIG_IsOK(ecode2)) {
7766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7767 }
7768 arg2 = static_cast< bool >(val2);
7769 {
7770 PyThreadState* __tstate = wxPyBeginAllowThreads();
7771 (arg1)->SetLeftDown(arg2);
7772 wxPyEndAllowThreads(__tstate);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 resultobj = SWIG_Py_Void();
7776 return resultobj;
7777 fail:
7778 return NULL;
7779 }
7780
7781
7782 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7783 PyObject *resultobj = 0;
7784 wxMouseState *arg1 = (wxMouseState *) 0 ;
7785 bool arg2 ;
7786 void *argp1 = 0 ;
7787 int res1 = 0 ;
7788 bool val2 ;
7789 int ecode2 = 0 ;
7790 PyObject * obj0 = 0 ;
7791 PyObject * obj1 = 0 ;
7792 char * kwnames[] = {
7793 (char *) "self",(char *) "down", NULL
7794 };
7795
7796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7798 if (!SWIG_IsOK(res1)) {
7799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7800 }
7801 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7802 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7803 if (!SWIG_IsOK(ecode2)) {
7804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7805 }
7806 arg2 = static_cast< bool >(val2);
7807 {
7808 PyThreadState* __tstate = wxPyBeginAllowThreads();
7809 (arg1)->SetMiddleDown(arg2);
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 resultobj = SWIG_Py_Void();
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj = 0;
7822 wxMouseState *arg1 = (wxMouseState *) 0 ;
7823 bool arg2 ;
7824 void *argp1 = 0 ;
7825 int res1 = 0 ;
7826 bool val2 ;
7827 int ecode2 = 0 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 char * kwnames[] = {
7831 (char *) "self",(char *) "down", NULL
7832 };
7833
7834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7836 if (!SWIG_IsOK(res1)) {
7837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7838 }
7839 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7841 if (!SWIG_IsOK(ecode2)) {
7842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7843 }
7844 arg2 = static_cast< bool >(val2);
7845 {
7846 PyThreadState* __tstate = wxPyBeginAllowThreads();
7847 (arg1)->SetRightDown(arg2);
7848 wxPyEndAllowThreads(__tstate);
7849 if (PyErr_Occurred()) SWIG_fail;
7850 }
7851 resultobj = SWIG_Py_Void();
7852 return resultobj;
7853 fail:
7854 return NULL;
7855 }
7856
7857
7858 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7859 PyObject *resultobj = 0;
7860 wxMouseState *arg1 = (wxMouseState *) 0 ;
7861 bool arg2 ;
7862 void *argp1 = 0 ;
7863 int res1 = 0 ;
7864 bool val2 ;
7865 int ecode2 = 0 ;
7866 PyObject * obj0 = 0 ;
7867 PyObject * obj1 = 0 ;
7868 char * kwnames[] = {
7869 (char *) "self",(char *) "down", NULL
7870 };
7871
7872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7874 if (!SWIG_IsOK(res1)) {
7875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7876 }
7877 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7878 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7879 if (!SWIG_IsOK(ecode2)) {
7880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7881 }
7882 arg2 = static_cast< bool >(val2);
7883 {
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 (arg1)->SetControlDown(arg2);
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 resultobj = SWIG_Py_Void();
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7897 PyObject *resultobj = 0;
7898 wxMouseState *arg1 = (wxMouseState *) 0 ;
7899 bool arg2 ;
7900 void *argp1 = 0 ;
7901 int res1 = 0 ;
7902 bool val2 ;
7903 int ecode2 = 0 ;
7904 PyObject * obj0 = 0 ;
7905 PyObject * obj1 = 0 ;
7906 char * kwnames[] = {
7907 (char *) "self",(char *) "down", NULL
7908 };
7909
7910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7912 if (!SWIG_IsOK(res1)) {
7913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7914 }
7915 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7916 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7917 if (!SWIG_IsOK(ecode2)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7919 }
7920 arg2 = static_cast< bool >(val2);
7921 {
7922 PyThreadState* __tstate = wxPyBeginAllowThreads();
7923 (arg1)->SetShiftDown(arg2);
7924 wxPyEndAllowThreads(__tstate);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 resultobj = SWIG_Py_Void();
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7935 PyObject *resultobj = 0;
7936 wxMouseState *arg1 = (wxMouseState *) 0 ;
7937 bool arg2 ;
7938 void *argp1 = 0 ;
7939 int res1 = 0 ;
7940 bool val2 ;
7941 int ecode2 = 0 ;
7942 PyObject * obj0 = 0 ;
7943 PyObject * obj1 = 0 ;
7944 char * kwnames[] = {
7945 (char *) "self",(char *) "down", NULL
7946 };
7947
7948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7950 if (!SWIG_IsOK(res1)) {
7951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7952 }
7953 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7954 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7955 if (!SWIG_IsOK(ecode2)) {
7956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7957 }
7958 arg2 = static_cast< bool >(val2);
7959 {
7960 PyThreadState* __tstate = wxPyBeginAllowThreads();
7961 (arg1)->SetAltDown(arg2);
7962 wxPyEndAllowThreads(__tstate);
7963 if (PyErr_Occurred()) SWIG_fail;
7964 }
7965 resultobj = SWIG_Py_Void();
7966 return resultobj;
7967 fail:
7968 return NULL;
7969 }
7970
7971
7972 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7973 PyObject *resultobj = 0;
7974 wxMouseState *arg1 = (wxMouseState *) 0 ;
7975 bool arg2 ;
7976 void *argp1 = 0 ;
7977 int res1 = 0 ;
7978 bool val2 ;
7979 int ecode2 = 0 ;
7980 PyObject * obj0 = 0 ;
7981 PyObject * obj1 = 0 ;
7982 char * kwnames[] = {
7983 (char *) "self",(char *) "down", NULL
7984 };
7985
7986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7988 if (!SWIG_IsOK(res1)) {
7989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7990 }
7991 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7992 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7993 if (!SWIG_IsOK(ecode2)) {
7994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7995 }
7996 arg2 = static_cast< bool >(val2);
7997 {
7998 PyThreadState* __tstate = wxPyBeginAllowThreads();
7999 (arg1)->SetMetaDown(arg2);
8000 wxPyEndAllowThreads(__tstate);
8001 if (PyErr_Occurred()) SWIG_fail;
8002 }
8003 resultobj = SWIG_Py_Void();
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8011 PyObject *obj;
8012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8013 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8014 return SWIG_Py_Void();
8015 }
8016
8017 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8018 return SWIG_Python_InitShadowInstance(args);
8019 }
8020
8021 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxMouseState result;
8024
8025 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8026 {
8027 PyThreadState* __tstate = wxPyBeginAllowThreads();
8028 result = wxGetMouseState();
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040 PyObject *resultobj = 0;
8041
8042 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8043 {
8044 if (!wxPyCheckForApp()) SWIG_fail;
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 wxWakeUpMainThread();
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = SWIG_Py_Void();
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8058 PyObject *resultobj = 0;
8059
8060 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8061 {
8062 if (!wxPyCheckForApp()) SWIG_fail;
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 wxMutexGuiEnter();
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 resultobj = SWIG_Py_Void();
8069 return resultobj;
8070 fail:
8071 return NULL;
8072 }
8073
8074
8075 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8076 PyObject *resultobj = 0;
8077
8078 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8079 {
8080 if (!wxPyCheckForApp()) SWIG_fail;
8081 PyThreadState* __tstate = wxPyBeginAllowThreads();
8082 wxMutexGuiLeave();
8083 wxPyEndAllowThreads(__tstate);
8084 if (PyErr_Occurred()) SWIG_fail;
8085 }
8086 resultobj = SWIG_Py_Void();
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8094 PyObject *resultobj = 0;
8095 wxMutexGuiLocker *result = 0 ;
8096
8097 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8098 {
8099 if (!wxPyCheckForApp()) SWIG_fail;
8100 PyThreadState* __tstate = wxPyBeginAllowThreads();
8101 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8113 PyObject *resultobj = 0;
8114 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8115 void *argp1 = 0 ;
8116 int res1 = 0 ;
8117 PyObject *swig_obj[1] ;
8118
8119 if (!args) SWIG_fail;
8120 swig_obj[0] = args;
8121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8122 if (!SWIG_IsOK(res1)) {
8123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8124 }
8125 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 delete arg1;
8129
8130 wxPyEndAllowThreads(__tstate);
8131 if (PyErr_Occurred()) SWIG_fail;
8132 }
8133 resultobj = SWIG_Py_Void();
8134 return resultobj;
8135 fail:
8136 return NULL;
8137 }
8138
8139
8140 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8141 PyObject *obj;
8142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8143 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8144 return SWIG_Py_Void();
8145 }
8146
8147 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8148 return SWIG_Python_InitShadowInstance(args);
8149 }
8150
8151 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8152 PyObject *resultobj = 0;
8153 bool result;
8154
8155 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 result = (bool)wxThread_IsMain();
8159 wxPyEndAllowThreads(__tstate);
8160 if (PyErr_Occurred()) SWIG_fail;
8161 }
8162 {
8163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8164 }
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8172 PyObject *resultobj = 0;
8173 wxString *arg1 = 0 ;
8174 wxToolTip *result = 0 ;
8175 bool temp1 = false ;
8176 PyObject * obj0 = 0 ;
8177 char * kwnames[] = {
8178 (char *) "tip", NULL
8179 };
8180
8181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8182 {
8183 arg1 = wxString_in_helper(obj0);
8184 if (arg1 == NULL) SWIG_fail;
8185 temp1 = true;
8186 }
8187 {
8188 if (!wxPyCheckForApp()) SWIG_fail;
8189 PyThreadState* __tstate = wxPyBeginAllowThreads();
8190 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8191 wxPyEndAllowThreads(__tstate);
8192 if (PyErr_Occurred()) SWIG_fail;
8193 }
8194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8195 {
8196 if (temp1)
8197 delete arg1;
8198 }
8199 return resultobj;
8200 fail:
8201 {
8202 if (temp1)
8203 delete arg1;
8204 }
8205 return NULL;
8206 }
8207
8208
8209 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8210 PyObject *resultobj = 0;
8211 wxToolTip *arg1 = (wxToolTip *) 0 ;
8212 void *argp1 = 0 ;
8213 int res1 = 0 ;
8214 PyObject *swig_obj[1] ;
8215
8216 if (!args) SWIG_fail;
8217 swig_obj[0] = args;
8218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8219 if (!SWIG_IsOK(res1)) {
8220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8221 }
8222 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8223 {
8224 PyThreadState* __tstate = wxPyBeginAllowThreads();
8225 delete arg1;
8226
8227 wxPyEndAllowThreads(__tstate);
8228 if (PyErr_Occurred()) SWIG_fail;
8229 }
8230 resultobj = SWIG_Py_Void();
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8238 PyObject *resultobj = 0;
8239 wxToolTip *arg1 = (wxToolTip *) 0 ;
8240 wxString *arg2 = 0 ;
8241 void *argp1 = 0 ;
8242 int res1 = 0 ;
8243 bool temp2 = false ;
8244 PyObject * obj0 = 0 ;
8245 PyObject * obj1 = 0 ;
8246 char * kwnames[] = {
8247 (char *) "self",(char *) "tip", NULL
8248 };
8249
8250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8252 if (!SWIG_IsOK(res1)) {
8253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8254 }
8255 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8256 {
8257 arg2 = wxString_in_helper(obj1);
8258 if (arg2 == NULL) SWIG_fail;
8259 temp2 = true;
8260 }
8261 {
8262 PyThreadState* __tstate = wxPyBeginAllowThreads();
8263 (arg1)->SetTip((wxString const &)*arg2);
8264 wxPyEndAllowThreads(__tstate);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 resultobj = SWIG_Py_Void();
8268 {
8269 if (temp2)
8270 delete arg2;
8271 }
8272 return resultobj;
8273 fail:
8274 {
8275 if (temp2)
8276 delete arg2;
8277 }
8278 return NULL;
8279 }
8280
8281
8282 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8283 PyObject *resultobj = 0;
8284 wxToolTip *arg1 = (wxToolTip *) 0 ;
8285 wxString result;
8286 void *argp1 = 0 ;
8287 int res1 = 0 ;
8288 PyObject *swig_obj[1] ;
8289
8290 if (!args) SWIG_fail;
8291 swig_obj[0] = args;
8292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8293 if (!SWIG_IsOK(res1)) {
8294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8295 }
8296 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8297 {
8298 PyThreadState* __tstate = wxPyBeginAllowThreads();
8299 result = (arg1)->GetTip();
8300 wxPyEndAllowThreads(__tstate);
8301 if (PyErr_Occurred()) SWIG_fail;
8302 }
8303 {
8304 #if wxUSE_UNICODE
8305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8306 #else
8307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8308 #endif
8309 }
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8317 PyObject *resultobj = 0;
8318 wxToolTip *arg1 = (wxToolTip *) 0 ;
8319 wxWindow *result = 0 ;
8320 void *argp1 = 0 ;
8321 int res1 = 0 ;
8322 PyObject *swig_obj[1] ;
8323
8324 if (!args) SWIG_fail;
8325 swig_obj[0] = args;
8326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8327 if (!SWIG_IsOK(res1)) {
8328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8329 }
8330 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 result = (wxWindow *)(arg1)->GetWindow();
8334 wxPyEndAllowThreads(__tstate);
8335 if (PyErr_Occurred()) SWIG_fail;
8336 }
8337 {
8338 resultobj = wxPyMake_wxObject(result, 0);
8339 }
8340 return resultobj;
8341 fail:
8342 return NULL;
8343 }
8344
8345
8346 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8347 PyObject *resultobj = 0;
8348 bool arg1 ;
8349 bool val1 ;
8350 int ecode1 = 0 ;
8351 PyObject * obj0 = 0 ;
8352 char * kwnames[] = {
8353 (char *) "flag", NULL
8354 };
8355
8356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8357 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8358 if (!SWIG_IsOK(ecode1)) {
8359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8360 }
8361 arg1 = static_cast< bool >(val1);
8362 {
8363 PyThreadState* __tstate = wxPyBeginAllowThreads();
8364 wxToolTip::Enable(arg1);
8365 wxPyEndAllowThreads(__tstate);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 resultobj = SWIG_Py_Void();
8369 return resultobj;
8370 fail:
8371 return NULL;
8372 }
8373
8374
8375 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8376 PyObject *resultobj = 0;
8377 long arg1 ;
8378 long val1 ;
8379 int ecode1 = 0 ;
8380 PyObject * obj0 = 0 ;
8381 char * kwnames[] = {
8382 (char *) "milliseconds", NULL
8383 };
8384
8385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8386 ecode1 = SWIG_AsVal_long(obj0, &val1);
8387 if (!SWIG_IsOK(ecode1)) {
8388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8389 }
8390 arg1 = static_cast< long >(val1);
8391 {
8392 PyThreadState* __tstate = wxPyBeginAllowThreads();
8393 wxToolTip::SetDelay(arg1);
8394 wxPyEndAllowThreads(__tstate);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 resultobj = SWIG_Py_Void();
8398 return resultobj;
8399 fail:
8400 return NULL;
8401 }
8402
8403
8404 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8405 PyObject *obj;
8406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8407 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8408 return SWIG_Py_Void();
8409 }
8410
8411 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8412 return SWIG_Python_InitShadowInstance(args);
8413 }
8414
8415 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8416 PyObject *resultobj = 0;
8417 wxWindow *arg1 = (wxWindow *) 0 ;
8418 wxSize *arg2 = 0 ;
8419 wxCaret *result = 0 ;
8420 void *argp1 = 0 ;
8421 int res1 = 0 ;
8422 wxSize temp2 ;
8423 PyObject * obj0 = 0 ;
8424 PyObject * obj1 = 0 ;
8425 char * kwnames[] = {
8426 (char *) "window",(char *) "size", NULL
8427 };
8428
8429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8431 if (!SWIG_IsOK(res1)) {
8432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8433 }
8434 arg1 = reinterpret_cast< wxWindow * >(argp1);
8435 {
8436 arg2 = &temp2;
8437 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8438 }
8439 {
8440 if (!wxPyCheckForApp()) SWIG_fail;
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8443 wxPyEndAllowThreads(__tstate);
8444 if (PyErr_Occurred()) SWIG_fail;
8445 }
8446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8454 PyObject *resultobj = 0;
8455 wxCaret *arg1 = (wxCaret *) 0 ;
8456 void *argp1 = 0 ;
8457 int res1 = 0 ;
8458 PyObject *swig_obj[1] ;
8459
8460 if (!args) SWIG_fail;
8461 swig_obj[0] = args;
8462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8463 if (!SWIG_IsOK(res1)) {
8464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8465 }
8466 arg1 = reinterpret_cast< wxCaret * >(argp1);
8467 {
8468 PyThreadState* __tstate = wxPyBeginAllowThreads();
8469 delete arg1;
8470
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 resultobj = SWIG_Py_Void();
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8482 PyObject *resultobj = 0;
8483 wxCaret *arg1 = (wxCaret *) 0 ;
8484 void *argp1 = 0 ;
8485 int res1 = 0 ;
8486 PyObject *swig_obj[1] ;
8487
8488 if (!args) SWIG_fail;
8489 swig_obj[0] = args;
8490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8491 if (!SWIG_IsOK(res1)) {
8492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8493 }
8494 arg1 = reinterpret_cast< wxCaret * >(argp1);
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 wxCaret_Destroy(arg1);
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 resultobj = SWIG_Py_Void();
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8509 PyObject *resultobj = 0;
8510 wxCaret *arg1 = (wxCaret *) 0 ;
8511 bool result;
8512 void *argp1 = 0 ;
8513 int res1 = 0 ;
8514 PyObject *swig_obj[1] ;
8515
8516 if (!args) SWIG_fail;
8517 swig_obj[0] = args;
8518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8519 if (!SWIG_IsOK(res1)) {
8520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8521 }
8522 arg1 = reinterpret_cast< wxCaret * >(argp1);
8523 {
8524 PyThreadState* __tstate = wxPyBeginAllowThreads();
8525 result = (bool)(arg1)->IsOk();
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 {
8530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8531 }
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8539 PyObject *resultobj = 0;
8540 wxCaret *arg1 = (wxCaret *) 0 ;
8541 bool result;
8542 void *argp1 = 0 ;
8543 int res1 = 0 ;
8544 PyObject *swig_obj[1] ;
8545
8546 if (!args) SWIG_fail;
8547 swig_obj[0] = args;
8548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8549 if (!SWIG_IsOK(res1)) {
8550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8551 }
8552 arg1 = reinterpret_cast< wxCaret * >(argp1);
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 result = (bool)(arg1)->IsVisible();
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 {
8560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8561 }
8562 return resultobj;
8563 fail:
8564 return NULL;
8565 }
8566
8567
8568 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8569 PyObject *resultobj = 0;
8570 wxCaret *arg1 = (wxCaret *) 0 ;
8571 wxPoint result;
8572 void *argp1 = 0 ;
8573 int res1 = 0 ;
8574 PyObject *swig_obj[1] ;
8575
8576 if (!args) SWIG_fail;
8577 swig_obj[0] = args;
8578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8579 if (!SWIG_IsOK(res1)) {
8580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8581 }
8582 arg1 = reinterpret_cast< wxCaret * >(argp1);
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 result = (arg1)->GetPosition();
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8597 PyObject *resultobj = 0;
8598 wxCaret *arg1 = (wxCaret *) 0 ;
8599 int *arg2 = (int *) 0 ;
8600 int *arg3 = (int *) 0 ;
8601 void *argp1 = 0 ;
8602 int res1 = 0 ;
8603 int temp2 ;
8604 int res2 = SWIG_TMPOBJ ;
8605 int temp3 ;
8606 int res3 = SWIG_TMPOBJ ;
8607 PyObject *swig_obj[1] ;
8608
8609 arg2 = &temp2;
8610 arg3 = &temp3;
8611 if (!args) SWIG_fail;
8612 swig_obj[0] = args;
8613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8616 }
8617 arg1 = reinterpret_cast< wxCaret * >(argp1);
8618 {
8619 PyThreadState* __tstate = wxPyBeginAllowThreads();
8620 (arg1)->GetPosition(arg2,arg3);
8621 wxPyEndAllowThreads(__tstate);
8622 if (PyErr_Occurred()) SWIG_fail;
8623 }
8624 resultobj = SWIG_Py_Void();
8625 if (SWIG_IsTmpObj(res2)) {
8626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8627 } else {
8628 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8630 }
8631 if (SWIG_IsTmpObj(res3)) {
8632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8633 } else {
8634 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8636 }
8637 return resultobj;
8638 fail:
8639 return NULL;
8640 }
8641
8642
8643 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8644 PyObject *resultobj = 0;
8645 wxCaret *arg1 = (wxCaret *) 0 ;
8646 wxSize result;
8647 void *argp1 = 0 ;
8648 int res1 = 0 ;
8649 PyObject *swig_obj[1] ;
8650
8651 if (!args) SWIG_fail;
8652 swig_obj[0] = args;
8653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8654 if (!SWIG_IsOK(res1)) {
8655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8656 }
8657 arg1 = reinterpret_cast< wxCaret * >(argp1);
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (arg1)->GetSize();
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8672 PyObject *resultobj = 0;
8673 wxCaret *arg1 = (wxCaret *) 0 ;
8674 int *arg2 = (int *) 0 ;
8675 int *arg3 = (int *) 0 ;
8676 void *argp1 = 0 ;
8677 int res1 = 0 ;
8678 int temp2 ;
8679 int res2 = SWIG_TMPOBJ ;
8680 int temp3 ;
8681 int res3 = SWIG_TMPOBJ ;
8682 PyObject *swig_obj[1] ;
8683
8684 arg2 = &temp2;
8685 arg3 = &temp3;
8686 if (!args) SWIG_fail;
8687 swig_obj[0] = args;
8688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8689 if (!SWIG_IsOK(res1)) {
8690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8691 }
8692 arg1 = reinterpret_cast< wxCaret * >(argp1);
8693 {
8694 PyThreadState* __tstate = wxPyBeginAllowThreads();
8695 (arg1)->GetSize(arg2,arg3);
8696 wxPyEndAllowThreads(__tstate);
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 resultobj = SWIG_Py_Void();
8700 if (SWIG_IsTmpObj(res2)) {
8701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8702 } else {
8703 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8705 }
8706 if (SWIG_IsTmpObj(res3)) {
8707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8708 } else {
8709 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8711 }
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8719 PyObject *resultobj = 0;
8720 wxCaret *arg1 = (wxCaret *) 0 ;
8721 wxWindow *result = 0 ;
8722 void *argp1 = 0 ;
8723 int res1 = 0 ;
8724 PyObject *swig_obj[1] ;
8725
8726 if (!args) SWIG_fail;
8727 swig_obj[0] = args;
8728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8729 if (!SWIG_IsOK(res1)) {
8730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8731 }
8732 arg1 = reinterpret_cast< wxCaret * >(argp1);
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 result = (wxWindow *)(arg1)->GetWindow();
8736 wxPyEndAllowThreads(__tstate);
8737 if (PyErr_Occurred()) SWIG_fail;
8738 }
8739 {
8740 resultobj = wxPyMake_wxObject(result, 0);
8741 }
8742 return resultobj;
8743 fail:
8744 return NULL;
8745 }
8746
8747
8748 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8749 PyObject *resultobj = 0;
8750 wxCaret *arg1 = (wxCaret *) 0 ;
8751 int arg2 ;
8752 int arg3 ;
8753 void *argp1 = 0 ;
8754 int res1 = 0 ;
8755 int val2 ;
8756 int ecode2 = 0 ;
8757 int val3 ;
8758 int ecode3 = 0 ;
8759 PyObject * obj0 = 0 ;
8760 PyObject * obj1 = 0 ;
8761 PyObject * obj2 = 0 ;
8762 char * kwnames[] = {
8763 (char *) "self",(char *) "x",(char *) "y", NULL
8764 };
8765
8766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8768 if (!SWIG_IsOK(res1)) {
8769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8770 }
8771 arg1 = reinterpret_cast< wxCaret * >(argp1);
8772 ecode2 = SWIG_AsVal_int(obj1, &val2);
8773 if (!SWIG_IsOK(ecode2)) {
8774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8775 }
8776 arg2 = static_cast< int >(val2);
8777 ecode3 = SWIG_AsVal_int(obj2, &val3);
8778 if (!SWIG_IsOK(ecode3)) {
8779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8780 }
8781 arg3 = static_cast< int >(val3);
8782 {
8783 PyThreadState* __tstate = wxPyBeginAllowThreads();
8784 (arg1)->Move(arg2,arg3);
8785 wxPyEndAllowThreads(__tstate);
8786 if (PyErr_Occurred()) SWIG_fail;
8787 }
8788 resultobj = SWIG_Py_Void();
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj = 0;
8797 wxCaret *arg1 = (wxCaret *) 0 ;
8798 wxPoint *arg2 = 0 ;
8799 void *argp1 = 0 ;
8800 int res1 = 0 ;
8801 wxPoint temp2 ;
8802 PyObject * obj0 = 0 ;
8803 PyObject * obj1 = 0 ;
8804 char * kwnames[] = {
8805 (char *) "self",(char *) "pt", NULL
8806 };
8807
8808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8810 if (!SWIG_IsOK(res1)) {
8811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8812 }
8813 arg1 = reinterpret_cast< wxCaret * >(argp1);
8814 {
8815 arg2 = &temp2;
8816 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8817 }
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 (arg1)->Move((wxPoint const &)*arg2);
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 resultobj = SWIG_Py_Void();
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj = 0;
8833 wxCaret *arg1 = (wxCaret *) 0 ;
8834 int arg2 ;
8835 int arg3 ;
8836 void *argp1 = 0 ;
8837 int res1 = 0 ;
8838 int val2 ;
8839 int ecode2 = 0 ;
8840 int val3 ;
8841 int ecode3 = 0 ;
8842 PyObject * obj0 = 0 ;
8843 PyObject * obj1 = 0 ;
8844 PyObject * obj2 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "self",(char *) "width",(char *) "height", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8853 }
8854 arg1 = reinterpret_cast< wxCaret * >(argp1);
8855 ecode2 = SWIG_AsVal_int(obj1, &val2);
8856 if (!SWIG_IsOK(ecode2)) {
8857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8858 }
8859 arg2 = static_cast< int >(val2);
8860 ecode3 = SWIG_AsVal_int(obj2, &val3);
8861 if (!SWIG_IsOK(ecode3)) {
8862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8863 }
8864 arg3 = static_cast< int >(val3);
8865 {
8866 PyThreadState* __tstate = wxPyBeginAllowThreads();
8867 (arg1)->SetSize(arg2,arg3);
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 resultobj = SWIG_Py_Void();
8872 return resultobj;
8873 fail:
8874 return NULL;
8875 }
8876
8877
8878 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8879 PyObject *resultobj = 0;
8880 wxCaret *arg1 = (wxCaret *) 0 ;
8881 wxSize *arg2 = 0 ;
8882 void *argp1 = 0 ;
8883 int res1 = 0 ;
8884 wxSize temp2 ;
8885 PyObject * obj0 = 0 ;
8886 PyObject * obj1 = 0 ;
8887 char * kwnames[] = {
8888 (char *) "self",(char *) "size", NULL
8889 };
8890
8891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8893 if (!SWIG_IsOK(res1)) {
8894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8895 }
8896 arg1 = reinterpret_cast< wxCaret * >(argp1);
8897 {
8898 arg2 = &temp2;
8899 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8900 }
8901 {
8902 PyThreadState* __tstate = wxPyBeginAllowThreads();
8903 (arg1)->SetSize((wxSize const &)*arg2);
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 resultobj = SWIG_Py_Void();
8908 return resultobj;
8909 fail:
8910 return NULL;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj = 0;
8916 wxCaret *arg1 = (wxCaret *) 0 ;
8917 int arg2 = (int) true ;
8918 void *argp1 = 0 ;
8919 int res1 = 0 ;
8920 int val2 ;
8921 int ecode2 = 0 ;
8922 PyObject * obj0 = 0 ;
8923 PyObject * obj1 = 0 ;
8924 char * kwnames[] = {
8925 (char *) "self",(char *) "show", NULL
8926 };
8927
8928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8930 if (!SWIG_IsOK(res1)) {
8931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8932 }
8933 arg1 = reinterpret_cast< wxCaret * >(argp1);
8934 if (obj1) {
8935 ecode2 = SWIG_AsVal_int(obj1, &val2);
8936 if (!SWIG_IsOK(ecode2)) {
8937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8938 }
8939 arg2 = static_cast< int >(val2);
8940 }
8941 {
8942 PyThreadState* __tstate = wxPyBeginAllowThreads();
8943 (arg1)->Show(arg2);
8944 wxPyEndAllowThreads(__tstate);
8945 if (PyErr_Occurred()) SWIG_fail;
8946 }
8947 resultobj = SWIG_Py_Void();
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8955 PyObject *resultobj = 0;
8956 wxCaret *arg1 = (wxCaret *) 0 ;
8957 void *argp1 = 0 ;
8958 int res1 = 0 ;
8959 PyObject *swig_obj[1] ;
8960
8961 if (!args) SWIG_fail;
8962 swig_obj[0] = args;
8963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8964 if (!SWIG_IsOK(res1)) {
8965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8966 }
8967 arg1 = reinterpret_cast< wxCaret * >(argp1);
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 (arg1)->Hide();
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 resultobj = SWIG_Py_Void();
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8982 PyObject *resultobj = 0;
8983 int result;
8984
8985 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = (int)wxCaret::GetBlinkTime();
8989 wxPyEndAllowThreads(__tstate);
8990 if (PyErr_Occurred()) SWIG_fail;
8991 }
8992 resultobj = SWIG_From_int(static_cast< int >(result));
8993 return resultobj;
8994 fail:
8995 return NULL;
8996 }
8997
8998
8999 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9000 PyObject *resultobj = 0;
9001 int arg1 ;
9002 int val1 ;
9003 int ecode1 = 0 ;
9004 PyObject * obj0 = 0 ;
9005 char * kwnames[] = {
9006 (char *) "milliseconds", NULL
9007 };
9008
9009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9010 ecode1 = SWIG_AsVal_int(obj0, &val1);
9011 if (!SWIG_IsOK(ecode1)) {
9012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9013 }
9014 arg1 = static_cast< int >(val1);
9015 {
9016 PyThreadState* __tstate = wxPyBeginAllowThreads();
9017 wxCaret::SetBlinkTime(arg1);
9018 wxPyEndAllowThreads(__tstate);
9019 if (PyErr_Occurred()) SWIG_fail;
9020 }
9021 resultobj = SWIG_Py_Void();
9022 return resultobj;
9023 fail:
9024 return NULL;
9025 }
9026
9027
9028 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9029 PyObject *obj;
9030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9031 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9032 return SWIG_Py_Void();
9033 }
9034
9035 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9036 return SWIG_Python_InitShadowInstance(args);
9037 }
9038
9039 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9040 PyObject *resultobj = 0;
9041 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9042 wxBusyCursor *result = 0 ;
9043 void *argp1 = 0 ;
9044 int res1 = 0 ;
9045 PyObject * obj0 = 0 ;
9046 char * kwnames[] = {
9047 (char *) "cursor", NULL
9048 };
9049
9050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9051 if (obj0) {
9052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9053 if (!SWIG_IsOK(res1)) {
9054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9055 }
9056 arg1 = reinterpret_cast< wxCursor * >(argp1);
9057 }
9058 {
9059 if (!wxPyCheckForApp()) SWIG_fail;
9060 PyThreadState* __tstate = wxPyBeginAllowThreads();
9061 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9062 wxPyEndAllowThreads(__tstate);
9063 if (PyErr_Occurred()) SWIG_fail;
9064 }
9065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9066 return resultobj;
9067 fail:
9068 return NULL;
9069 }
9070
9071
9072 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9073 PyObject *resultobj = 0;
9074 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9075 void *argp1 = 0 ;
9076 int res1 = 0 ;
9077 PyObject *swig_obj[1] ;
9078
9079 if (!args) SWIG_fail;
9080 swig_obj[0] = args;
9081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9082 if (!SWIG_IsOK(res1)) {
9083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9084 }
9085 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 delete arg1;
9089
9090 wxPyEndAllowThreads(__tstate);
9091 if (PyErr_Occurred()) SWIG_fail;
9092 }
9093 resultobj = SWIG_Py_Void();
9094 return resultobj;
9095 fail:
9096 return NULL;
9097 }
9098
9099
9100 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9101 PyObject *obj;
9102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9103 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9104 return SWIG_Py_Void();
9105 }
9106
9107 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9108 return SWIG_Python_InitShadowInstance(args);
9109 }
9110
9111 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9112 PyObject *resultobj = 0;
9113 wxWindow *arg1 = (wxWindow *) NULL ;
9114 wxWindowDisabler *result = 0 ;
9115 void *argp1 = 0 ;
9116 int res1 = 0 ;
9117 PyObject * obj0 = 0 ;
9118 char * kwnames[] = {
9119 (char *) "winToSkip", NULL
9120 };
9121
9122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9123 if (obj0) {
9124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9125 if (!SWIG_IsOK(res1)) {
9126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9127 }
9128 arg1 = reinterpret_cast< wxWindow * >(argp1);
9129 }
9130 {
9131 if (!wxPyCheckForApp()) SWIG_fail;
9132 PyThreadState* __tstate = wxPyBeginAllowThreads();
9133 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9134 wxPyEndAllowThreads(__tstate);
9135 if (PyErr_Occurred()) SWIG_fail;
9136 }
9137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9138 return resultobj;
9139 fail:
9140 return NULL;
9141 }
9142
9143
9144 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9145 PyObject *resultobj = 0;
9146 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 PyObject *swig_obj[1] ;
9150
9151 if (!args) SWIG_fail;
9152 swig_obj[0] = args;
9153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9154 if (!SWIG_IsOK(res1)) {
9155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9156 }
9157 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9158 {
9159 PyThreadState* __tstate = wxPyBeginAllowThreads();
9160 delete arg1;
9161
9162 wxPyEndAllowThreads(__tstate);
9163 if (PyErr_Occurred()) SWIG_fail;
9164 }
9165 resultobj = SWIG_Py_Void();
9166 return resultobj;
9167 fail:
9168 return NULL;
9169 }
9170
9171
9172 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9173 PyObject *obj;
9174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9175 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9176 return SWIG_Py_Void();
9177 }
9178
9179 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9180 return SWIG_Python_InitShadowInstance(args);
9181 }
9182
9183 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj = 0;
9185 wxString *arg1 = 0 ;
9186 wxBusyInfo *result = 0 ;
9187 bool temp1 = false ;
9188 PyObject * obj0 = 0 ;
9189 char * kwnames[] = {
9190 (char *) "message", NULL
9191 };
9192
9193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9194 {
9195 arg1 = wxString_in_helper(obj0);
9196 if (arg1 == NULL) SWIG_fail;
9197 temp1 = true;
9198 }
9199 {
9200 if (!wxPyCheckForApp()) SWIG_fail;
9201 PyThreadState* __tstate = wxPyBeginAllowThreads();
9202 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9207 {
9208 if (temp1)
9209 delete arg1;
9210 }
9211 return resultobj;
9212 fail:
9213 {
9214 if (temp1)
9215 delete arg1;
9216 }
9217 return NULL;
9218 }
9219
9220
9221 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 PyObject *resultobj = 0;
9223 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9224 void *argp1 = 0 ;
9225 int res1 = 0 ;
9226 PyObject *swig_obj[1] ;
9227
9228 if (!args) SWIG_fail;
9229 swig_obj[0] = args;
9230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9231 if (!SWIG_IsOK(res1)) {
9232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9233 }
9234 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9235 {
9236 PyThreadState* __tstate = wxPyBeginAllowThreads();
9237 delete arg1;
9238
9239 wxPyEndAllowThreads(__tstate);
9240 if (PyErr_Occurred()) SWIG_fail;
9241 }
9242 resultobj = SWIG_Py_Void();
9243 return resultobj;
9244 fail:
9245 return NULL;
9246 }
9247
9248
9249 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9250 PyObject *obj;
9251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9252 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9253 return SWIG_Py_Void();
9254 }
9255
9256 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9257 return SWIG_Python_InitShadowInstance(args);
9258 }
9259
9260 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9261 PyObject *resultobj = 0;
9262 wxStopWatch *result = 0 ;
9263
9264 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9265 {
9266 PyThreadState* __tstate = wxPyBeginAllowThreads();
9267 result = (wxStopWatch *)new wxStopWatch();
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279 PyObject *resultobj = 0;
9280 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9281 void *argp1 = 0 ;
9282 int res1 = 0 ;
9283 PyObject *swig_obj[1] ;
9284
9285 if (!args) SWIG_fail;
9286 swig_obj[0] = args;
9287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9288 if (!SWIG_IsOK(res1)) {
9289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9290 }
9291 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 delete arg1;
9295
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 resultobj = SWIG_Py_Void();
9300 return resultobj;
9301 fail:
9302 return NULL;
9303 }
9304
9305
9306 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj = 0;
9308 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9309 long arg2 = (long) 0 ;
9310 void *argp1 = 0 ;
9311 int res1 = 0 ;
9312 long val2 ;
9313 int ecode2 = 0 ;
9314 PyObject * obj0 = 0 ;
9315 PyObject * obj1 = 0 ;
9316 char * kwnames[] = {
9317 (char *) "self",(char *) "t0", NULL
9318 };
9319
9320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9322 if (!SWIG_IsOK(res1)) {
9323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9324 }
9325 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9326 if (obj1) {
9327 ecode2 = SWIG_AsVal_long(obj1, &val2);
9328 if (!SWIG_IsOK(ecode2)) {
9329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9330 }
9331 arg2 = static_cast< long >(val2);
9332 }
9333 {
9334 PyThreadState* __tstate = wxPyBeginAllowThreads();
9335 (arg1)->Start(arg2);
9336 wxPyEndAllowThreads(__tstate);
9337 if (PyErr_Occurred()) SWIG_fail;
9338 }
9339 resultobj = SWIG_Py_Void();
9340 return resultobj;
9341 fail:
9342 return NULL;
9343 }
9344
9345
9346 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9347 PyObject *resultobj = 0;
9348 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9349 void *argp1 = 0 ;
9350 int res1 = 0 ;
9351 PyObject *swig_obj[1] ;
9352
9353 if (!args) SWIG_fail;
9354 swig_obj[0] = args;
9355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9356 if (!SWIG_IsOK(res1)) {
9357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9358 }
9359 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9360 {
9361 PyThreadState* __tstate = wxPyBeginAllowThreads();
9362 (arg1)->Pause();
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 resultobj = SWIG_Py_Void();
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9374 PyObject *resultobj = 0;
9375 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9376 void *argp1 = 0 ;
9377 int res1 = 0 ;
9378 PyObject *swig_obj[1] ;
9379
9380 if (!args) SWIG_fail;
9381 swig_obj[0] = args;
9382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9383 if (!SWIG_IsOK(res1)) {
9384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9385 }
9386 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9387 {
9388 PyThreadState* __tstate = wxPyBeginAllowThreads();
9389 (arg1)->Resume();
9390 wxPyEndAllowThreads(__tstate);
9391 if (PyErr_Occurred()) SWIG_fail;
9392 }
9393 resultobj = SWIG_Py_Void();
9394 return resultobj;
9395 fail:
9396 return NULL;
9397 }
9398
9399
9400 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9401 PyObject *resultobj = 0;
9402 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9403 long result;
9404 void *argp1 = 0 ;
9405 int res1 = 0 ;
9406 PyObject *swig_obj[1] ;
9407
9408 if (!args) SWIG_fail;
9409 swig_obj[0] = args;
9410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9413 }
9414 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (long)((wxStopWatch const *)arg1)->Time();
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 resultobj = SWIG_From_long(static_cast< long >(result));
9422 return resultobj;
9423 fail:
9424 return NULL;
9425 }
9426
9427
9428 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9429 PyObject *obj;
9430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9431 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9432 return SWIG_Py_Void();
9433 }
9434
9435 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9436 return SWIG_Python_InitShadowInstance(args);
9437 }
9438
9439 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj = 0;
9441 int arg1 = (int) 9 ;
9442 int arg2 = (int) wxID_FILE1 ;
9443 wxFileHistory *result = 0 ;
9444 int val1 ;
9445 int ecode1 = 0 ;
9446 int val2 ;
9447 int ecode2 = 0 ;
9448 PyObject * obj0 = 0 ;
9449 PyObject * obj1 = 0 ;
9450 char * kwnames[] = {
9451 (char *) "maxFiles",(char *) "idBase", NULL
9452 };
9453
9454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9455 if (obj0) {
9456 ecode1 = SWIG_AsVal_int(obj0, &val1);
9457 if (!SWIG_IsOK(ecode1)) {
9458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9459 }
9460 arg1 = static_cast< int >(val1);
9461 }
9462 if (obj1) {
9463 ecode2 = SWIG_AsVal_int(obj1, &val2);
9464 if (!SWIG_IsOK(ecode2)) {
9465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9466 }
9467 arg2 = static_cast< int >(val2);
9468 }
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9483 PyObject *resultobj = 0;
9484 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9485 void *argp1 = 0 ;
9486 int res1 = 0 ;
9487 PyObject *swig_obj[1] ;
9488
9489 if (!args) SWIG_fail;
9490 swig_obj[0] = args;
9491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9492 if (!SWIG_IsOK(res1)) {
9493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9494 }
9495 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9496 {
9497 PyThreadState* __tstate = wxPyBeginAllowThreads();
9498 delete arg1;
9499
9500 wxPyEndAllowThreads(__tstate);
9501 if (PyErr_Occurred()) SWIG_fail;
9502 }
9503 resultobj = SWIG_Py_Void();
9504 return resultobj;
9505 fail:
9506 return NULL;
9507 }
9508
9509
9510 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9511 PyObject *resultobj = 0;
9512 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9513 wxString *arg2 = 0 ;
9514 void *argp1 = 0 ;
9515 int res1 = 0 ;
9516 bool temp2 = false ;
9517 PyObject * obj0 = 0 ;
9518 PyObject * obj1 = 0 ;
9519 char * kwnames[] = {
9520 (char *) "self",(char *) "file", NULL
9521 };
9522
9523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9525 if (!SWIG_IsOK(res1)) {
9526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9527 }
9528 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9529 {
9530 arg2 = wxString_in_helper(obj1);
9531 if (arg2 == NULL) SWIG_fail;
9532 temp2 = true;
9533 }
9534 {
9535 PyThreadState* __tstate = wxPyBeginAllowThreads();
9536 (arg1)->AddFileToHistory((wxString const &)*arg2);
9537 wxPyEndAllowThreads(__tstate);
9538 if (PyErr_Occurred()) SWIG_fail;
9539 }
9540 resultobj = SWIG_Py_Void();
9541 {
9542 if (temp2)
9543 delete arg2;
9544 }
9545 return resultobj;
9546 fail:
9547 {
9548 if (temp2)
9549 delete arg2;
9550 }
9551 return NULL;
9552 }
9553
9554
9555 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj = 0;
9557 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9558 int arg2 ;
9559 void *argp1 = 0 ;
9560 int res1 = 0 ;
9561 int val2 ;
9562 int ecode2 = 0 ;
9563 PyObject * obj0 = 0 ;
9564 PyObject * obj1 = 0 ;
9565 char * kwnames[] = {
9566 (char *) "self",(char *) "i", NULL
9567 };
9568
9569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9571 if (!SWIG_IsOK(res1)) {
9572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9573 }
9574 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9575 ecode2 = SWIG_AsVal_int(obj1, &val2);
9576 if (!SWIG_IsOK(ecode2)) {
9577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9578 }
9579 arg2 = static_cast< int >(val2);
9580 {
9581 PyThreadState* __tstate = wxPyBeginAllowThreads();
9582 (arg1)->RemoveFileFromHistory(arg2);
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 resultobj = SWIG_Py_Void();
9587 return resultobj;
9588 fail:
9589 return NULL;
9590 }
9591
9592
9593 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9594 PyObject *resultobj = 0;
9595 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9596 int result;
9597 void *argp1 = 0 ;
9598 int res1 = 0 ;
9599 PyObject *swig_obj[1] ;
9600
9601 if (!args) SWIG_fail;
9602 swig_obj[0] = args;
9603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9604 if (!SWIG_IsOK(res1)) {
9605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9606 }
9607 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9608 {
9609 PyThreadState* __tstate = wxPyBeginAllowThreads();
9610 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9611 wxPyEndAllowThreads(__tstate);
9612 if (PyErr_Occurred()) SWIG_fail;
9613 }
9614 resultobj = SWIG_From_int(static_cast< int >(result));
9615 return resultobj;
9616 fail:
9617 return NULL;
9618 }
9619
9620
9621 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9622 PyObject *resultobj = 0;
9623 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9624 wxMenu *arg2 = (wxMenu *) 0 ;
9625 void *argp1 = 0 ;
9626 int res1 = 0 ;
9627 void *argp2 = 0 ;
9628 int res2 = 0 ;
9629 PyObject * obj0 = 0 ;
9630 PyObject * obj1 = 0 ;
9631 char * kwnames[] = {
9632 (char *) "self",(char *) "menu", NULL
9633 };
9634
9635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9637 if (!SWIG_IsOK(res1)) {
9638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9639 }
9640 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9642 if (!SWIG_IsOK(res2)) {
9643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9644 }
9645 arg2 = reinterpret_cast< wxMenu * >(argp2);
9646 {
9647 PyThreadState* __tstate = wxPyBeginAllowThreads();
9648 (arg1)->UseMenu(arg2);
9649 wxPyEndAllowThreads(__tstate);
9650 if (PyErr_Occurred()) SWIG_fail;
9651 }
9652 resultobj = SWIG_Py_Void();
9653 return resultobj;
9654 fail:
9655 return NULL;
9656 }
9657
9658
9659 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9660 PyObject *resultobj = 0;
9661 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9662 wxMenu *arg2 = (wxMenu *) 0 ;
9663 void *argp1 = 0 ;
9664 int res1 = 0 ;
9665 void *argp2 = 0 ;
9666 int res2 = 0 ;
9667 PyObject * obj0 = 0 ;
9668 PyObject * obj1 = 0 ;
9669 char * kwnames[] = {
9670 (char *) "self",(char *) "menu", NULL
9671 };
9672
9673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9675 if (!SWIG_IsOK(res1)) {
9676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9677 }
9678 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9680 if (!SWIG_IsOK(res2)) {
9681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9682 }
9683 arg2 = reinterpret_cast< wxMenu * >(argp2);
9684 {
9685 PyThreadState* __tstate = wxPyBeginAllowThreads();
9686 (arg1)->RemoveMenu(arg2);
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_Py_Void();
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9698 PyObject *resultobj = 0;
9699 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9700 wxConfigBase *arg2 = 0 ;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 void *argp2 = 0 ;
9704 int res2 = 0 ;
9705 PyObject * obj0 = 0 ;
9706 PyObject * obj1 = 0 ;
9707 char * kwnames[] = {
9708 (char *) "self",(char *) "config", NULL
9709 };
9710
9711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9713 if (!SWIG_IsOK(res1)) {
9714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9715 }
9716 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9718 if (!SWIG_IsOK(res2)) {
9719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9720 }
9721 if (!argp2) {
9722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9723 }
9724 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9725 {
9726 PyThreadState* __tstate = wxPyBeginAllowThreads();
9727 (arg1)->Load(*arg2);
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 resultobj = SWIG_Py_Void();
9732 return resultobj;
9733 fail:
9734 return NULL;
9735 }
9736
9737
9738 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj = 0;
9740 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9741 wxConfigBase *arg2 = 0 ;
9742 void *argp1 = 0 ;
9743 int res1 = 0 ;
9744 void *argp2 = 0 ;
9745 int res2 = 0 ;
9746 PyObject * obj0 = 0 ;
9747 PyObject * obj1 = 0 ;
9748 char * kwnames[] = {
9749 (char *) "self",(char *) "config", NULL
9750 };
9751
9752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9756 }
9757 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9758 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9759 if (!SWIG_IsOK(res2)) {
9760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9761 }
9762 if (!argp2) {
9763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9764 }
9765 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 (arg1)->Save(*arg2);
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 resultobj = SWIG_Py_Void();
9773 return resultobj;
9774 fail:
9775 return NULL;
9776 }
9777
9778
9779 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9780 PyObject *resultobj = 0;
9781 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9782 void *argp1 = 0 ;
9783 int res1 = 0 ;
9784 PyObject *swig_obj[1] ;
9785
9786 if (!args) SWIG_fail;
9787 swig_obj[0] = args;
9788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9789 if (!SWIG_IsOK(res1)) {
9790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9791 }
9792 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9793 {
9794 PyThreadState* __tstate = wxPyBeginAllowThreads();
9795 (arg1)->AddFilesToMenu();
9796 wxPyEndAllowThreads(__tstate);
9797 if (PyErr_Occurred()) SWIG_fail;
9798 }
9799 resultobj = SWIG_Py_Void();
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9807 PyObject *resultobj = 0;
9808 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9809 wxMenu *arg2 = (wxMenu *) 0 ;
9810 void *argp1 = 0 ;
9811 int res1 = 0 ;
9812 void *argp2 = 0 ;
9813 int res2 = 0 ;
9814 PyObject * obj0 = 0 ;
9815 PyObject * obj1 = 0 ;
9816 char * kwnames[] = {
9817 (char *) "self",(char *) "menu", NULL
9818 };
9819
9820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9822 if (!SWIG_IsOK(res1)) {
9823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9824 }
9825 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9826 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9827 if (!SWIG_IsOK(res2)) {
9828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9829 }
9830 arg2 = reinterpret_cast< wxMenu * >(argp2);
9831 {
9832 PyThreadState* __tstate = wxPyBeginAllowThreads();
9833 (arg1)->AddFilesToMenu(arg2);
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 resultobj = SWIG_Py_Void();
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9845 PyObject *resultobj = 0;
9846 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9847 int arg2 ;
9848 wxString result;
9849 void *argp1 = 0 ;
9850 int res1 = 0 ;
9851 int val2 ;
9852 int ecode2 = 0 ;
9853 PyObject * obj0 = 0 ;
9854 PyObject * obj1 = 0 ;
9855 char * kwnames[] = {
9856 (char *) "self",(char *) "i", NULL
9857 };
9858
9859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9861 if (!SWIG_IsOK(res1)) {
9862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9863 }
9864 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9865 ecode2 = SWIG_AsVal_int(obj1, &val2);
9866 if (!SWIG_IsOK(ecode2)) {
9867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9868 }
9869 arg2 = static_cast< int >(val2);
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9873 wxPyEndAllowThreads(__tstate);
9874 if (PyErr_Occurred()) SWIG_fail;
9875 }
9876 {
9877 #if wxUSE_UNICODE
9878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9879 #else
9880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9881 #endif
9882 }
9883 return resultobj;
9884 fail:
9885 return NULL;
9886 }
9887
9888
9889 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 PyObject *resultobj = 0;
9891 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9892 int result;
9893 void *argp1 = 0 ;
9894 int res1 = 0 ;
9895 PyObject *swig_obj[1] ;
9896
9897 if (!args) SWIG_fail;
9898 swig_obj[0] = args;
9899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9900 if (!SWIG_IsOK(res1)) {
9901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9902 }
9903 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 result = (int)((wxFileHistory const *)arg1)->GetCount();
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_From_int(static_cast< int >(result));
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *obj;
9919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9920 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9921 return SWIG_Py_Void();
9922 }
9923
9924 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9925 return SWIG_Python_InitShadowInstance(args);
9926 }
9927
9928 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9929 PyObject *resultobj = 0;
9930 wxString *arg1 = 0 ;
9931 wxString const &arg2_defvalue = wxPyEmptyString ;
9932 wxString *arg2 = (wxString *) &arg2_defvalue ;
9933 wxSingleInstanceChecker *result = 0 ;
9934 bool temp1 = false ;
9935 bool temp2 = false ;
9936 PyObject * obj0 = 0 ;
9937 PyObject * obj1 = 0 ;
9938 char * kwnames[] = {
9939 (char *) "name",(char *) "path", NULL
9940 };
9941
9942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9943 {
9944 arg1 = wxString_in_helper(obj0);
9945 if (arg1 == NULL) SWIG_fail;
9946 temp1 = true;
9947 }
9948 if (obj1) {
9949 {
9950 arg2 = wxString_in_helper(obj1);
9951 if (arg2 == NULL) SWIG_fail;
9952 temp2 = true;
9953 }
9954 }
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9962 {
9963 if (temp1)
9964 delete arg1;
9965 }
9966 {
9967 if (temp2)
9968 delete arg2;
9969 }
9970 return resultobj;
9971 fail:
9972 {
9973 if (temp1)
9974 delete arg1;
9975 }
9976 {
9977 if (temp2)
9978 delete arg2;
9979 }
9980 return NULL;
9981 }
9982
9983
9984 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9985 PyObject *resultobj = 0;
9986 wxSingleInstanceChecker *result = 0 ;
9987
9988 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9989 {
9990 PyThreadState* __tstate = wxPyBeginAllowThreads();
9991 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9996 return resultobj;
9997 fail:
9998 return NULL;
9999 }
10000
10001
10002 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10003 PyObject *resultobj = 0;
10004 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10005 void *argp1 = 0 ;
10006 int res1 = 0 ;
10007 PyObject *swig_obj[1] ;
10008
10009 if (!args) SWIG_fail;
10010 swig_obj[0] = args;
10011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10012 if (!SWIG_IsOK(res1)) {
10013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10014 }
10015 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 delete arg1;
10019
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_Py_Void();
10024 return resultobj;
10025 fail:
10026 return NULL;
10027 }
10028
10029
10030 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10031 PyObject *resultobj = 0;
10032 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10033 wxString *arg2 = 0 ;
10034 wxString const &arg3_defvalue = wxPyEmptyString ;
10035 wxString *arg3 = (wxString *) &arg3_defvalue ;
10036 bool result;
10037 void *argp1 = 0 ;
10038 int res1 = 0 ;
10039 bool temp2 = false ;
10040 bool temp3 = false ;
10041 PyObject * obj0 = 0 ;
10042 PyObject * obj1 = 0 ;
10043 PyObject * obj2 = 0 ;
10044 char * kwnames[] = {
10045 (char *) "self",(char *) "name",(char *) "path", NULL
10046 };
10047
10048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10050 if (!SWIG_IsOK(res1)) {
10051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10052 }
10053 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10054 {
10055 arg2 = wxString_in_helper(obj1);
10056 if (arg2 == NULL) SWIG_fail;
10057 temp2 = true;
10058 }
10059 if (obj2) {
10060 {
10061 arg3 = wxString_in_helper(obj2);
10062 if (arg3 == NULL) SWIG_fail;
10063 temp3 = true;
10064 }
10065 }
10066 {
10067 PyThreadState* __tstate = wxPyBeginAllowThreads();
10068 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 {
10073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10074 }
10075 {
10076 if (temp2)
10077 delete arg2;
10078 }
10079 {
10080 if (temp3)
10081 delete arg3;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp2)
10087 delete arg2;
10088 }
10089 {
10090 if (temp3)
10091 delete arg3;
10092 }
10093 return NULL;
10094 }
10095
10096
10097 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10098 PyObject *resultobj = 0;
10099 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10100 bool result;
10101 void *argp1 = 0 ;
10102 int res1 = 0 ;
10103 PyObject *swig_obj[1] ;
10104
10105 if (!args) SWIG_fail;
10106 swig_obj[0] = args;
10107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10108 if (!SWIG_IsOK(res1)) {
10109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10110 }
10111 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 {
10119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10120 }
10121 return resultobj;
10122 fail:
10123 return NULL;
10124 }
10125
10126
10127 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10128 PyObject *obj;
10129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10130 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10131 return SWIG_Py_Void();
10132 }
10133
10134 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10135 return SWIG_Python_InitShadowInstance(args);
10136 }
10137
10138 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10139 PyObject *resultobj = 0;
10140 wxPlatformInfo *result = 0 ;
10141
10142 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 result = (wxPlatformInfo *)new wxPlatformInfo();
10146 wxPyEndAllowThreads(__tstate);
10147 if (PyErr_Occurred()) SWIG_fail;
10148 }
10149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10150 return resultobj;
10151 fail:
10152 return NULL;
10153 }
10154
10155
10156 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10157 PyObject *resultobj = 0;
10158 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10159 wxPlatformInfo *arg2 = 0 ;
10160 bool result;
10161 void *argp1 = 0 ;
10162 int res1 = 0 ;
10163 void *argp2 = 0 ;
10164 int res2 = 0 ;
10165 PyObject * obj0 = 0 ;
10166 PyObject * obj1 = 0 ;
10167 char * kwnames[] = {
10168 (char *) "self",(char *) "t", NULL
10169 };
10170
10171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10173 if (!SWIG_IsOK(res1)) {
10174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10175 }
10176 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10177 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10178 if (!SWIG_IsOK(res2)) {
10179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10180 }
10181 if (!argp2) {
10182 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10183 }
10184 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10185 {
10186 PyThreadState* __tstate = wxPyBeginAllowThreads();
10187 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10188 wxPyEndAllowThreads(__tstate);
10189 if (PyErr_Occurred()) SWIG_fail;
10190 }
10191 {
10192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10193 }
10194 return resultobj;
10195 fail:
10196 return NULL;
10197 }
10198
10199
10200 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj = 0;
10202 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10203 wxPlatformInfo *arg2 = 0 ;
10204 bool result;
10205 void *argp1 = 0 ;
10206 int res1 = 0 ;
10207 void *argp2 = 0 ;
10208 int res2 = 0 ;
10209 PyObject * obj0 = 0 ;
10210 PyObject * obj1 = 0 ;
10211 char * kwnames[] = {
10212 (char *) "self",(char *) "t", NULL
10213 };
10214
10215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10217 if (!SWIG_IsOK(res1)) {
10218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10219 }
10220 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10221 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10222 if (!SWIG_IsOK(res2)) {
10223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10224 }
10225 if (!argp2) {
10226 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10227 }
10228 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10232 wxPyEndAllowThreads(__tstate);
10233 if (PyErr_Occurred()) SWIG_fail;
10234 }
10235 {
10236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10237 }
10238 return resultobj;
10239 fail:
10240 return NULL;
10241 }
10242
10243
10244 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10245 PyObject *resultobj = 0;
10246 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10247 int result;
10248 void *argp1 = 0 ;
10249 int res1 = 0 ;
10250 PyObject *swig_obj[1] ;
10251
10252 if (!args) SWIG_fail;
10253 swig_obj[0] = args;
10254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10255 if (!SWIG_IsOK(res1)) {
10256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10257 }
10258 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 resultobj = SWIG_From_int(static_cast< int >(result));
10266 return resultobj;
10267 fail:
10268 return NULL;
10269 }
10270
10271
10272 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10273 PyObject *resultobj = 0;
10274 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10275 int result;
10276 void *argp1 = 0 ;
10277 int res1 = 0 ;
10278 PyObject *swig_obj[1] ;
10279
10280 if (!args) SWIG_fail;
10281 swig_obj[0] = args;
10282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10283 if (!SWIG_IsOK(res1)) {
10284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10285 }
10286 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10287 {
10288 PyThreadState* __tstate = wxPyBeginAllowThreads();
10289 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10290 wxPyEndAllowThreads(__tstate);
10291 if (PyErr_Occurred()) SWIG_fail;
10292 }
10293 resultobj = SWIG_From_int(static_cast< int >(result));
10294 return resultobj;
10295 fail:
10296 return NULL;
10297 }
10298
10299
10300 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10301 PyObject *resultobj = 0;
10302 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10303 int arg2 ;
10304 int arg3 ;
10305 bool result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 int val2 ;
10309 int ecode2 = 0 ;
10310 int val3 ;
10311 int ecode3 = 0 ;
10312 PyObject * obj0 = 0 ;
10313 PyObject * obj1 = 0 ;
10314 PyObject * obj2 = 0 ;
10315 char * kwnames[] = {
10316 (char *) "self",(char *) "major",(char *) "minor", NULL
10317 };
10318
10319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10321 if (!SWIG_IsOK(res1)) {
10322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10323 }
10324 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10325 ecode2 = SWIG_AsVal_int(obj1, &val2);
10326 if (!SWIG_IsOK(ecode2)) {
10327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10328 }
10329 arg2 = static_cast< int >(val2);
10330 ecode3 = SWIG_AsVal_int(obj2, &val3);
10331 if (!SWIG_IsOK(ecode3)) {
10332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10333 }
10334 arg3 = static_cast< int >(val3);
10335 {
10336 PyThreadState* __tstate = wxPyBeginAllowThreads();
10337 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 {
10342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10343 }
10344 return resultobj;
10345 fail:
10346 return NULL;
10347 }
10348
10349
10350 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10351 PyObject *resultobj = 0;
10352 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10353 int result;
10354 void *argp1 = 0 ;
10355 int res1 = 0 ;
10356 PyObject *swig_obj[1] ;
10357
10358 if (!args) SWIG_fail;
10359 swig_obj[0] = args;
10360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10361 if (!SWIG_IsOK(res1)) {
10362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10363 }
10364 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10365 {
10366 PyThreadState* __tstate = wxPyBeginAllowThreads();
10367 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10368 wxPyEndAllowThreads(__tstate);
10369 if (PyErr_Occurred()) SWIG_fail;
10370 }
10371 resultobj = SWIG_From_int(static_cast< int >(result));
10372 return resultobj;
10373 fail:
10374 return NULL;
10375 }
10376
10377
10378 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10379 PyObject *resultobj = 0;
10380 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10381 int result;
10382 void *argp1 = 0 ;
10383 int res1 = 0 ;
10384 PyObject *swig_obj[1] ;
10385
10386 if (!args) SWIG_fail;
10387 swig_obj[0] = args;
10388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10389 if (!SWIG_IsOK(res1)) {
10390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10391 }
10392 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10393 {
10394 PyThreadState* __tstate = wxPyBeginAllowThreads();
10395 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10396 wxPyEndAllowThreads(__tstate);
10397 if (PyErr_Occurred()) SWIG_fail;
10398 }
10399 resultobj = SWIG_From_int(static_cast< int >(result));
10400 return resultobj;
10401 fail:
10402 return NULL;
10403 }
10404
10405
10406 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10407 PyObject *resultobj = 0;
10408 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10409 int arg2 ;
10410 int arg3 ;
10411 bool result;
10412 void *argp1 = 0 ;
10413 int res1 = 0 ;
10414 int val2 ;
10415 int ecode2 = 0 ;
10416 int val3 ;
10417 int ecode3 = 0 ;
10418 PyObject * obj0 = 0 ;
10419 PyObject * obj1 = 0 ;
10420 PyObject * obj2 = 0 ;
10421 char * kwnames[] = {
10422 (char *) "self",(char *) "major",(char *) "minor", NULL
10423 };
10424
10425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10427 if (!SWIG_IsOK(res1)) {
10428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10429 }
10430 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10431 ecode2 = SWIG_AsVal_int(obj1, &val2);
10432 if (!SWIG_IsOK(ecode2)) {
10433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10434 }
10435 arg2 = static_cast< int >(val2);
10436 ecode3 = SWIG_AsVal_int(obj2, &val3);
10437 if (!SWIG_IsOK(ecode3)) {
10438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10439 }
10440 arg3 = static_cast< int >(val3);
10441 {
10442 PyThreadState* __tstate = wxPyBeginAllowThreads();
10443 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10444 wxPyEndAllowThreads(__tstate);
10445 if (PyErr_Occurred()) SWIG_fail;
10446 }
10447 {
10448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10449 }
10450 return resultobj;
10451 fail:
10452 return NULL;
10453 }
10454
10455
10456 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10457 PyObject *resultobj = 0;
10458 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10459 bool result;
10460 void *argp1 = 0 ;
10461 int res1 = 0 ;
10462 PyObject *swig_obj[1] ;
10463
10464 if (!args) SWIG_fail;
10465 swig_obj[0] = args;
10466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10467 if (!SWIG_IsOK(res1)) {
10468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10469 }
10470 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10471 {
10472 PyThreadState* __tstate = wxPyBeginAllowThreads();
10473 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10474 wxPyEndAllowThreads(__tstate);
10475 if (PyErr_Occurred()) SWIG_fail;
10476 }
10477 {
10478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10479 }
10480 return resultobj;
10481 fail:
10482 return NULL;
10483 }
10484
10485
10486 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10487 PyObject *resultobj = 0;
10488 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10489 wxOperatingSystemId result;
10490 void *argp1 = 0 ;
10491 int res1 = 0 ;
10492 PyObject *swig_obj[1] ;
10493
10494 if (!args) SWIG_fail;
10495 swig_obj[0] = args;
10496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10497 if (!SWIG_IsOK(res1)) {
10498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10499 }
10500 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10501 {
10502 PyThreadState* __tstate = wxPyBeginAllowThreads();
10503 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10504 wxPyEndAllowThreads(__tstate);
10505 if (PyErr_Occurred()) SWIG_fail;
10506 }
10507 resultobj = SWIG_From_int(static_cast< int >(result));
10508 return resultobj;
10509 fail:
10510 return NULL;
10511 }
10512
10513
10514 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10515 PyObject *resultobj = 0;
10516 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10517 wxPortId result;
10518 void *argp1 = 0 ;
10519 int res1 = 0 ;
10520 PyObject *swig_obj[1] ;
10521
10522 if (!args) SWIG_fail;
10523 swig_obj[0] = args;
10524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10525 if (!SWIG_IsOK(res1)) {
10526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10527 }
10528 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10529 {
10530 PyThreadState* __tstate = wxPyBeginAllowThreads();
10531 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10532 wxPyEndAllowThreads(__tstate);
10533 if (PyErr_Occurred()) SWIG_fail;
10534 }
10535 resultobj = SWIG_From_int(static_cast< int >(result));
10536 return resultobj;
10537 fail:
10538 return NULL;
10539 }
10540
10541
10542 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10543 PyObject *resultobj = 0;
10544 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10545 wxArchitecture result;
10546 void *argp1 = 0 ;
10547 int res1 = 0 ;
10548 PyObject *swig_obj[1] ;
10549
10550 if (!args) SWIG_fail;
10551 swig_obj[0] = args;
10552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10553 if (!SWIG_IsOK(res1)) {
10554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10555 }
10556 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10557 {
10558 PyThreadState* __tstate = wxPyBeginAllowThreads();
10559 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10560 wxPyEndAllowThreads(__tstate);
10561 if (PyErr_Occurred()) SWIG_fail;
10562 }
10563 resultobj = SWIG_From_int(static_cast< int >(result));
10564 return resultobj;
10565 fail:
10566 return NULL;
10567 }
10568
10569
10570 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10571 PyObject *resultobj = 0;
10572 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10573 wxEndianness result;
10574 void *argp1 = 0 ;
10575 int res1 = 0 ;
10576 PyObject *swig_obj[1] ;
10577
10578 if (!args) SWIG_fail;
10579 swig_obj[0] = args;
10580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10581 if (!SWIG_IsOK(res1)) {
10582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10583 }
10584 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10585 {
10586 PyThreadState* __tstate = wxPyBeginAllowThreads();
10587 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10588 wxPyEndAllowThreads(__tstate);
10589 if (PyErr_Occurred()) SWIG_fail;
10590 }
10591 resultobj = SWIG_From_int(static_cast< int >(result));
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10599 PyObject *resultobj = 0;
10600 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10601 wxString result;
10602 void *argp1 = 0 ;
10603 int res1 = 0 ;
10604 PyObject *swig_obj[1] ;
10605
10606 if (!args) SWIG_fail;
10607 swig_obj[0] = args;
10608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10609 if (!SWIG_IsOK(res1)) {
10610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10611 }
10612 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10613 {
10614 PyThreadState* __tstate = wxPyBeginAllowThreads();
10615 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10616 wxPyEndAllowThreads(__tstate);
10617 if (PyErr_Occurred()) SWIG_fail;
10618 }
10619 {
10620 #if wxUSE_UNICODE
10621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10622 #else
10623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10624 #endif
10625 }
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10633 PyObject *resultobj = 0;
10634 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10635 wxString result;
10636 void *argp1 = 0 ;
10637 int res1 = 0 ;
10638 PyObject *swig_obj[1] ;
10639
10640 if (!args) SWIG_fail;
10641 swig_obj[0] = args;
10642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10643 if (!SWIG_IsOK(res1)) {
10644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10645 }
10646 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10647 {
10648 PyThreadState* __tstate = wxPyBeginAllowThreads();
10649 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10650 wxPyEndAllowThreads(__tstate);
10651 if (PyErr_Occurred()) SWIG_fail;
10652 }
10653 {
10654 #if wxUSE_UNICODE
10655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10656 #else
10657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10658 #endif
10659 }
10660 return resultobj;
10661 fail:
10662 return NULL;
10663 }
10664
10665
10666 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10667 PyObject *resultobj = 0;
10668 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10669 wxString result;
10670 void *argp1 = 0 ;
10671 int res1 = 0 ;
10672 PyObject *swig_obj[1] ;
10673
10674 if (!args) SWIG_fail;
10675 swig_obj[0] = args;
10676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10677 if (!SWIG_IsOK(res1)) {
10678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10679 }
10680 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10681 {
10682 PyThreadState* __tstate = wxPyBeginAllowThreads();
10683 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10684 wxPyEndAllowThreads(__tstate);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 {
10688 #if wxUSE_UNICODE
10689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10690 #else
10691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10692 #endif
10693 }
10694 return resultobj;
10695 fail:
10696 return NULL;
10697 }
10698
10699
10700 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10701 PyObject *resultobj = 0;
10702 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10703 wxString result;
10704 void *argp1 = 0 ;
10705 int res1 = 0 ;
10706 PyObject *swig_obj[1] ;
10707
10708 if (!args) SWIG_fail;
10709 swig_obj[0] = args;
10710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10711 if (!SWIG_IsOK(res1)) {
10712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10713 }
10714 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 {
10722 #if wxUSE_UNICODE
10723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10724 #else
10725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10726 #endif
10727 }
10728 return resultobj;
10729 fail:
10730 return NULL;
10731 }
10732
10733
10734 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10735 PyObject *resultobj = 0;
10736 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10737 wxString result;
10738 void *argp1 = 0 ;
10739 int res1 = 0 ;
10740 PyObject *swig_obj[1] ;
10741
10742 if (!args) SWIG_fail;
10743 swig_obj[0] = args;
10744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10745 if (!SWIG_IsOK(res1)) {
10746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10747 }
10748 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10749 {
10750 PyThreadState* __tstate = wxPyBeginAllowThreads();
10751 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 {
10756 #if wxUSE_UNICODE
10757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10758 #else
10759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10760 #endif
10761 }
10762 return resultobj;
10763 fail:
10764 return NULL;
10765 }
10766
10767
10768 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10769 PyObject *resultobj = 0;
10770 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10771 wxString result;
10772 void *argp1 = 0 ;
10773 int res1 = 0 ;
10774 PyObject *swig_obj[1] ;
10775
10776 if (!args) SWIG_fail;
10777 swig_obj[0] = args;
10778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10779 if (!SWIG_IsOK(res1)) {
10780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10781 }
10782 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 {
10790 #if wxUSE_UNICODE
10791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10792 #else
10793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10794 #endif
10795 }
10796 return resultobj;
10797 fail:
10798 return NULL;
10799 }
10800
10801
10802 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10803 PyObject *resultobj = 0;
10804 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10805 int arg2 ;
10806 int arg3 ;
10807 void *argp1 = 0 ;
10808 int res1 = 0 ;
10809 int val2 ;
10810 int ecode2 = 0 ;
10811 int val3 ;
10812 int ecode3 = 0 ;
10813 PyObject * obj0 = 0 ;
10814 PyObject * obj1 = 0 ;
10815 PyObject * obj2 = 0 ;
10816 char * kwnames[] = {
10817 (char *) "self",(char *) "major",(char *) "minor", NULL
10818 };
10819
10820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10822 if (!SWIG_IsOK(res1)) {
10823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10824 }
10825 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10826 ecode2 = SWIG_AsVal_int(obj1, &val2);
10827 if (!SWIG_IsOK(ecode2)) {
10828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10829 }
10830 arg2 = static_cast< int >(val2);
10831 ecode3 = SWIG_AsVal_int(obj2, &val3);
10832 if (!SWIG_IsOK(ecode3)) {
10833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10834 }
10835 arg3 = static_cast< int >(val3);
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 (arg1)->SetOSVersion(arg2,arg3);
10839 wxPyEndAllowThreads(__tstate);
10840 if (PyErr_Occurred()) SWIG_fail;
10841 }
10842 resultobj = SWIG_Py_Void();
10843 return resultobj;
10844 fail:
10845 return NULL;
10846 }
10847
10848
10849 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10850 PyObject *resultobj = 0;
10851 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10852 int arg2 ;
10853 int arg3 ;
10854 void *argp1 = 0 ;
10855 int res1 = 0 ;
10856 int val2 ;
10857 int ecode2 = 0 ;
10858 int val3 ;
10859 int ecode3 = 0 ;
10860 PyObject * obj0 = 0 ;
10861 PyObject * obj1 = 0 ;
10862 PyObject * obj2 = 0 ;
10863 char * kwnames[] = {
10864 (char *) "self",(char *) "major",(char *) "minor", NULL
10865 };
10866
10867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10869 if (!SWIG_IsOK(res1)) {
10870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10871 }
10872 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10873 ecode2 = SWIG_AsVal_int(obj1, &val2);
10874 if (!SWIG_IsOK(ecode2)) {
10875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10876 }
10877 arg2 = static_cast< int >(val2);
10878 ecode3 = SWIG_AsVal_int(obj2, &val3);
10879 if (!SWIG_IsOK(ecode3)) {
10880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10881 }
10882 arg3 = static_cast< int >(val3);
10883 {
10884 PyThreadState* __tstate = wxPyBeginAllowThreads();
10885 (arg1)->SetToolkitVersion(arg2,arg3);
10886 wxPyEndAllowThreads(__tstate);
10887 if (PyErr_Occurred()) SWIG_fail;
10888 }
10889 resultobj = SWIG_Py_Void();
10890 return resultobj;
10891 fail:
10892 return NULL;
10893 }
10894
10895
10896 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10897 PyObject *resultobj = 0;
10898 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10899 wxOperatingSystemId arg2 ;
10900 void *argp1 = 0 ;
10901 int res1 = 0 ;
10902 int val2 ;
10903 int ecode2 = 0 ;
10904 PyObject * obj0 = 0 ;
10905 PyObject * obj1 = 0 ;
10906 char * kwnames[] = {
10907 (char *) "self",(char *) "n", NULL
10908 };
10909
10910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10912 if (!SWIG_IsOK(res1)) {
10913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10914 }
10915 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10916 ecode2 = SWIG_AsVal_int(obj1, &val2);
10917 if (!SWIG_IsOK(ecode2)) {
10918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10919 }
10920 arg2 = static_cast< wxOperatingSystemId >(val2);
10921 {
10922 PyThreadState* __tstate = wxPyBeginAllowThreads();
10923 (arg1)->SetOperatingSystemId(arg2);
10924 wxPyEndAllowThreads(__tstate);
10925 if (PyErr_Occurred()) SWIG_fail;
10926 }
10927 resultobj = SWIG_Py_Void();
10928 return resultobj;
10929 fail:
10930 return NULL;
10931 }
10932
10933
10934 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10935 PyObject *resultobj = 0;
10936 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10937 wxPortId arg2 ;
10938 void *argp1 = 0 ;
10939 int res1 = 0 ;
10940 int val2 ;
10941 int ecode2 = 0 ;
10942 PyObject * obj0 = 0 ;
10943 PyObject * obj1 = 0 ;
10944 char * kwnames[] = {
10945 (char *) "self",(char *) "n", NULL
10946 };
10947
10948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10950 if (!SWIG_IsOK(res1)) {
10951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10952 }
10953 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10954 ecode2 = SWIG_AsVal_int(obj1, &val2);
10955 if (!SWIG_IsOK(ecode2)) {
10956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10957 }
10958 arg2 = static_cast< wxPortId >(val2);
10959 {
10960 PyThreadState* __tstate = wxPyBeginAllowThreads();
10961 (arg1)->SetPortId(arg2);
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 resultobj = SWIG_Py_Void();
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10973 PyObject *resultobj = 0;
10974 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10975 wxArchitecture arg2 ;
10976 void *argp1 = 0 ;
10977 int res1 = 0 ;
10978 int val2 ;
10979 int ecode2 = 0 ;
10980 PyObject * obj0 = 0 ;
10981 PyObject * obj1 = 0 ;
10982 char * kwnames[] = {
10983 (char *) "self",(char *) "n", NULL
10984 };
10985
10986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10988 if (!SWIG_IsOK(res1)) {
10989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10990 }
10991 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10992 ecode2 = SWIG_AsVal_int(obj1, &val2);
10993 if (!SWIG_IsOK(ecode2)) {
10994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10995 }
10996 arg2 = static_cast< wxArchitecture >(val2);
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 (arg1)->SetArchitecture(arg2);
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 resultobj = SWIG_Py_Void();
11004 return resultobj;
11005 fail:
11006 return NULL;
11007 }
11008
11009
11010 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11011 PyObject *resultobj = 0;
11012 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11013 wxEndianness arg2 ;
11014 void *argp1 = 0 ;
11015 int res1 = 0 ;
11016 int val2 ;
11017 int ecode2 = 0 ;
11018 PyObject * obj0 = 0 ;
11019 PyObject * obj1 = 0 ;
11020 char * kwnames[] = {
11021 (char *) "self",(char *) "n", NULL
11022 };
11023
11024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11026 if (!SWIG_IsOK(res1)) {
11027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11028 }
11029 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11030 ecode2 = SWIG_AsVal_int(obj1, &val2);
11031 if (!SWIG_IsOK(ecode2)) {
11032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11033 }
11034 arg2 = static_cast< wxEndianness >(val2);
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 (arg1)->SetEndianness(arg2);
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 resultobj = SWIG_Py_Void();
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11049 PyObject *resultobj = 0;
11050 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11051 bool result;
11052 void *argp1 = 0 ;
11053 int res1 = 0 ;
11054 PyObject *swig_obj[1] ;
11055
11056 if (!args) SWIG_fail;
11057 swig_obj[0] = args;
11058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11059 if (!SWIG_IsOK(res1)) {
11060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11061 }
11062 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11063 {
11064 PyThreadState* __tstate = wxPyBeginAllowThreads();
11065 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11066 wxPyEndAllowThreads(__tstate);
11067 if (PyErr_Occurred()) SWIG_fail;
11068 }
11069 {
11070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11071 }
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11079 PyObject *obj;
11080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11081 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11082 return SWIG_Py_Void();
11083 }
11084
11085 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11086 return SWIG_Python_InitShadowInstance(args);
11087 }
11088
11089 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11090 PyObject *resultobj = 0;
11091 wxWindow *arg1 = (wxWindow *) 0 ;
11092 wxDC *arg2 = 0 ;
11093 bool result;
11094 void *argp1 = 0 ;
11095 int res1 = 0 ;
11096 void *argp2 = 0 ;
11097 int res2 = 0 ;
11098 PyObject * obj0 = 0 ;
11099 PyObject * obj1 = 0 ;
11100 char * kwnames[] = {
11101 (char *) "window",(char *) "dc", NULL
11102 };
11103
11104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11106 if (!SWIG_IsOK(res1)) {
11107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11108 }
11109 arg1 = reinterpret_cast< wxWindow * >(argp1);
11110 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11111 if (!SWIG_IsOK(res2)) {
11112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11113 }
11114 if (!argp2) {
11115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11116 }
11117 arg2 = reinterpret_cast< wxDC * >(argp2);
11118 {
11119 PyThreadState* __tstate = wxPyBeginAllowThreads();
11120 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 {
11125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11126 }
11127 return resultobj;
11128 fail:
11129 return NULL;
11130 }
11131
11132
11133 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11134 PyObject *resultobj = 0;
11135 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11136 void *argp1 = 0 ;
11137 int res1 = 0 ;
11138 PyObject *swig_obj[1] ;
11139
11140 if (!args) SWIG_fail;
11141 swig_obj[0] = args;
11142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11143 if (!SWIG_IsOK(res1)) {
11144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11145 }
11146 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 delete arg1;
11150
11151 wxPyEndAllowThreads(__tstate);
11152 if (PyErr_Occurred()) SWIG_fail;
11153 }
11154 resultobj = SWIG_Py_Void();
11155 return resultobj;
11156 fail:
11157 return NULL;
11158 }
11159
11160
11161 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11162 PyObject *resultobj = 0;
11163 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11164 wxString result;
11165 void *argp1 = 0 ;
11166 int res1 = 0 ;
11167 PyObject *swig_obj[1] ;
11168
11169 if (!args) SWIG_fail;
11170 swig_obj[0] = args;
11171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11172 if (!SWIG_IsOK(res1)) {
11173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11174 }
11175 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11176 {
11177 PyThreadState* __tstate = wxPyBeginAllowThreads();
11178 result = (arg1)->GetTip();
11179 wxPyEndAllowThreads(__tstate);
11180 if (PyErr_Occurred()) SWIG_fail;
11181 }
11182 {
11183 #if wxUSE_UNICODE
11184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11185 #else
11186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11187 #endif
11188 }
11189 return resultobj;
11190 fail:
11191 return NULL;
11192 }
11193
11194
11195 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11196 PyObject *resultobj = 0;
11197 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11198 size_t result;
11199 void *argp1 = 0 ;
11200 int res1 = 0 ;
11201 PyObject *swig_obj[1] ;
11202
11203 if (!args) SWIG_fail;
11204 swig_obj[0] = args;
11205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11206 if (!SWIG_IsOK(res1)) {
11207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11208 }
11209 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11210 {
11211 PyThreadState* __tstate = wxPyBeginAllowThreads();
11212 result = (size_t)(arg1)->GetCurrentTip();
11213 wxPyEndAllowThreads(__tstate);
11214 if (PyErr_Occurred()) SWIG_fail;
11215 }
11216 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11217 return resultobj;
11218 fail:
11219 return NULL;
11220 }
11221
11222
11223 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11224 PyObject *resultobj = 0;
11225 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11226 wxString *arg2 = 0 ;
11227 wxString result;
11228 void *argp1 = 0 ;
11229 int res1 = 0 ;
11230 bool temp2 = false ;
11231 PyObject * obj0 = 0 ;
11232 PyObject * obj1 = 0 ;
11233 char * kwnames[] = {
11234 (char *) "self",(char *) "tip", NULL
11235 };
11236
11237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11239 if (!SWIG_IsOK(res1)) {
11240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11241 }
11242 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11243 {
11244 arg2 = wxString_in_helper(obj1);
11245 if (arg2 == NULL) SWIG_fail;
11246 temp2 = true;
11247 }
11248 {
11249 PyThreadState* __tstate = wxPyBeginAllowThreads();
11250 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11251 wxPyEndAllowThreads(__tstate);
11252 if (PyErr_Occurred()) SWIG_fail;
11253 }
11254 {
11255 #if wxUSE_UNICODE
11256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11257 #else
11258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11259 #endif
11260 }
11261 {
11262 if (temp2)
11263 delete arg2;
11264 }
11265 return resultobj;
11266 fail:
11267 {
11268 if (temp2)
11269 delete arg2;
11270 }
11271 return NULL;
11272 }
11273
11274
11275 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11276 PyObject *obj;
11277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11278 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11279 return SWIG_Py_Void();
11280 }
11281
11282 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11283 PyObject *resultobj = 0;
11284 size_t arg1 ;
11285 wxPyTipProvider *result = 0 ;
11286 size_t val1 ;
11287 int ecode1 = 0 ;
11288 PyObject * obj0 = 0 ;
11289 char * kwnames[] = {
11290 (char *) "currentTip", NULL
11291 };
11292
11293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11294 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11295 if (!SWIG_IsOK(ecode1)) {
11296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11297 }
11298 arg1 = static_cast< size_t >(val1);
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11306 return resultobj;
11307 fail:
11308 return NULL;
11309 }
11310
11311
11312 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11313 PyObject *resultobj = 0;
11314 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11315 PyObject *arg2 = (PyObject *) 0 ;
11316 PyObject *arg3 = (PyObject *) 0 ;
11317 void *argp1 = 0 ;
11318 int res1 = 0 ;
11319 PyObject * obj0 = 0 ;
11320 PyObject * obj1 = 0 ;
11321 PyObject * obj2 = 0 ;
11322 char * kwnames[] = {
11323 (char *) "self",(char *) "self",(char *) "_class", NULL
11324 };
11325
11326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11328 if (!SWIG_IsOK(res1)) {
11329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11330 }
11331 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11332 arg2 = obj1;
11333 arg3 = obj2;
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 (arg1)->_setCallbackInfo(arg2,arg3);
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11348 PyObject *obj;
11349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11350 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11351 return SWIG_Py_Void();
11352 }
11353
11354 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11355 return SWIG_Python_InitShadowInstance(args);
11356 }
11357
11358 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj = 0;
11360 wxWindow *arg1 = (wxWindow *) 0 ;
11361 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11362 bool arg3 = (bool) true ;
11363 bool result;
11364 void *argp1 = 0 ;
11365 int res1 = 0 ;
11366 void *argp2 = 0 ;
11367 int res2 = 0 ;
11368 bool val3 ;
11369 int ecode3 = 0 ;
11370 PyObject * obj0 = 0 ;
11371 PyObject * obj1 = 0 ;
11372 PyObject * obj2 = 0 ;
11373 char * kwnames[] = {
11374 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11375 };
11376
11377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11379 if (!SWIG_IsOK(res1)) {
11380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11381 }
11382 arg1 = reinterpret_cast< wxWindow * >(argp1);
11383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11384 if (!SWIG_IsOK(res2)) {
11385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11386 }
11387 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11388 if (obj2) {
11389 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11390 if (!SWIG_IsOK(ecode3)) {
11391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11392 }
11393 arg3 = static_cast< bool >(val3);
11394 }
11395 {
11396 if (!wxPyCheckForApp()) SWIG_fail;
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 result = (bool)wxShowTip(arg1,arg2,arg3);
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 {
11403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11404 }
11405 return resultobj;
11406 fail:
11407 return NULL;
11408 }
11409
11410
11411 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11412 PyObject *resultobj = 0;
11413 wxString *arg1 = 0 ;
11414 size_t arg2 ;
11415 wxTipProvider *result = 0 ;
11416 bool temp1 = false ;
11417 size_t val2 ;
11418 int ecode2 = 0 ;
11419 PyObject * obj0 = 0 ;
11420 PyObject * obj1 = 0 ;
11421 char * kwnames[] = {
11422 (char *) "filename",(char *) "currentTip", NULL
11423 };
11424
11425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11426 {
11427 arg1 = wxString_in_helper(obj0);
11428 if (arg1 == NULL) SWIG_fail;
11429 temp1 = true;
11430 }
11431 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11432 if (!SWIG_IsOK(ecode2)) {
11433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11434 }
11435 arg2 = static_cast< size_t >(val2);
11436 {
11437 if (!wxPyCheckForApp()) SWIG_fail;
11438 PyThreadState* __tstate = wxPyBeginAllowThreads();
11439 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11444 {
11445 if (temp1)
11446 delete arg1;
11447 }
11448 return resultobj;
11449 fail:
11450 {
11451 if (temp1)
11452 delete arg1;
11453 }
11454 return NULL;
11455 }
11456
11457
11458 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11459 PyObject *resultobj = 0;
11460 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11461 int arg2 = (int) wxID_ANY ;
11462 wxPyTimer *result = 0 ;
11463 void *argp1 = 0 ;
11464 int res1 = 0 ;
11465 int val2 ;
11466 int ecode2 = 0 ;
11467 PyObject * obj0 = 0 ;
11468 PyObject * obj1 = 0 ;
11469 char * kwnames[] = {
11470 (char *) "owner",(char *) "id", NULL
11471 };
11472
11473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11474 if (obj0) {
11475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11476 if (!SWIG_IsOK(res1)) {
11477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11478 }
11479 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11480 }
11481 if (obj1) {
11482 ecode2 = SWIG_AsVal_int(obj1, &val2);
11483 if (!SWIG_IsOK(ecode2)) {
11484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11485 }
11486 arg2 = static_cast< int >(val2);
11487 }
11488 {
11489 if (!wxPyCheckForApp()) SWIG_fail;
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11492 wxPyEndAllowThreads(__tstate);
11493 if (PyErr_Occurred()) SWIG_fail;
11494 }
11495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11496 return resultobj;
11497 fail:
11498 return NULL;
11499 }
11500
11501
11502 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11503 PyObject *resultobj = 0;
11504 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11505 void *argp1 = 0 ;
11506 int res1 = 0 ;
11507 PyObject *swig_obj[1] ;
11508
11509 if (!args) SWIG_fail;
11510 swig_obj[0] = args;
11511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11512 if (!SWIG_IsOK(res1)) {
11513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11514 }
11515 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 delete arg1;
11519
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 resultobj = SWIG_Py_Void();
11524 return resultobj;
11525 fail:
11526 return NULL;
11527 }
11528
11529
11530 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj = 0;
11532 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11533 PyObject *arg2 = (PyObject *) 0 ;
11534 PyObject *arg3 = (PyObject *) 0 ;
11535 int arg4 = (int) 1 ;
11536 void *argp1 = 0 ;
11537 int res1 = 0 ;
11538 int val4 ;
11539 int ecode4 = 0 ;
11540 PyObject * obj0 = 0 ;
11541 PyObject * obj1 = 0 ;
11542 PyObject * obj2 = 0 ;
11543 PyObject * obj3 = 0 ;
11544 char * kwnames[] = {
11545 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11546 };
11547
11548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11550 if (!SWIG_IsOK(res1)) {
11551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11552 }
11553 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11554 arg2 = obj1;
11555 arg3 = obj2;
11556 if (obj3) {
11557 ecode4 = SWIG_AsVal_int(obj3, &val4);
11558 if (!SWIG_IsOK(ecode4)) {
11559 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11560 }
11561 arg4 = static_cast< int >(val4);
11562 }
11563 {
11564 PyThreadState* __tstate = wxPyBeginAllowThreads();
11565 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 resultobj = SWIG_Py_Void();
11570 return resultobj;
11571 fail:
11572 return NULL;
11573 }
11574
11575
11576 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11577 PyObject *resultobj = 0;
11578 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11579 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11580 int arg3 = (int) wxID_ANY ;
11581 void *argp1 = 0 ;
11582 int res1 = 0 ;
11583 void *argp2 = 0 ;
11584 int res2 = 0 ;
11585 int val3 ;
11586 int ecode3 = 0 ;
11587 PyObject * obj0 = 0 ;
11588 PyObject * obj1 = 0 ;
11589 PyObject * obj2 = 0 ;
11590 char * kwnames[] = {
11591 (char *) "self",(char *) "owner",(char *) "id", NULL
11592 };
11593
11594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11596 if (!SWIG_IsOK(res1)) {
11597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11598 }
11599 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11601 if (!SWIG_IsOK(res2)) {
11602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11603 }
11604 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11605 if (obj2) {
11606 ecode3 = SWIG_AsVal_int(obj2, &val3);
11607 if (!SWIG_IsOK(ecode3)) {
11608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11609 }
11610 arg3 = static_cast< int >(val3);
11611 }
11612 {
11613 PyThreadState* __tstate = wxPyBeginAllowThreads();
11614 (arg1)->SetOwner(arg2,arg3);
11615 wxPyEndAllowThreads(__tstate);
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 resultobj = SWIG_Py_Void();
11619 return resultobj;
11620 fail:
11621 return NULL;
11622 }
11623
11624
11625 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11626 PyObject *resultobj = 0;
11627 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11628 wxEvtHandler *result = 0 ;
11629 void *argp1 = 0 ;
11630 int res1 = 0 ;
11631 PyObject *swig_obj[1] ;
11632
11633 if (!args) SWIG_fail;
11634 swig_obj[0] = args;
11635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11636 if (!SWIG_IsOK(res1)) {
11637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11638 }
11639 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11640 {
11641 PyThreadState* __tstate = wxPyBeginAllowThreads();
11642 result = (wxEvtHandler *)(arg1)->GetOwner();
11643 wxPyEndAllowThreads(__tstate);
11644 if (PyErr_Occurred()) SWIG_fail;
11645 }
11646 {
11647 resultobj = wxPyMake_wxObject(result, 0);
11648 }
11649 return resultobj;
11650 fail:
11651 return NULL;
11652 }
11653
11654
11655 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11656 PyObject *resultobj = 0;
11657 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11658 int arg2 = (int) -1 ;
11659 bool arg3 = (bool) false ;
11660 bool result;
11661 void *argp1 = 0 ;
11662 int res1 = 0 ;
11663 int val2 ;
11664 int ecode2 = 0 ;
11665 bool val3 ;
11666 int ecode3 = 0 ;
11667 PyObject * obj0 = 0 ;
11668 PyObject * obj1 = 0 ;
11669 PyObject * obj2 = 0 ;
11670 char * kwnames[] = {
11671 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11672 };
11673
11674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11676 if (!SWIG_IsOK(res1)) {
11677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11678 }
11679 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11680 if (obj1) {
11681 ecode2 = SWIG_AsVal_int(obj1, &val2);
11682 if (!SWIG_IsOK(ecode2)) {
11683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11684 }
11685 arg2 = static_cast< int >(val2);
11686 }
11687 if (obj2) {
11688 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11689 if (!SWIG_IsOK(ecode3)) {
11690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11691 }
11692 arg3 = static_cast< bool >(val3);
11693 }
11694 {
11695 PyThreadState* __tstate = wxPyBeginAllowThreads();
11696 result = (bool)(arg1)->Start(arg2,arg3);
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 {
11701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11702 }
11703 return resultobj;
11704 fail:
11705 return NULL;
11706 }
11707
11708
11709 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11710 PyObject *resultobj = 0;
11711 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11712 void *argp1 = 0 ;
11713 int res1 = 0 ;
11714 PyObject *swig_obj[1] ;
11715
11716 if (!args) SWIG_fail;
11717 swig_obj[0] = args;
11718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11719 if (!SWIG_IsOK(res1)) {
11720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11721 }
11722 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11723 {
11724 PyThreadState* __tstate = wxPyBeginAllowThreads();
11725 (arg1)->Stop();
11726 wxPyEndAllowThreads(__tstate);
11727 if (PyErr_Occurred()) SWIG_fail;
11728 }
11729 resultobj = SWIG_Py_Void();
11730 return resultobj;
11731 fail:
11732 return NULL;
11733 }
11734
11735
11736 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737 PyObject *resultobj = 0;
11738 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11739 void *argp1 = 0 ;
11740 int res1 = 0 ;
11741 PyObject *swig_obj[1] ;
11742
11743 if (!args) SWIG_fail;
11744 swig_obj[0] = args;
11745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11746 if (!SWIG_IsOK(res1)) {
11747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11748 }
11749 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11750 {
11751 PyThreadState* __tstate = wxPyBeginAllowThreads();
11752 (arg1)->Notify();
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 resultobj = SWIG_Py_Void();
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11764 PyObject *resultobj = 0;
11765 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11766 bool result;
11767 void *argp1 = 0 ;
11768 int res1 = 0 ;
11769 PyObject *swig_obj[1] ;
11770
11771 if (!args) SWIG_fail;
11772 swig_obj[0] = args;
11773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11774 if (!SWIG_IsOK(res1)) {
11775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11776 }
11777 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11778 {
11779 PyThreadState* __tstate = wxPyBeginAllowThreads();
11780 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11781 wxPyEndAllowThreads(__tstate);
11782 if (PyErr_Occurred()) SWIG_fail;
11783 }
11784 {
11785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11786 }
11787 return resultobj;
11788 fail:
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 PyObject *resultobj = 0;
11795 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11796 int result;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 PyObject *swig_obj[1] ;
11800
11801 if (!args) SWIG_fail;
11802 swig_obj[0] = args;
11803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11804 if (!SWIG_IsOK(res1)) {
11805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11806 }
11807 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 resultobj = SWIG_From_int(static_cast< int >(result));
11815 return resultobj;
11816 fail:
11817 return NULL;
11818 }
11819
11820
11821 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11822 PyObject *resultobj = 0;
11823 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11824 int result;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 PyObject *swig_obj[1] ;
11828
11829 if (!args) SWIG_fail;
11830 swig_obj[0] = args;
11831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11834 }
11835 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (int)((wxPyTimer const *)arg1)->GetId();
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_From_int(static_cast< int >(result));
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11852 bool result;
11853 void *argp1 = 0 ;
11854 int res1 = 0 ;
11855 PyObject *swig_obj[1] ;
11856
11857 if (!args) SWIG_fail;
11858 swig_obj[0] = args;
11859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11862 }
11863 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11864 {
11865 PyThreadState* __tstate = wxPyBeginAllowThreads();
11866 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 {
11871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11872 }
11873 return resultobj;
11874 fail:
11875 return NULL;
11876 }
11877
11878
11879 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11880 PyObject *obj;
11881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11882 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11883 return SWIG_Py_Void();
11884 }
11885
11886 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11887 return SWIG_Python_InitShadowInstance(args);
11888 }
11889
11890 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11891 PyObject *resultobj = 0;
11892 int arg1 = (int) 0 ;
11893 int arg2 = (int) 0 ;
11894 wxTimerEvent *result = 0 ;
11895 int val1 ;
11896 int ecode1 = 0 ;
11897 int val2 ;
11898 int ecode2 = 0 ;
11899 PyObject * obj0 = 0 ;
11900 PyObject * obj1 = 0 ;
11901 char * kwnames[] = {
11902 (char *) "timerid",(char *) "interval", NULL
11903 };
11904
11905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11906 if (obj0) {
11907 ecode1 = SWIG_AsVal_int(obj0, &val1);
11908 if (!SWIG_IsOK(ecode1)) {
11909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11910 }
11911 arg1 = static_cast< int >(val1);
11912 }
11913 if (obj1) {
11914 ecode2 = SWIG_AsVal_int(obj1, &val2);
11915 if (!SWIG_IsOK(ecode2)) {
11916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11917 }
11918 arg2 = static_cast< int >(val2);
11919 }
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11927 return resultobj;
11928 fail:
11929 return NULL;
11930 }
11931
11932
11933 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11934 PyObject *resultobj = 0;
11935 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11936 int result;
11937 void *argp1 = 0 ;
11938 int res1 = 0 ;
11939 PyObject *swig_obj[1] ;
11940
11941 if (!args) SWIG_fail;
11942 swig_obj[0] = args;
11943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11944 if (!SWIG_IsOK(res1)) {
11945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11946 }
11947 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11948 {
11949 PyThreadState* __tstate = wxPyBeginAllowThreads();
11950 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 resultobj = SWIG_From_int(static_cast< int >(result));
11955 return resultobj;
11956 fail:
11957 return NULL;
11958 }
11959
11960
11961 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11962 PyObject *obj;
11963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11964 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11965 return SWIG_Py_Void();
11966 }
11967
11968 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11969 return SWIG_Python_InitShadowInstance(args);
11970 }
11971
11972 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11973 PyObject *resultobj = 0;
11974 wxTimer *arg1 = 0 ;
11975 wxTimerRunner *result = 0 ;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978
11979 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11981 if (!SWIG_IsOK(res1)) {
11982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11983 }
11984 if (!argp1) {
11985 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11986 }
11987 arg1 = reinterpret_cast< wxTimer * >(argp1);
11988 {
11989 if (!wxPyCheckForApp()) SWIG_fail;
11990 PyThreadState* __tstate = wxPyBeginAllowThreads();
11991 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11992 wxPyEndAllowThreads(__tstate);
11993 if (PyErr_Occurred()) SWIG_fail;
11994 }
11995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11996 return resultobj;
11997 fail:
11998 return NULL;
11999 }
12000
12001
12002 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12003 PyObject *resultobj = 0;
12004 wxTimer *arg1 = 0 ;
12005 int arg2 ;
12006 bool arg3 = (bool) false ;
12007 wxTimerRunner *result = 0 ;
12008 void *argp1 = 0 ;
12009 int res1 = 0 ;
12010 int val2 ;
12011 int ecode2 = 0 ;
12012 bool val3 ;
12013 int ecode3 = 0 ;
12014
12015 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12017 if (!SWIG_IsOK(res1)) {
12018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12019 }
12020 if (!argp1) {
12021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12022 }
12023 arg1 = reinterpret_cast< wxTimer * >(argp1);
12024 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12025 if (!SWIG_IsOK(ecode2)) {
12026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12027 }
12028 arg2 = static_cast< int >(val2);
12029 if (swig_obj[2]) {
12030 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12031 if (!SWIG_IsOK(ecode3)) {
12032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12033 }
12034 arg3 = static_cast< bool >(val3);
12035 }
12036 {
12037 if (!wxPyCheckForApp()) SWIG_fail;
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12040 wxPyEndAllowThreads(__tstate);
12041 if (PyErr_Occurred()) SWIG_fail;
12042 }
12043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12044 return resultobj;
12045 fail:
12046 return NULL;
12047 }
12048
12049
12050 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12051 int argc;
12052 PyObject *argv[4];
12053
12054 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12055 --argc;
12056 if (argc == 1) {
12057 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12058 }
12059 if ((argc >= 2) && (argc <= 3)) {
12060 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12061 }
12062
12063 fail:
12064 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12065 return NULL;
12066 }
12067
12068
12069 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12070 PyObject *resultobj = 0;
12071 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12072 void *argp1 = 0 ;
12073 int res1 = 0 ;
12074 PyObject *swig_obj[1] ;
12075
12076 if (!args) SWIG_fail;
12077 swig_obj[0] = args;
12078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12079 if (!SWIG_IsOK(res1)) {
12080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12081 }
12082 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 delete arg1;
12086
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 resultobj = SWIG_Py_Void();
12091 return resultobj;
12092 fail:
12093 return NULL;
12094 }
12095
12096
12097 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12098 PyObject *resultobj = 0;
12099 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12100 int arg2 ;
12101 bool arg3 = (bool) false ;
12102 void *argp1 = 0 ;
12103 int res1 = 0 ;
12104 int val2 ;
12105 int ecode2 = 0 ;
12106 bool val3 ;
12107 int ecode3 = 0 ;
12108 PyObject * obj0 = 0 ;
12109 PyObject * obj1 = 0 ;
12110 PyObject * obj2 = 0 ;
12111 char * kwnames[] = {
12112 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12113 };
12114
12115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12117 if (!SWIG_IsOK(res1)) {
12118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12119 }
12120 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12121 ecode2 = SWIG_AsVal_int(obj1, &val2);
12122 if (!SWIG_IsOK(ecode2)) {
12123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12124 }
12125 arg2 = static_cast< int >(val2);
12126 if (obj2) {
12127 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12128 if (!SWIG_IsOK(ecode3)) {
12129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12130 }
12131 arg3 = static_cast< bool >(val3);
12132 }
12133 {
12134 PyThreadState* __tstate = wxPyBeginAllowThreads();
12135 (arg1)->Start(arg2,arg3);
12136 wxPyEndAllowThreads(__tstate);
12137 if (PyErr_Occurred()) SWIG_fail;
12138 }
12139 resultobj = SWIG_Py_Void();
12140 return resultobj;
12141 fail:
12142 return NULL;
12143 }
12144
12145
12146 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12147 PyObject *obj;
12148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12149 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12150 return SWIG_Py_Void();
12151 }
12152
12153 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154 return SWIG_Python_InitShadowInstance(args);
12155 }
12156
12157 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12158 PyObject *resultobj = 0;
12159 wxLog *result = 0 ;
12160
12161 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12162 {
12163 PyThreadState* __tstate = wxPyBeginAllowThreads();
12164 result = (wxLog *)new wxLog();
12165 wxPyEndAllowThreads(__tstate);
12166 if (PyErr_Occurred()) SWIG_fail;
12167 }
12168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12169 return resultobj;
12170 fail:
12171 return NULL;
12172 }
12173
12174
12175 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12176 PyObject *resultobj = 0;
12177 wxLog *arg1 = (wxLog *) 0 ;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 PyObject *swig_obj[1] ;
12181
12182 if (!args) SWIG_fail;
12183 swig_obj[0] = args;
12184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12185 if (!SWIG_IsOK(res1)) {
12186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12187 }
12188 arg1 = reinterpret_cast< wxLog * >(argp1);
12189 {
12190 PyThreadState* __tstate = wxPyBeginAllowThreads();
12191 delete arg1;
12192
12193 wxPyEndAllowThreads(__tstate);
12194 if (PyErr_Occurred()) SWIG_fail;
12195 }
12196 resultobj = SWIG_Py_Void();
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12204 PyObject *resultobj = 0;
12205 bool result;
12206
12207 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12208 {
12209 PyThreadState* __tstate = wxPyBeginAllowThreads();
12210 result = (bool)wxLog::IsEnabled();
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 {
12215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12216 }
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12224 PyObject *resultobj = 0;
12225 bool arg1 = (bool) true ;
12226 bool result;
12227 bool val1 ;
12228 int ecode1 = 0 ;
12229 PyObject * obj0 = 0 ;
12230 char * kwnames[] = {
12231 (char *) "doIt", NULL
12232 };
12233
12234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12235 if (obj0) {
12236 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12237 if (!SWIG_IsOK(ecode1)) {
12238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12239 }
12240 arg1 = static_cast< bool >(val1);
12241 }
12242 {
12243 PyThreadState* __tstate = wxPyBeginAllowThreads();
12244 result = (bool)wxLog::EnableLogging(arg1);
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 {
12249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12250 }
12251 return resultobj;
12252 fail:
12253 return NULL;
12254 }
12255
12256
12257 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12258 PyObject *resultobj = 0;
12259 wxLogLevel arg1 ;
12260 wxChar *arg2 = (wxChar *) 0 ;
12261 time_t arg3 ;
12262 unsigned long val1 ;
12263 int ecode1 = 0 ;
12264 void *argp2 = 0 ;
12265 int res2 = 0 ;
12266 unsigned int val3 ;
12267 int ecode3 = 0 ;
12268 PyObject * obj0 = 0 ;
12269 PyObject * obj1 = 0 ;
12270 PyObject * obj2 = 0 ;
12271 char * kwnames[] = {
12272 (char *) "level",(char *) "szString",(char *) "t", NULL
12273 };
12274
12275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12276 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12277 if (!SWIG_IsOK(ecode1)) {
12278 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12279 }
12280 arg1 = static_cast< wxLogLevel >(val1);
12281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12282 if (!SWIG_IsOK(res2)) {
12283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12284 }
12285 arg2 = reinterpret_cast< wxChar * >(argp2);
12286 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12287 if (!SWIG_IsOK(ecode3)) {
12288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12289 }
12290 arg3 = static_cast< time_t >(val3);
12291 {
12292 PyThreadState* __tstate = wxPyBeginAllowThreads();
12293 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12294 wxPyEndAllowThreads(__tstate);
12295 if (PyErr_Occurred()) SWIG_fail;
12296 }
12297 resultobj = SWIG_Py_Void();
12298 return resultobj;
12299 fail:
12300 return NULL;
12301 }
12302
12303
12304 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12305 PyObject *resultobj = 0;
12306 wxLog *arg1 = (wxLog *) 0 ;
12307 void *argp1 = 0 ;
12308 int res1 = 0 ;
12309 PyObject *swig_obj[1] ;
12310
12311 if (!args) SWIG_fail;
12312 swig_obj[0] = args;
12313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12314 if (!SWIG_IsOK(res1)) {
12315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12316 }
12317 arg1 = reinterpret_cast< wxLog * >(argp1);
12318 {
12319 PyThreadState* __tstate = wxPyBeginAllowThreads();
12320 (arg1)->Flush();
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 resultobj = SWIG_Py_Void();
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12332 PyObject *resultobj = 0;
12333
12334 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 wxLog::FlushActive();
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 resultobj = SWIG_Py_Void();
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12349 PyObject *resultobj = 0;
12350 wxLog *result = 0 ;
12351
12352 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12353 {
12354 PyThreadState* __tstate = wxPyBeginAllowThreads();
12355 result = (wxLog *)wxLog::GetActiveTarget();
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12360 return resultobj;
12361 fail:
12362 return NULL;
12363 }
12364
12365
12366 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12367 PyObject *resultobj = 0;
12368 wxLog *arg1 = (wxLog *) 0 ;
12369 wxLog *result = 0 ;
12370 int res1 = 0 ;
12371 PyObject * obj0 = 0 ;
12372 char * kwnames[] = {
12373 (char *) "pLogger", NULL
12374 };
12375
12376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12377 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12378 if (!SWIG_IsOK(res1)) {
12379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12380 }
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12395 PyObject *resultobj = 0;
12396
12397 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 wxLog::Suspend();
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 resultobj = SWIG_Py_Void();
12405 return resultobj;
12406 fail:
12407 return NULL;
12408 }
12409
12410
12411 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12412 PyObject *resultobj = 0;
12413
12414 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12415 {
12416 PyThreadState* __tstate = wxPyBeginAllowThreads();
12417 wxLog::Resume();
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 resultobj = SWIG_Py_Void();
12422 return resultobj;
12423 fail:
12424 return NULL;
12425 }
12426
12427
12428 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12429 PyObject *resultobj = 0;
12430 bool arg1 = (bool) true ;
12431 bool val1 ;
12432 int ecode1 = 0 ;
12433 PyObject * obj0 = 0 ;
12434 char * kwnames[] = {
12435 (char *) "bVerbose", NULL
12436 };
12437
12438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12439 if (obj0) {
12440 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12441 if (!SWIG_IsOK(ecode1)) {
12442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12443 }
12444 arg1 = static_cast< bool >(val1);
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 wxLog::SetVerbose(arg1);
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 resultobj = SWIG_Py_Void();
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12460 PyObject *resultobj = 0;
12461 wxLogLevel arg1 ;
12462 unsigned long val1 ;
12463 int ecode1 = 0 ;
12464 PyObject * obj0 = 0 ;
12465 char * kwnames[] = {
12466 (char *) "logLevel", NULL
12467 };
12468
12469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12470 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12471 if (!SWIG_IsOK(ecode1)) {
12472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12473 }
12474 arg1 = static_cast< wxLogLevel >(val1);
12475 {
12476 PyThreadState* __tstate = wxPyBeginAllowThreads();
12477 wxLog::SetLogLevel(arg1);
12478 wxPyEndAllowThreads(__tstate);
12479 if (PyErr_Occurred()) SWIG_fail;
12480 }
12481 resultobj = SWIG_Py_Void();
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12489 PyObject *resultobj = 0;
12490
12491 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 wxLog::DontCreateOnDemand();
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 resultobj = SWIG_Py_Void();
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12506 PyObject *resultobj = 0;
12507 bool arg1 = (bool) true ;
12508 bool val1 ;
12509 int ecode1 = 0 ;
12510 PyObject * obj0 = 0 ;
12511 char * kwnames[] = {
12512 (char *) "bRepetCounting", NULL
12513 };
12514
12515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12516 if (obj0) {
12517 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12518 if (!SWIG_IsOK(ecode1)) {
12519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12520 }
12521 arg1 = static_cast< bool >(val1);
12522 }
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 wxLog::SetRepetitionCounting(arg1);
12526 wxPyEndAllowThreads(__tstate);
12527 if (PyErr_Occurred()) SWIG_fail;
12528 }
12529 resultobj = SWIG_Py_Void();
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12537 PyObject *resultobj = 0;
12538 bool result;
12539
12540 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12541 {
12542 PyThreadState* __tstate = wxPyBeginAllowThreads();
12543 result = (bool)wxLog::GetRepetitionCounting();
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 {
12548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12549 }
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12557 PyObject *resultobj = 0;
12558 wxTraceMask arg1 ;
12559 unsigned long val1 ;
12560 int ecode1 = 0 ;
12561 PyObject * obj0 = 0 ;
12562 char * kwnames[] = {
12563 (char *) "ulMask", NULL
12564 };
12565
12566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12567 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12568 if (!SWIG_IsOK(ecode1)) {
12569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12570 }
12571 arg1 = static_cast< wxTraceMask >(val1);
12572 {
12573 PyThreadState* __tstate = wxPyBeginAllowThreads();
12574 wxLog::SetTraceMask(arg1);
12575 wxPyEndAllowThreads(__tstate);
12576 if (PyErr_Occurred()) SWIG_fail;
12577 }
12578 resultobj = SWIG_Py_Void();
12579 return resultobj;
12580 fail:
12581 return NULL;
12582 }
12583
12584
12585 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12586 PyObject *resultobj = 0;
12587 wxString *arg1 = 0 ;
12588 bool temp1 = false ;
12589 PyObject * obj0 = 0 ;
12590 char * kwnames[] = {
12591 (char *) "str", NULL
12592 };
12593
12594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12595 {
12596 arg1 = wxString_in_helper(obj0);
12597 if (arg1 == NULL) SWIG_fail;
12598 temp1 = true;
12599 }
12600 {
12601 PyThreadState* __tstate = wxPyBeginAllowThreads();
12602 wxLog::AddTraceMask((wxString const &)*arg1);
12603 wxPyEndAllowThreads(__tstate);
12604 if (PyErr_Occurred()) SWIG_fail;
12605 }
12606 resultobj = SWIG_Py_Void();
12607 {
12608 if (temp1)
12609 delete arg1;
12610 }
12611 return resultobj;
12612 fail:
12613 {
12614 if (temp1)
12615 delete arg1;
12616 }
12617 return NULL;
12618 }
12619
12620
12621 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12622 PyObject *resultobj = 0;
12623 wxString *arg1 = 0 ;
12624 bool temp1 = false ;
12625 PyObject * obj0 = 0 ;
12626 char * kwnames[] = {
12627 (char *) "str", NULL
12628 };
12629
12630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12631 {
12632 arg1 = wxString_in_helper(obj0);
12633 if (arg1 == NULL) SWIG_fail;
12634 temp1 = true;
12635 }
12636 {
12637 PyThreadState* __tstate = wxPyBeginAllowThreads();
12638 wxLog::RemoveTraceMask((wxString const &)*arg1);
12639 wxPyEndAllowThreads(__tstate);
12640 if (PyErr_Occurred()) SWIG_fail;
12641 }
12642 resultobj = SWIG_Py_Void();
12643 {
12644 if (temp1)
12645 delete arg1;
12646 }
12647 return resultobj;
12648 fail:
12649 {
12650 if (temp1)
12651 delete arg1;
12652 }
12653 return NULL;
12654 }
12655
12656
12657 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12658 PyObject *resultobj = 0;
12659
12660 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12661 {
12662 PyThreadState* __tstate = wxPyBeginAllowThreads();
12663 wxLog::ClearTraceMasks();
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 resultobj = SWIG_Py_Void();
12668 return resultobj;
12669 fail:
12670 return NULL;
12671 }
12672
12673
12674 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12675 PyObject *resultobj = 0;
12676 wxArrayString *result = 0 ;
12677
12678 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 {
12682 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12683 result = (wxArrayString *) &_result_ref;
12684 }
12685 wxPyEndAllowThreads(__tstate);
12686 if (PyErr_Occurred()) SWIG_fail;
12687 }
12688 {
12689 resultobj = wxArrayString2PyList_helper(*result);
12690 }
12691 return resultobj;
12692 fail:
12693 return NULL;
12694 }
12695
12696
12697 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12698 PyObject *resultobj = 0;
12699 wxChar *arg1 = (wxChar *) 0 ;
12700 void *argp1 = 0 ;
12701 int res1 = 0 ;
12702 PyObject * obj0 = 0 ;
12703 char * kwnames[] = {
12704 (char *) "ts", NULL
12705 };
12706
12707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12709 if (!SWIG_IsOK(res1)) {
12710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12711 }
12712 arg1 = reinterpret_cast< wxChar * >(argp1);
12713 {
12714 PyThreadState* __tstate = wxPyBeginAllowThreads();
12715 wxLog::SetTimestamp((wxChar const *)arg1);
12716 wxPyEndAllowThreads(__tstate);
12717 if (PyErr_Occurred()) SWIG_fail;
12718 }
12719 resultobj = SWIG_Py_Void();
12720 return resultobj;
12721 fail:
12722 return NULL;
12723 }
12724
12725
12726 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12727 PyObject *resultobj = 0;
12728 bool result;
12729
12730 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12731 {
12732 PyThreadState* __tstate = wxPyBeginAllowThreads();
12733 result = (bool)wxLog::GetVerbose();
12734 wxPyEndAllowThreads(__tstate);
12735 if (PyErr_Occurred()) SWIG_fail;
12736 }
12737 {
12738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12739 }
12740 return resultobj;
12741 fail:
12742 return NULL;
12743 }
12744
12745
12746 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12747 PyObject *resultobj = 0;
12748 wxTraceMask result;
12749
12750 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12751 {
12752 PyThreadState* __tstate = wxPyBeginAllowThreads();
12753 result = (wxTraceMask)wxLog::GetTraceMask();
12754 wxPyEndAllowThreads(__tstate);
12755 if (PyErr_Occurred()) SWIG_fail;
12756 }
12757 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12758 return resultobj;
12759 fail:
12760 return NULL;
12761 }
12762
12763
12764 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12765 PyObject *resultobj = 0;
12766 wxChar *arg1 = (wxChar *) 0 ;
12767 bool result;
12768 void *argp1 = 0 ;
12769 int res1 = 0 ;
12770 PyObject * obj0 = 0 ;
12771 char * kwnames[] = {
12772 (char *) "mask", NULL
12773 };
12774
12775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12777 if (!SWIG_IsOK(res1)) {
12778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12779 }
12780 arg1 = reinterpret_cast< wxChar * >(argp1);
12781 {
12782 PyThreadState* __tstate = wxPyBeginAllowThreads();
12783 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12784 wxPyEndAllowThreads(__tstate);
12785 if (PyErr_Occurred()) SWIG_fail;
12786 }
12787 {
12788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12789 }
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 PyObject *resultobj = 0;
12798 wxLogLevel result;
12799
12800 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12801 {
12802 PyThreadState* __tstate = wxPyBeginAllowThreads();
12803 result = (wxLogLevel)wxLog::GetLogLevel();
12804 wxPyEndAllowThreads(__tstate);
12805 if (PyErr_Occurred()) SWIG_fail;
12806 }
12807 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12808 return resultobj;
12809 fail:
12810 return NULL;
12811 }
12812
12813
12814 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12815 PyObject *resultobj = 0;
12816 wxChar *result = 0 ;
12817
12818 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12819 {
12820 PyThreadState* __tstate = wxPyBeginAllowThreads();
12821 result = (wxChar *)wxLog::GetTimestamp();
12822 wxPyEndAllowThreads(__tstate);
12823 if (PyErr_Occurred()) SWIG_fail;
12824 }
12825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12833 PyObject *resultobj = 0;
12834 wxString result;
12835
12836 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12837 {
12838 PyThreadState* __tstate = wxPyBeginAllowThreads();
12839 result = wxLog_TimeStamp();
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 {
12844 #if wxUSE_UNICODE
12845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12846 #else
12847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12848 #endif
12849 }
12850 return resultobj;
12851 fail:
12852 return NULL;
12853 }
12854
12855
12856 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12857 PyObject *resultobj = 0;
12858 wxLog *arg1 = (wxLog *) 0 ;
12859 void *argp1 = 0 ;
12860 int res1 = 0 ;
12861 PyObject *swig_obj[1] ;
12862
12863 if (!args) SWIG_fail;
12864 swig_obj[0] = args;
12865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12866 if (!SWIG_IsOK(res1)) {
12867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12868 }
12869 arg1 = reinterpret_cast< wxLog * >(argp1);
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 wxLog_Destroy(arg1);
12873 wxPyEndAllowThreads(__tstate);
12874 if (PyErr_Occurred()) SWIG_fail;
12875 }
12876 resultobj = SWIG_Py_Void();
12877 return resultobj;
12878 fail:
12879 return NULL;
12880 }
12881
12882
12883 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12884 PyObject *obj;
12885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12886 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12887 return SWIG_Py_Void();
12888 }
12889
12890 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12891 return SWIG_Python_InitShadowInstance(args);
12892 }
12893
12894 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12895 PyObject *resultobj = 0;
12896 wxLogStderr *result = 0 ;
12897
12898 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12899 {
12900 PyThreadState* __tstate = wxPyBeginAllowThreads();
12901 result = (wxLogStderr *)new wxLogStderr();
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 PyObject *obj;
12914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12915 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12916 return SWIG_Py_Void();
12917 }
12918
12919 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12920 return SWIG_Python_InitShadowInstance(args);
12921 }
12922
12923 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12924 PyObject *resultobj = 0;
12925 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12926 wxLogTextCtrl *result = 0 ;
12927 void *argp1 = 0 ;
12928 int res1 = 0 ;
12929 PyObject * obj0 = 0 ;
12930 char * kwnames[] = {
12931 (char *) "pTextCtrl", NULL
12932 };
12933
12934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12936 if (!SWIG_IsOK(res1)) {
12937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12938 }
12939 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12947 return resultobj;
12948 fail:
12949 return NULL;
12950 }
12951
12952
12953 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12954 PyObject *obj;
12955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12956 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12957 return SWIG_Py_Void();
12958 }
12959
12960 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 return SWIG_Python_InitShadowInstance(args);
12962 }
12963
12964 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12965 PyObject *resultobj = 0;
12966 wxLogGui *result = 0 ;
12967
12968 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 result = (wxLogGui *)new wxLogGui();
12972 wxPyEndAllowThreads(__tstate);
12973 if (PyErr_Occurred()) SWIG_fail;
12974 }
12975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12976 return resultobj;
12977 fail:
12978 return NULL;
12979 }
12980
12981
12982 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12983 PyObject *obj;
12984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12985 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12986 return SWIG_Py_Void();
12987 }
12988
12989 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12990 return SWIG_Python_InitShadowInstance(args);
12991 }
12992
12993 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12994 PyObject *resultobj = 0;
12995 wxFrame *arg1 = (wxFrame *) 0 ;
12996 wxString *arg2 = 0 ;
12997 bool arg3 = (bool) true ;
12998 bool arg4 = (bool) true ;
12999 wxLogWindow *result = 0 ;
13000 void *argp1 = 0 ;
13001 int res1 = 0 ;
13002 bool temp2 = false ;
13003 bool val3 ;
13004 int ecode3 = 0 ;
13005 bool val4 ;
13006 int ecode4 = 0 ;
13007 PyObject * obj0 = 0 ;
13008 PyObject * obj1 = 0 ;
13009 PyObject * obj2 = 0 ;
13010 PyObject * obj3 = 0 ;
13011 char * kwnames[] = {
13012 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13013 };
13014
13015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13017 if (!SWIG_IsOK(res1)) {
13018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13019 }
13020 arg1 = reinterpret_cast< wxFrame * >(argp1);
13021 {
13022 arg2 = wxString_in_helper(obj1);
13023 if (arg2 == NULL) SWIG_fail;
13024 temp2 = true;
13025 }
13026 if (obj2) {
13027 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13028 if (!SWIG_IsOK(ecode3)) {
13029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13030 }
13031 arg3 = static_cast< bool >(val3);
13032 }
13033 if (obj3) {
13034 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13035 if (!SWIG_IsOK(ecode4)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13037 }
13038 arg4 = static_cast< bool >(val4);
13039 }
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13047 {
13048 if (temp2)
13049 delete arg2;
13050 }
13051 return resultobj;
13052 fail:
13053 {
13054 if (temp2)
13055 delete arg2;
13056 }
13057 return NULL;
13058 }
13059
13060
13061 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13062 PyObject *resultobj = 0;
13063 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13064 bool arg2 = (bool) true ;
13065 void *argp1 = 0 ;
13066 int res1 = 0 ;
13067 bool val2 ;
13068 int ecode2 = 0 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 char * kwnames[] = {
13072 (char *) "self",(char *) "bShow", NULL
13073 };
13074
13075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13077 if (!SWIG_IsOK(res1)) {
13078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13079 }
13080 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13081 if (obj1) {
13082 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13083 if (!SWIG_IsOK(ecode2)) {
13084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13085 }
13086 arg2 = static_cast< bool >(val2);
13087 }
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 (arg1)->Show(arg2);
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_Py_Void();
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13102 PyObject *resultobj = 0;
13103 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13104 wxFrame *result = 0 ;
13105 void *argp1 = 0 ;
13106 int res1 = 0 ;
13107 PyObject *swig_obj[1] ;
13108
13109 if (!args) SWIG_fail;
13110 swig_obj[0] = args;
13111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13112 if (!SWIG_IsOK(res1)) {
13113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13114 }
13115 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13116 {
13117 PyThreadState* __tstate = wxPyBeginAllowThreads();
13118 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 {
13123 resultobj = wxPyMake_wxObject(result, (bool)0);
13124 }
13125 return resultobj;
13126 fail:
13127 return NULL;
13128 }
13129
13130
13131 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13132 PyObject *resultobj = 0;
13133 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13134 wxLog *result = 0 ;
13135 void *argp1 = 0 ;
13136 int res1 = 0 ;
13137 PyObject *swig_obj[1] ;
13138
13139 if (!args) SWIG_fail;
13140 swig_obj[0] = args;
13141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13142 if (!SWIG_IsOK(res1)) {
13143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13144 }
13145 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13146 {
13147 PyThreadState* __tstate = wxPyBeginAllowThreads();
13148 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13153 return resultobj;
13154 fail:
13155 return NULL;
13156 }
13157
13158
13159 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13160 PyObject *resultobj = 0;
13161 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13162 bool result;
13163 void *argp1 = 0 ;
13164 int res1 = 0 ;
13165 PyObject *swig_obj[1] ;
13166
13167 if (!args) SWIG_fail;
13168 swig_obj[0] = args;
13169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13170 if (!SWIG_IsOK(res1)) {
13171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13172 }
13173 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13174 {
13175 PyThreadState* __tstate = wxPyBeginAllowThreads();
13176 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13177 wxPyEndAllowThreads(__tstate);
13178 if (PyErr_Occurred()) SWIG_fail;
13179 }
13180 {
13181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13182 }
13183 return resultobj;
13184 fail:
13185 return NULL;
13186 }
13187
13188
13189 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13190 PyObject *resultobj = 0;
13191 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13192 bool arg2 ;
13193 void *argp1 = 0 ;
13194 int res1 = 0 ;
13195 bool val2 ;
13196 int ecode2 = 0 ;
13197 PyObject * obj0 = 0 ;
13198 PyObject * obj1 = 0 ;
13199 char * kwnames[] = {
13200 (char *) "self",(char *) "bDoPass", NULL
13201 };
13202
13203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13205 if (!SWIG_IsOK(res1)) {
13206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13207 }
13208 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13209 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13210 if (!SWIG_IsOK(ecode2)) {
13211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13212 }
13213 arg2 = static_cast< bool >(val2);
13214 {
13215 PyThreadState* __tstate = wxPyBeginAllowThreads();
13216 (arg1)->PassMessages(arg2);
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 resultobj = SWIG_Py_Void();
13221 return resultobj;
13222 fail:
13223 return NULL;
13224 }
13225
13226
13227 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13228 PyObject *obj;
13229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13230 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13231 return SWIG_Py_Void();
13232 }
13233
13234 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13235 return SWIG_Python_InitShadowInstance(args);
13236 }
13237
13238 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj = 0;
13240 wxLog *arg1 = (wxLog *) 0 ;
13241 wxLogChain *result = 0 ;
13242 void *argp1 = 0 ;
13243 int res1 = 0 ;
13244 PyObject * obj0 = 0 ;
13245 char * kwnames[] = {
13246 (char *) "logger", NULL
13247 };
13248
13249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13251 if (!SWIG_IsOK(res1)) {
13252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13253 }
13254 arg1 = reinterpret_cast< wxLog * >(argp1);
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 result = (wxLogChain *)new wxLogChain(arg1);
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13269 PyObject *resultobj = 0;
13270 wxLogChain *arg1 = (wxLogChain *) 0 ;
13271 wxLog *arg2 = (wxLog *) 0 ;
13272 void *argp1 = 0 ;
13273 int res1 = 0 ;
13274 void *argp2 = 0 ;
13275 int res2 = 0 ;
13276 PyObject * obj0 = 0 ;
13277 PyObject * obj1 = 0 ;
13278 char * kwnames[] = {
13279 (char *) "self",(char *) "logger", NULL
13280 };
13281
13282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13284 if (!SWIG_IsOK(res1)) {
13285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13286 }
13287 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13289 if (!SWIG_IsOK(res2)) {
13290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13291 }
13292 arg2 = reinterpret_cast< wxLog * >(argp2);
13293 {
13294 PyThreadState* __tstate = wxPyBeginAllowThreads();
13295 (arg1)->SetLog(arg2);
13296 wxPyEndAllowThreads(__tstate);
13297 if (PyErr_Occurred()) SWIG_fail;
13298 }
13299 resultobj = SWIG_Py_Void();
13300 return resultobj;
13301 fail:
13302 return NULL;
13303 }
13304
13305
13306 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13307 PyObject *resultobj = 0;
13308 wxLogChain *arg1 = (wxLogChain *) 0 ;
13309 bool arg2 ;
13310 void *argp1 = 0 ;
13311 int res1 = 0 ;
13312 bool val2 ;
13313 int ecode2 = 0 ;
13314 PyObject * obj0 = 0 ;
13315 PyObject * obj1 = 0 ;
13316 char * kwnames[] = {
13317 (char *) "self",(char *) "bDoPass", NULL
13318 };
13319
13320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13322 if (!SWIG_IsOK(res1)) {
13323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13324 }
13325 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13326 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13327 if (!SWIG_IsOK(ecode2)) {
13328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13329 }
13330 arg2 = static_cast< bool >(val2);
13331 {
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 (arg1)->PassMessages(arg2);
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 resultobj = SWIG_Py_Void();
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13345 PyObject *resultobj = 0;
13346 wxLogChain *arg1 = (wxLogChain *) 0 ;
13347 bool result;
13348 void *argp1 = 0 ;
13349 int res1 = 0 ;
13350 PyObject *swig_obj[1] ;
13351
13352 if (!args) SWIG_fail;
13353 swig_obj[0] = args;
13354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13355 if (!SWIG_IsOK(res1)) {
13356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13357 }
13358 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13359 {
13360 PyThreadState* __tstate = wxPyBeginAllowThreads();
13361 result = (bool)(arg1)->IsPassingMessages();
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 {
13366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13367 }
13368 return resultobj;
13369 fail:
13370 return NULL;
13371 }
13372
13373
13374 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13375 PyObject *resultobj = 0;
13376 wxLogChain *arg1 = (wxLogChain *) 0 ;
13377 wxLog *result = 0 ;
13378 void *argp1 = 0 ;
13379 int res1 = 0 ;
13380 PyObject *swig_obj[1] ;
13381
13382 if (!args) SWIG_fail;
13383 swig_obj[0] = args;
13384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13385 if (!SWIG_IsOK(res1)) {
13386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13387 }
13388 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13389 {
13390 PyThreadState* __tstate = wxPyBeginAllowThreads();
13391 result = (wxLog *)(arg1)->GetOldLog();
13392 wxPyEndAllowThreads(__tstate);
13393 if (PyErr_Occurred()) SWIG_fail;
13394 }
13395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13396 return resultobj;
13397 fail:
13398 return NULL;
13399 }
13400
13401
13402 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13403 PyObject *obj;
13404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13405 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13406 return SWIG_Py_Void();
13407 }
13408
13409 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13410 return SWIG_Python_InitShadowInstance(args);
13411 }
13412
13413 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13414 PyObject *resultobj = 0;
13415 wxLogBuffer *result = 0 ;
13416
13417 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13418 {
13419 PyThreadState* __tstate = wxPyBeginAllowThreads();
13420 result = (wxLogBuffer *)new wxLogBuffer();
13421 wxPyEndAllowThreads(__tstate);
13422 if (PyErr_Occurred()) SWIG_fail;
13423 }
13424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13425 return resultobj;
13426 fail:
13427 return NULL;
13428 }
13429
13430
13431 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432 PyObject *resultobj = 0;
13433 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13434 wxString *result = 0 ;
13435 void *argp1 = 0 ;
13436 int res1 = 0 ;
13437 PyObject *swig_obj[1] ;
13438
13439 if (!args) SWIG_fail;
13440 swig_obj[0] = args;
13441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13442 if (!SWIG_IsOK(res1)) {
13443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13444 }
13445 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13446 {
13447 PyThreadState* __tstate = wxPyBeginAllowThreads();
13448 {
13449 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13450 result = (wxString *) &_result_ref;
13451 }
13452 wxPyEndAllowThreads(__tstate);
13453 if (PyErr_Occurred()) SWIG_fail;
13454 }
13455 {
13456 #if wxUSE_UNICODE
13457 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13458 #else
13459 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13460 #endif
13461 }
13462 return resultobj;
13463 fail:
13464 return NULL;
13465 }
13466
13467
13468 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13469 PyObject *obj;
13470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13471 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13472 return SWIG_Py_Void();
13473 }
13474
13475 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13476 return SWIG_Python_InitShadowInstance(args);
13477 }
13478
13479 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13480 PyObject *resultobj = 0;
13481 unsigned long result;
13482
13483 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13484 {
13485 PyThreadState* __tstate = wxPyBeginAllowThreads();
13486 result = (unsigned long)wxSysErrorCode();
13487 wxPyEndAllowThreads(__tstate);
13488 if (PyErr_Occurred()) SWIG_fail;
13489 }
13490 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13491 return resultobj;
13492 fail:
13493 return NULL;
13494 }
13495
13496
13497 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13498 PyObject *resultobj = 0;
13499 unsigned long arg1 = (unsigned long) 0 ;
13500 wxString result;
13501 unsigned long val1 ;
13502 int ecode1 = 0 ;
13503 PyObject * obj0 = 0 ;
13504 char * kwnames[] = {
13505 (char *) "nErrCode", NULL
13506 };
13507
13508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13509 if (obj0) {
13510 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13511 if (!SWIG_IsOK(ecode1)) {
13512 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13513 }
13514 arg1 = static_cast< unsigned long >(val1);
13515 }
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 result = wxSysErrorMsg(arg1);
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 {
13523 #if wxUSE_UNICODE
13524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13525 #else
13526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13527 #endif
13528 }
13529 return resultobj;
13530 fail:
13531 return NULL;
13532 }
13533
13534
13535 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13536 PyObject *resultobj = 0;
13537 wxString *arg1 = 0 ;
13538 bool temp1 = false ;
13539 PyObject * obj0 = 0 ;
13540 char * kwnames[] = {
13541 (char *) "msg", NULL
13542 };
13543
13544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13545 {
13546 arg1 = wxString_in_helper(obj0);
13547 if (arg1 == NULL) SWIG_fail;
13548 temp1 = true;
13549 }
13550 {
13551 PyThreadState* __tstate = wxPyBeginAllowThreads();
13552 wxPyLogFatalError((wxString const &)*arg1);
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 resultobj = SWIG_Py_Void();
13557 {
13558 if (temp1)
13559 delete arg1;
13560 }
13561 return resultobj;
13562 fail:
13563 {
13564 if (temp1)
13565 delete arg1;
13566 }
13567 return NULL;
13568 }
13569
13570
13571 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj = 0;
13573 wxString *arg1 = 0 ;
13574 bool temp1 = false ;
13575 PyObject * obj0 = 0 ;
13576 char * kwnames[] = {
13577 (char *) "msg", NULL
13578 };
13579
13580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13581 {
13582 arg1 = wxString_in_helper(obj0);
13583 if (arg1 == NULL) SWIG_fail;
13584 temp1 = true;
13585 }
13586 {
13587 PyThreadState* __tstate = wxPyBeginAllowThreads();
13588 wxPyLogError((wxString const &)*arg1);
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 resultobj = SWIG_Py_Void();
13593 {
13594 if (temp1)
13595 delete arg1;
13596 }
13597 return resultobj;
13598 fail:
13599 {
13600 if (temp1)
13601 delete arg1;
13602 }
13603 return NULL;
13604 }
13605
13606
13607 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13608 PyObject *resultobj = 0;
13609 wxString *arg1 = 0 ;
13610 bool temp1 = false ;
13611 PyObject * obj0 = 0 ;
13612 char * kwnames[] = {
13613 (char *) "msg", NULL
13614 };
13615
13616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13617 {
13618 arg1 = wxString_in_helper(obj0);
13619 if (arg1 == NULL) SWIG_fail;
13620 temp1 = true;
13621 }
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 wxPyLogWarning((wxString const &)*arg1);
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 resultobj = SWIG_Py_Void();
13629 {
13630 if (temp1)
13631 delete arg1;
13632 }
13633 return resultobj;
13634 fail:
13635 {
13636 if (temp1)
13637 delete arg1;
13638 }
13639 return NULL;
13640 }
13641
13642
13643 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13644 PyObject *resultobj = 0;
13645 wxString *arg1 = 0 ;
13646 bool temp1 = false ;
13647 PyObject * obj0 = 0 ;
13648 char * kwnames[] = {
13649 (char *) "msg", NULL
13650 };
13651
13652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13653 {
13654 arg1 = wxString_in_helper(obj0);
13655 if (arg1 == NULL) SWIG_fail;
13656 temp1 = true;
13657 }
13658 {
13659 PyThreadState* __tstate = wxPyBeginAllowThreads();
13660 wxPyLogMessage((wxString const &)*arg1);
13661 wxPyEndAllowThreads(__tstate);
13662 if (PyErr_Occurred()) SWIG_fail;
13663 }
13664 resultobj = SWIG_Py_Void();
13665 {
13666 if (temp1)
13667 delete arg1;
13668 }
13669 return resultobj;
13670 fail:
13671 {
13672 if (temp1)
13673 delete arg1;
13674 }
13675 return NULL;
13676 }
13677
13678
13679 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13680 PyObject *resultobj = 0;
13681 wxString *arg1 = 0 ;
13682 bool temp1 = false ;
13683 PyObject * obj0 = 0 ;
13684 char * kwnames[] = {
13685 (char *) "msg", NULL
13686 };
13687
13688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13689 {
13690 arg1 = wxString_in_helper(obj0);
13691 if (arg1 == NULL) SWIG_fail;
13692 temp1 = true;
13693 }
13694 {
13695 PyThreadState* __tstate = wxPyBeginAllowThreads();
13696 wxPyLogInfo((wxString const &)*arg1);
13697 wxPyEndAllowThreads(__tstate);
13698 if (PyErr_Occurred()) SWIG_fail;
13699 }
13700 resultobj = SWIG_Py_Void();
13701 {
13702 if (temp1)
13703 delete arg1;
13704 }
13705 return resultobj;
13706 fail:
13707 {
13708 if (temp1)
13709 delete arg1;
13710 }
13711 return NULL;
13712 }
13713
13714
13715 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj = 0;
13717 wxString *arg1 = 0 ;
13718 bool temp1 = false ;
13719 PyObject * obj0 = 0 ;
13720 char * kwnames[] = {
13721 (char *) "msg", NULL
13722 };
13723
13724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13725 {
13726 arg1 = wxString_in_helper(obj0);
13727 if (arg1 == NULL) SWIG_fail;
13728 temp1 = true;
13729 }
13730 {
13731 PyThreadState* __tstate = wxPyBeginAllowThreads();
13732 wxPyLogDebug((wxString const &)*arg1);
13733 wxPyEndAllowThreads(__tstate);
13734 if (PyErr_Occurred()) SWIG_fail;
13735 }
13736 resultobj = SWIG_Py_Void();
13737 {
13738 if (temp1)
13739 delete arg1;
13740 }
13741 return resultobj;
13742 fail:
13743 {
13744 if (temp1)
13745 delete arg1;
13746 }
13747 return NULL;
13748 }
13749
13750
13751 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13752 PyObject *resultobj = 0;
13753 wxString *arg1 = 0 ;
13754 bool temp1 = false ;
13755 PyObject * obj0 = 0 ;
13756 char * kwnames[] = {
13757 (char *) "msg", NULL
13758 };
13759
13760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13761 {
13762 arg1 = wxString_in_helper(obj0);
13763 if (arg1 == NULL) SWIG_fail;
13764 temp1 = true;
13765 }
13766 {
13767 PyThreadState* __tstate = wxPyBeginAllowThreads();
13768 wxPyLogVerbose((wxString const &)*arg1);
13769 wxPyEndAllowThreads(__tstate);
13770 if (PyErr_Occurred()) SWIG_fail;
13771 }
13772 resultobj = SWIG_Py_Void();
13773 {
13774 if (temp1)
13775 delete arg1;
13776 }
13777 return resultobj;
13778 fail:
13779 {
13780 if (temp1)
13781 delete arg1;
13782 }
13783 return NULL;
13784 }
13785
13786
13787 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13788 PyObject *resultobj = 0;
13789 wxString *arg1 = 0 ;
13790 bool temp1 = false ;
13791 PyObject * obj0 = 0 ;
13792 char * kwnames[] = {
13793 (char *) "msg", NULL
13794 };
13795
13796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13797 {
13798 arg1 = wxString_in_helper(obj0);
13799 if (arg1 == NULL) SWIG_fail;
13800 temp1 = true;
13801 }
13802 {
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 wxPyLogStatus((wxString const &)*arg1);
13805 wxPyEndAllowThreads(__tstate);
13806 if (PyErr_Occurred()) SWIG_fail;
13807 }
13808 resultobj = SWIG_Py_Void();
13809 {
13810 if (temp1)
13811 delete arg1;
13812 }
13813 return resultobj;
13814 fail:
13815 {
13816 if (temp1)
13817 delete arg1;
13818 }
13819 return NULL;
13820 }
13821
13822
13823 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13824 PyObject *resultobj = 0;
13825 wxFrame *arg1 = (wxFrame *) 0 ;
13826 wxString *arg2 = 0 ;
13827 void *argp1 = 0 ;
13828 int res1 = 0 ;
13829 bool temp2 = false ;
13830 PyObject * obj0 = 0 ;
13831 PyObject * obj1 = 0 ;
13832 char * kwnames[] = {
13833 (char *) "pFrame",(char *) "msg", NULL
13834 };
13835
13836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13838 if (!SWIG_IsOK(res1)) {
13839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13840 }
13841 arg1 = reinterpret_cast< wxFrame * >(argp1);
13842 {
13843 arg2 = wxString_in_helper(obj1);
13844 if (arg2 == NULL) SWIG_fail;
13845 temp2 = true;
13846 }
13847 {
13848 PyThreadState* __tstate = wxPyBeginAllowThreads();
13849 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13850 wxPyEndAllowThreads(__tstate);
13851 if (PyErr_Occurred()) SWIG_fail;
13852 }
13853 resultobj = SWIG_Py_Void();
13854 {
13855 if (temp2)
13856 delete arg2;
13857 }
13858 return resultobj;
13859 fail:
13860 {
13861 if (temp2)
13862 delete arg2;
13863 }
13864 return NULL;
13865 }
13866
13867
13868 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13869 PyObject *resultobj = 0;
13870 wxString *arg1 = 0 ;
13871 bool temp1 = false ;
13872 PyObject * obj0 = 0 ;
13873 char * kwnames[] = {
13874 (char *) "msg", NULL
13875 };
13876
13877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13878 {
13879 arg1 = wxString_in_helper(obj0);
13880 if (arg1 == NULL) SWIG_fail;
13881 temp1 = true;
13882 }
13883 {
13884 PyThreadState* __tstate = wxPyBeginAllowThreads();
13885 wxPyLogSysError((wxString const &)*arg1);
13886 wxPyEndAllowThreads(__tstate);
13887 if (PyErr_Occurred()) SWIG_fail;
13888 }
13889 resultobj = SWIG_Py_Void();
13890 {
13891 if (temp1)
13892 delete arg1;
13893 }
13894 return resultobj;
13895 fail:
13896 {
13897 if (temp1)
13898 delete arg1;
13899 }
13900 return NULL;
13901 }
13902
13903
13904 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13905 PyObject *resultobj = 0;
13906 unsigned long arg1 ;
13907 wxString *arg2 = 0 ;
13908 unsigned long val1 ;
13909 int ecode1 = 0 ;
13910 bool temp2 = false ;
13911 PyObject * obj0 = 0 ;
13912 PyObject * obj1 = 0 ;
13913 char * kwnames[] = {
13914 (char *) "level",(char *) "msg", NULL
13915 };
13916
13917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13918 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13919 if (!SWIG_IsOK(ecode1)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13921 }
13922 arg1 = static_cast< unsigned long >(val1);
13923 {
13924 arg2 = wxString_in_helper(obj1);
13925 if (arg2 == NULL) SWIG_fail;
13926 temp2 = true;
13927 }
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13931 wxPyEndAllowThreads(__tstate);
13932 if (PyErr_Occurred()) SWIG_fail;
13933 }
13934 resultobj = SWIG_Py_Void();
13935 {
13936 if (temp2)
13937 delete arg2;
13938 }
13939 return resultobj;
13940 fail:
13941 {
13942 if (temp2)
13943 delete arg2;
13944 }
13945 return NULL;
13946 }
13947
13948
13949 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13950 PyObject *resultobj = 0;
13951 unsigned long arg1 ;
13952 wxString *arg2 = 0 ;
13953 unsigned long val1 ;
13954 int ecode1 = 0 ;
13955 bool temp2 = false ;
13956
13957 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13958 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13959 if (!SWIG_IsOK(ecode1)) {
13960 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13961 }
13962 arg1 = static_cast< unsigned long >(val1);
13963 {
13964 arg2 = wxString_in_helper(swig_obj[1]);
13965 if (arg2 == NULL) SWIG_fail;
13966 temp2 = true;
13967 }
13968 {
13969 PyThreadState* __tstate = wxPyBeginAllowThreads();
13970 wxPyLogTrace(arg1,(wxString const &)*arg2);
13971 wxPyEndAllowThreads(__tstate);
13972 if (PyErr_Occurred()) SWIG_fail;
13973 }
13974 resultobj = SWIG_Py_Void();
13975 {
13976 if (temp2)
13977 delete arg2;
13978 }
13979 return resultobj;
13980 fail:
13981 {
13982 if (temp2)
13983 delete arg2;
13984 }
13985 return NULL;
13986 }
13987
13988
13989 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13990 PyObject *resultobj = 0;
13991 wxString *arg1 = 0 ;
13992 wxString *arg2 = 0 ;
13993 bool temp1 = false ;
13994 bool temp2 = false ;
13995
13996 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13997 {
13998 arg1 = wxString_in_helper(swig_obj[0]);
13999 if (arg1 == NULL) SWIG_fail;
14000 temp1 = true;
14001 }
14002 {
14003 arg2 = wxString_in_helper(swig_obj[1]);
14004 if (arg2 == NULL) SWIG_fail;
14005 temp2 = true;
14006 }
14007 {
14008 PyThreadState* __tstate = wxPyBeginAllowThreads();
14009 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14010 wxPyEndAllowThreads(__tstate);
14011 if (PyErr_Occurred()) SWIG_fail;
14012 }
14013 resultobj = SWIG_Py_Void();
14014 {
14015 if (temp1)
14016 delete arg1;
14017 }
14018 {
14019 if (temp2)
14020 delete arg2;
14021 }
14022 return resultobj;
14023 fail:
14024 {
14025 if (temp1)
14026 delete arg1;
14027 }
14028 {
14029 if (temp2)
14030 delete arg2;
14031 }
14032 return NULL;
14033 }
14034
14035
14036 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14037 int argc;
14038 PyObject *argv[3];
14039
14040 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14041 --argc;
14042 if (argc == 2) {
14043 int _v = 0;
14044 {
14045 {
14046 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14047 }
14048 }
14049 if (!_v) goto check_1;
14050 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14051 }
14052 check_1:
14053
14054 if (argc == 2) {
14055 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14056 }
14057
14058 fail:
14059 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14060 return NULL;
14061 }
14062
14063
14064 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14065 PyObject *resultobj = 0;
14066 wxString *arg1 = 0 ;
14067 wxString *arg2 = 0 ;
14068 bool temp1 = false ;
14069 bool temp2 = false ;
14070 PyObject * obj0 = 0 ;
14071 PyObject * obj1 = 0 ;
14072 char * kwnames[] = {
14073 (char *) "title",(char *) "text", NULL
14074 };
14075
14076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14077 {
14078 arg1 = wxString_in_helper(obj0);
14079 if (arg1 == NULL) SWIG_fail;
14080 temp1 = true;
14081 }
14082 {
14083 arg2 = wxString_in_helper(obj1);
14084 if (arg2 == NULL) SWIG_fail;
14085 temp2 = true;
14086 }
14087 {
14088 PyThreadState* __tstate = wxPyBeginAllowThreads();
14089 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 resultobj = SWIG_Py_Void();
14094 {
14095 if (temp1)
14096 delete arg1;
14097 }
14098 {
14099 if (temp2)
14100 delete arg2;
14101 }
14102 return resultobj;
14103 fail:
14104 {
14105 if (temp1)
14106 delete arg1;
14107 }
14108 {
14109 if (temp2)
14110 delete arg2;
14111 }
14112 return NULL;
14113 }
14114
14115
14116 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14117 PyObject *resultobj = 0;
14118 wxLogNull *result = 0 ;
14119
14120 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14121 {
14122 PyThreadState* __tstate = wxPyBeginAllowThreads();
14123 result = (wxLogNull *)new wxLogNull();
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14135 PyObject *resultobj = 0;
14136 wxLogNull *arg1 = (wxLogNull *) 0 ;
14137 void *argp1 = 0 ;
14138 int res1 = 0 ;
14139 PyObject *swig_obj[1] ;
14140
14141 if (!args) SWIG_fail;
14142 swig_obj[0] = args;
14143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14144 if (!SWIG_IsOK(res1)) {
14145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14146 }
14147 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14148 {
14149 PyThreadState* __tstate = wxPyBeginAllowThreads();
14150 delete arg1;
14151
14152 wxPyEndAllowThreads(__tstate);
14153 if (PyErr_Occurred()) SWIG_fail;
14154 }
14155 resultobj = SWIG_Py_Void();
14156 return resultobj;
14157 fail:
14158 return NULL;
14159 }
14160
14161
14162 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14163 PyObject *obj;
14164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14165 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14166 return SWIG_Py_Void();
14167 }
14168
14169 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14170 return SWIG_Python_InitShadowInstance(args);
14171 }
14172
14173 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14174 PyObject *resultobj = 0;
14175 wxPyLog *result = 0 ;
14176
14177 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14178 {
14179 PyThreadState* __tstate = wxPyBeginAllowThreads();
14180 result = (wxPyLog *)new wxPyLog();
14181 wxPyEndAllowThreads(__tstate);
14182 if (PyErr_Occurred()) SWIG_fail;
14183 }
14184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14185 return resultobj;
14186 fail:
14187 return NULL;
14188 }
14189
14190
14191 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14192 PyObject *resultobj = 0;
14193 wxPyLog *arg1 = (wxPyLog *) 0 ;
14194 PyObject *arg2 = (PyObject *) 0 ;
14195 PyObject *arg3 = (PyObject *) 0 ;
14196 void *argp1 = 0 ;
14197 int res1 = 0 ;
14198 PyObject * obj0 = 0 ;
14199 PyObject * obj1 = 0 ;
14200 PyObject * obj2 = 0 ;
14201 char * kwnames[] = {
14202 (char *) "self",(char *) "self",(char *) "_class", NULL
14203 };
14204
14205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14207 if (!SWIG_IsOK(res1)) {
14208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14209 }
14210 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14211 arg2 = obj1;
14212 arg3 = obj2;
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 (arg1)->_setCallbackInfo(arg2,arg3);
14216 wxPyEndAllowThreads(__tstate);
14217 if (PyErr_Occurred()) SWIG_fail;
14218 }
14219 resultobj = SWIG_Py_Void();
14220 return resultobj;
14221 fail:
14222 return NULL;
14223 }
14224
14225
14226 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14227 PyObject *obj;
14228 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14229 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14230 return SWIG_Py_Void();
14231 }
14232
14233 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14234 return SWIG_Python_InitShadowInstance(args);
14235 }
14236
14237 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj = 0;
14239 int arg1 ;
14240 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14241 int arg3 = (int) wxKILL_NOCHILDREN ;
14242 wxKillError result;
14243 int val1 ;
14244 int ecode1 = 0 ;
14245 int val2 ;
14246 int ecode2 = 0 ;
14247 int val3 ;
14248 int ecode3 = 0 ;
14249 PyObject * obj0 = 0 ;
14250 PyObject * obj1 = 0 ;
14251 PyObject * obj2 = 0 ;
14252 char * kwnames[] = {
14253 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14254 };
14255
14256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14257 ecode1 = SWIG_AsVal_int(obj0, &val1);
14258 if (!SWIG_IsOK(ecode1)) {
14259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14260 }
14261 arg1 = static_cast< int >(val1);
14262 if (obj1) {
14263 ecode2 = SWIG_AsVal_int(obj1, &val2);
14264 if (!SWIG_IsOK(ecode2)) {
14265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14266 }
14267 arg2 = static_cast< wxSignal >(val2);
14268 }
14269 if (obj2) {
14270 ecode3 = SWIG_AsVal_int(obj2, &val3);
14271 if (!SWIG_IsOK(ecode3)) {
14272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14273 }
14274 arg3 = static_cast< int >(val3);
14275 }
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 resultobj = SWIG_From_int(static_cast< int >(result));
14283 return resultobj;
14284 fail:
14285 return NULL;
14286 }
14287
14288
14289 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14290 PyObject *resultobj = 0;
14291 int arg1 ;
14292 bool result;
14293 int val1 ;
14294 int ecode1 = 0 ;
14295 PyObject * obj0 = 0 ;
14296 char * kwnames[] = {
14297 (char *) "pid", NULL
14298 };
14299
14300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14301 ecode1 = SWIG_AsVal_int(obj0, &val1);
14302 if (!SWIG_IsOK(ecode1)) {
14303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14304 }
14305 arg1 = static_cast< int >(val1);
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 result = (bool)wxPyProcess::Exists(arg1);
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 {
14313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14314 }
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj = 0;
14323 wxString *arg1 = 0 ;
14324 int arg2 = (int) wxEXEC_ASYNC ;
14325 wxPyProcess *result = 0 ;
14326 bool temp1 = false ;
14327 int val2 ;
14328 int ecode2 = 0 ;
14329 PyObject * obj0 = 0 ;
14330 PyObject * obj1 = 0 ;
14331 char * kwnames[] = {
14332 (char *) "cmd",(char *) "flags", NULL
14333 };
14334
14335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14336 {
14337 arg1 = wxString_in_helper(obj0);
14338 if (arg1 == NULL) SWIG_fail;
14339 temp1 = true;
14340 }
14341 if (obj1) {
14342 ecode2 = SWIG_AsVal_int(obj1, &val2);
14343 if (!SWIG_IsOK(ecode2)) {
14344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14345 }
14346 arg2 = static_cast< int >(val2);
14347 }
14348 {
14349 PyThreadState* __tstate = wxPyBeginAllowThreads();
14350 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14351 wxPyEndAllowThreads(__tstate);
14352 if (PyErr_Occurred()) SWIG_fail;
14353 }
14354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14355 {
14356 if (temp1)
14357 delete arg1;
14358 }
14359 return resultobj;
14360 fail:
14361 {
14362 if (temp1)
14363 delete arg1;
14364 }
14365 return NULL;
14366 }
14367
14368
14369 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14370 PyObject *resultobj = 0;
14371 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14372 int arg2 = (int) -1 ;
14373 wxPyProcess *result = 0 ;
14374 void *argp1 = 0 ;
14375 int res1 = 0 ;
14376 int val2 ;
14377 int ecode2 = 0 ;
14378 PyObject * obj0 = 0 ;
14379 PyObject * obj1 = 0 ;
14380 char * kwnames[] = {
14381 (char *) "parent",(char *) "id", NULL
14382 };
14383
14384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14385 if (obj0) {
14386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14387 if (!SWIG_IsOK(res1)) {
14388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14389 }
14390 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14391 }
14392 if (obj1) {
14393 ecode2 = SWIG_AsVal_int(obj1, &val2);
14394 if (!SWIG_IsOK(ecode2)) {
14395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14396 }
14397 arg2 = static_cast< int >(val2);
14398 }
14399 {
14400 PyThreadState* __tstate = wxPyBeginAllowThreads();
14401 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14402 wxPyEndAllowThreads(__tstate);
14403 if (PyErr_Occurred()) SWIG_fail;
14404 }
14405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14406 return resultobj;
14407 fail:
14408 return NULL;
14409 }
14410
14411
14412 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14413 PyObject *resultobj = 0;
14414 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14415 void *argp1 = 0 ;
14416 int res1 = 0 ;
14417 PyObject *swig_obj[1] ;
14418
14419 if (!args) SWIG_fail;
14420 swig_obj[0] = args;
14421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14422 if (!SWIG_IsOK(res1)) {
14423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14424 }
14425 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 delete arg1;
14429
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 resultobj = SWIG_Py_Void();
14434 return resultobj;
14435 fail:
14436 return NULL;
14437 }
14438
14439
14440 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14441 PyObject *resultobj = 0;
14442 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14443 PyObject *arg2 = (PyObject *) 0 ;
14444 PyObject *arg3 = (PyObject *) 0 ;
14445 void *argp1 = 0 ;
14446 int res1 = 0 ;
14447 PyObject * obj0 = 0 ;
14448 PyObject * obj1 = 0 ;
14449 PyObject * obj2 = 0 ;
14450 char * kwnames[] = {
14451 (char *) "self",(char *) "self",(char *) "_class", NULL
14452 };
14453
14454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14456 if (!SWIG_IsOK(res1)) {
14457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14458 }
14459 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14460 arg2 = obj1;
14461 arg3 = obj2;
14462 {
14463 PyThreadState* __tstate = wxPyBeginAllowThreads();
14464 (arg1)->_setCallbackInfo(arg2,arg3);
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 resultobj = SWIG_Py_Void();
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14476 PyObject *resultobj = 0;
14477 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14478 long result;
14479 void *argp1 = 0 ;
14480 int res1 = 0 ;
14481 PyObject *swig_obj[1] ;
14482
14483 if (!args) SWIG_fail;
14484 swig_obj[0] = args;
14485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14486 if (!SWIG_IsOK(res1)) {
14487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14488 }
14489 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14490 {
14491 PyThreadState* __tstate = wxPyBeginAllowThreads();
14492 result = (long)((wxPyProcess const *)arg1)->GetPid();
14493 wxPyEndAllowThreads(__tstate);
14494 if (PyErr_Occurred()) SWIG_fail;
14495 }
14496 resultobj = SWIG_From_long(static_cast< long >(result));
14497 return resultobj;
14498 fail:
14499 return NULL;
14500 }
14501
14502
14503 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14504 PyObject *resultobj = 0;
14505 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14506 int arg2 ;
14507 int arg3 ;
14508 void *argp1 = 0 ;
14509 int res1 = 0 ;
14510 int val2 ;
14511 int ecode2 = 0 ;
14512 int val3 ;
14513 int ecode3 = 0 ;
14514 PyObject * obj0 = 0 ;
14515 PyObject * obj1 = 0 ;
14516 PyObject * obj2 = 0 ;
14517 char * kwnames[] = {
14518 (char *) "self",(char *) "pid",(char *) "status", NULL
14519 };
14520
14521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14523 if (!SWIG_IsOK(res1)) {
14524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14525 }
14526 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14527 ecode2 = SWIG_AsVal_int(obj1, &val2);
14528 if (!SWIG_IsOK(ecode2)) {
14529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14530 }
14531 arg2 = static_cast< int >(val2);
14532 ecode3 = SWIG_AsVal_int(obj2, &val3);
14533 if (!SWIG_IsOK(ecode3)) {
14534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14535 }
14536 arg3 = static_cast< int >(val3);
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 (arg1)->OnTerminate(arg2,arg3);
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = SWIG_Py_Void();
14544 return resultobj;
14545 fail:
14546 return NULL;
14547 }
14548
14549
14550 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14551 PyObject *resultobj = 0;
14552 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14553 void *argp1 = 0 ;
14554 int res1 = 0 ;
14555 PyObject *swig_obj[1] ;
14556
14557 if (!args) SWIG_fail;
14558 swig_obj[0] = args;
14559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14560 if (!SWIG_IsOK(res1)) {
14561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14562 }
14563 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14564 {
14565 PyThreadState* __tstate = wxPyBeginAllowThreads();
14566 (arg1)->Redirect();
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 resultobj = SWIG_Py_Void();
14571 return resultobj;
14572 fail:
14573 return NULL;
14574 }
14575
14576
14577 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14578 PyObject *resultobj = 0;
14579 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14580 bool result;
14581 void *argp1 = 0 ;
14582 int res1 = 0 ;
14583 PyObject *swig_obj[1] ;
14584
14585 if (!args) SWIG_fail;
14586 swig_obj[0] = args;
14587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14588 if (!SWIG_IsOK(res1)) {
14589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14590 }
14591 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14592 {
14593 PyThreadState* __tstate = wxPyBeginAllowThreads();
14594 result = (bool)(arg1)->IsRedirected();
14595 wxPyEndAllowThreads(__tstate);
14596 if (PyErr_Occurred()) SWIG_fail;
14597 }
14598 {
14599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14600 }
14601 return resultobj;
14602 fail:
14603 return NULL;
14604 }
14605
14606
14607 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14608 PyObject *resultobj = 0;
14609 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14610 void *argp1 = 0 ;
14611 int res1 = 0 ;
14612 PyObject *swig_obj[1] ;
14613
14614 if (!args) SWIG_fail;
14615 swig_obj[0] = args;
14616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14617 if (!SWIG_IsOK(res1)) {
14618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14619 }
14620 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14621 {
14622 PyThreadState* __tstate = wxPyBeginAllowThreads();
14623 (arg1)->Detach();
14624 wxPyEndAllowThreads(__tstate);
14625 if (PyErr_Occurred()) SWIG_fail;
14626 }
14627 resultobj = SWIG_Py_Void();
14628 return resultobj;
14629 fail:
14630 return NULL;
14631 }
14632
14633
14634 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14635 PyObject *resultobj = 0;
14636 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14637 wxInputStream *result = 0 ;
14638 void *argp1 = 0 ;
14639 int res1 = 0 ;
14640 PyObject *swig_obj[1] ;
14641
14642 if (!args) SWIG_fail;
14643 swig_obj[0] = args;
14644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14645 if (!SWIG_IsOK(res1)) {
14646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14647 }
14648 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14649 {
14650 PyThreadState* __tstate = wxPyBeginAllowThreads();
14651 result = (wxInputStream *)(arg1)->GetInputStream();
14652 wxPyEndAllowThreads(__tstate);
14653 if (PyErr_Occurred()) SWIG_fail;
14654 }
14655 {
14656 wxPyInputStream * _ptr = NULL;
14657
14658 if (result) {
14659 _ptr = new wxPyInputStream(result);
14660 }
14661 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14662 }
14663 return resultobj;
14664 fail:
14665 return NULL;
14666 }
14667
14668
14669 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14670 PyObject *resultobj = 0;
14671 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14672 wxInputStream *result = 0 ;
14673 void *argp1 = 0 ;
14674 int res1 = 0 ;
14675 PyObject *swig_obj[1] ;
14676
14677 if (!args) SWIG_fail;
14678 swig_obj[0] = args;
14679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14680 if (!SWIG_IsOK(res1)) {
14681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14682 }
14683 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14684 {
14685 PyThreadState* __tstate = wxPyBeginAllowThreads();
14686 result = (wxInputStream *)(arg1)->GetErrorStream();
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 {
14691 wxPyInputStream * _ptr = NULL;
14692
14693 if (result) {
14694 _ptr = new wxPyInputStream(result);
14695 }
14696 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14697 }
14698 return resultobj;
14699 fail:
14700 return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14705 PyObject *resultobj = 0;
14706 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14707 wxOutputStream *result = 0 ;
14708 void *argp1 = 0 ;
14709 int res1 = 0 ;
14710 PyObject *swig_obj[1] ;
14711
14712 if (!args) SWIG_fail;
14713 swig_obj[0] = args;
14714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14715 if (!SWIG_IsOK(res1)) {
14716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14717 }
14718 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (wxOutputStream *)(arg1)->GetOutputStream();
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14735 void *argp1 = 0 ;
14736 int res1 = 0 ;
14737 PyObject *swig_obj[1] ;
14738
14739 if (!args) SWIG_fail;
14740 swig_obj[0] = args;
14741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14742 if (!SWIG_IsOK(res1)) {
14743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14744 }
14745 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 (arg1)->CloseOutput();
14749 wxPyEndAllowThreads(__tstate);
14750 if (PyErr_Occurred()) SWIG_fail;
14751 }
14752 resultobj = SWIG_Py_Void();
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14760 PyObject *resultobj = 0;
14761 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14762 bool result;
14763 void *argp1 = 0 ;
14764 int res1 = 0 ;
14765 PyObject *swig_obj[1] ;
14766
14767 if (!args) SWIG_fail;
14768 swig_obj[0] = args;
14769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14770 if (!SWIG_IsOK(res1)) {
14771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14772 }
14773 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 {
14781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14782 }
14783 return resultobj;
14784 fail:
14785 return NULL;
14786 }
14787
14788
14789 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14790 PyObject *resultobj = 0;
14791 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14792 bool result;
14793 void *argp1 = 0 ;
14794 int res1 = 0 ;
14795 PyObject *swig_obj[1] ;
14796
14797 if (!args) SWIG_fail;
14798 swig_obj[0] = args;
14799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14800 if (!SWIG_IsOK(res1)) {
14801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14802 }
14803 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14804 {
14805 PyThreadState* __tstate = wxPyBeginAllowThreads();
14806 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 {
14811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14812 }
14813 return resultobj;
14814 fail:
14815 return NULL;
14816 }
14817
14818
14819 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14820 PyObject *resultobj = 0;
14821 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14822 bool result;
14823 void *argp1 = 0 ;
14824 int res1 = 0 ;
14825 PyObject *swig_obj[1] ;
14826
14827 if (!args) SWIG_fail;
14828 swig_obj[0] = args;
14829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14830 if (!SWIG_IsOK(res1)) {
14831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14832 }
14833 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14834 {
14835 PyThreadState* __tstate = wxPyBeginAllowThreads();
14836 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14837 wxPyEndAllowThreads(__tstate);
14838 if (PyErr_Occurred()) SWIG_fail;
14839 }
14840 {
14841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14842 }
14843 return resultobj;
14844 fail:
14845 return NULL;
14846 }
14847
14848
14849 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14850 PyObject *obj;
14851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14852 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14853 return SWIG_Py_Void();
14854 }
14855
14856 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14857 return SWIG_Python_InitShadowInstance(args);
14858 }
14859
14860 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj = 0;
14862 int arg1 = (int) 0 ;
14863 int arg2 = (int) 0 ;
14864 int arg3 = (int) 0 ;
14865 wxProcessEvent *result = 0 ;
14866 int val1 ;
14867 int ecode1 = 0 ;
14868 int val2 ;
14869 int ecode2 = 0 ;
14870 int val3 ;
14871 int ecode3 = 0 ;
14872 PyObject * obj0 = 0 ;
14873 PyObject * obj1 = 0 ;
14874 PyObject * obj2 = 0 ;
14875 char * kwnames[] = {
14876 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14877 };
14878
14879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14880 if (obj0) {
14881 ecode1 = SWIG_AsVal_int(obj0, &val1);
14882 if (!SWIG_IsOK(ecode1)) {
14883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14884 }
14885 arg1 = static_cast< int >(val1);
14886 }
14887 if (obj1) {
14888 ecode2 = SWIG_AsVal_int(obj1, &val2);
14889 if (!SWIG_IsOK(ecode2)) {
14890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14891 }
14892 arg2 = static_cast< int >(val2);
14893 }
14894 if (obj2) {
14895 ecode3 = SWIG_AsVal_int(obj2, &val3);
14896 if (!SWIG_IsOK(ecode3)) {
14897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14898 }
14899 arg3 = static_cast< int >(val3);
14900 }
14901 {
14902 PyThreadState* __tstate = wxPyBeginAllowThreads();
14903 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14904 wxPyEndAllowThreads(__tstate);
14905 if (PyErr_Occurred()) SWIG_fail;
14906 }
14907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14908 return resultobj;
14909 fail:
14910 return NULL;
14911 }
14912
14913
14914 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14915 PyObject *resultobj = 0;
14916 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14917 int result;
14918 void *argp1 = 0 ;
14919 int res1 = 0 ;
14920 PyObject *swig_obj[1] ;
14921
14922 if (!args) SWIG_fail;
14923 swig_obj[0] = args;
14924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14925 if (!SWIG_IsOK(res1)) {
14926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14927 }
14928 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14929 {
14930 PyThreadState* __tstate = wxPyBeginAllowThreads();
14931 result = (int)(arg1)->GetPid();
14932 wxPyEndAllowThreads(__tstate);
14933 if (PyErr_Occurred()) SWIG_fail;
14934 }
14935 resultobj = SWIG_From_int(static_cast< int >(result));
14936 return resultobj;
14937 fail:
14938 return NULL;
14939 }
14940
14941
14942 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14943 PyObject *resultobj = 0;
14944 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14945 int result;
14946 void *argp1 = 0 ;
14947 int res1 = 0 ;
14948 PyObject *swig_obj[1] ;
14949
14950 if (!args) SWIG_fail;
14951 swig_obj[0] = args;
14952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14953 if (!SWIG_IsOK(res1)) {
14954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14955 }
14956 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 result = (int)(arg1)->GetExitCode();
14960 wxPyEndAllowThreads(__tstate);
14961 if (PyErr_Occurred()) SWIG_fail;
14962 }
14963 resultobj = SWIG_From_int(static_cast< int >(result));
14964 return resultobj;
14965 fail:
14966 return NULL;
14967 }
14968
14969
14970 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14971 PyObject *resultobj = 0;
14972 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14973 int arg2 ;
14974 void *argp1 = 0 ;
14975 int res1 = 0 ;
14976 int val2 ;
14977 int ecode2 = 0 ;
14978 PyObject *swig_obj[2] ;
14979
14980 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14982 if (!SWIG_IsOK(res1)) {
14983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14984 }
14985 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14986 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14987 if (!SWIG_IsOK(ecode2)) {
14988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14989 }
14990 arg2 = static_cast< int >(val2);
14991 if (arg1) (arg1)->m_pid = arg2;
14992
14993 resultobj = SWIG_Py_Void();
14994 return resultobj;
14995 fail:
14996 return NULL;
14997 }
14998
14999
15000 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15001 PyObject *resultobj = 0;
15002 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15003 int result;
15004 void *argp1 = 0 ;
15005 int res1 = 0 ;
15006 PyObject *swig_obj[1] ;
15007
15008 if (!args) SWIG_fail;
15009 swig_obj[0] = args;
15010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15011 if (!SWIG_IsOK(res1)) {
15012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15013 }
15014 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15015 result = (int) ((arg1)->m_pid);
15016 resultobj = SWIG_From_int(static_cast< int >(result));
15017 return resultobj;
15018 fail:
15019 return NULL;
15020 }
15021
15022
15023 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15024 PyObject *resultobj = 0;
15025 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15026 int arg2 ;
15027 void *argp1 = 0 ;
15028 int res1 = 0 ;
15029 int val2 ;
15030 int ecode2 = 0 ;
15031 PyObject *swig_obj[2] ;
15032
15033 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15035 if (!SWIG_IsOK(res1)) {
15036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15037 }
15038 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15039 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15040 if (!SWIG_IsOK(ecode2)) {
15041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15042 }
15043 arg2 = static_cast< int >(val2);
15044 if (arg1) (arg1)->m_exitcode = arg2;
15045
15046 resultobj = SWIG_Py_Void();
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15054 PyObject *resultobj = 0;
15055 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15056 int result;
15057 void *argp1 = 0 ;
15058 int res1 = 0 ;
15059 PyObject *swig_obj[1] ;
15060
15061 if (!args) SWIG_fail;
15062 swig_obj[0] = args;
15063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15064 if (!SWIG_IsOK(res1)) {
15065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15066 }
15067 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15068 result = (int) ((arg1)->m_exitcode);
15069 resultobj = SWIG_From_int(static_cast< int >(result));
15070 return resultobj;
15071 fail:
15072 return NULL;
15073 }
15074
15075
15076 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15077 PyObject *obj;
15078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15079 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15080 return SWIG_Py_Void();
15081 }
15082
15083 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15084 return SWIG_Python_InitShadowInstance(args);
15085 }
15086
15087 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15088 PyObject *resultobj = 0;
15089 wxString *arg1 = 0 ;
15090 int arg2 = (int) wxEXEC_ASYNC ;
15091 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15092 long result;
15093 bool temp1 = false ;
15094 int val2 ;
15095 int ecode2 = 0 ;
15096 void *argp3 = 0 ;
15097 int res3 = 0 ;
15098 PyObject * obj0 = 0 ;
15099 PyObject * obj1 = 0 ;
15100 PyObject * obj2 = 0 ;
15101 char * kwnames[] = {
15102 (char *) "command",(char *) "flags",(char *) "process", NULL
15103 };
15104
15105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15106 {
15107 arg1 = wxString_in_helper(obj0);
15108 if (arg1 == NULL) SWIG_fail;
15109 temp1 = true;
15110 }
15111 if (obj1) {
15112 ecode2 = SWIG_AsVal_int(obj1, &val2);
15113 if (!SWIG_IsOK(ecode2)) {
15114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15115 }
15116 arg2 = static_cast< int >(val2);
15117 }
15118 if (obj2) {
15119 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15120 if (!SWIG_IsOK(res3)) {
15121 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15122 }
15123 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15124 }
15125 {
15126 if (!wxPyCheckForApp()) SWIG_fail;
15127 PyThreadState* __tstate = wxPyBeginAllowThreads();
15128 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15129 wxPyEndAllowThreads(__tstate);
15130 if (PyErr_Occurred()) SWIG_fail;
15131 }
15132 resultobj = SWIG_From_long(static_cast< long >(result));
15133 {
15134 if (temp1)
15135 delete arg1;
15136 }
15137 return resultobj;
15138 fail:
15139 {
15140 if (temp1)
15141 delete arg1;
15142 }
15143 return NULL;
15144 }
15145
15146
15147 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15148 PyObject *resultobj = 0;
15149 long arg1 ;
15150 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15151 wxKillError *arg3 = (wxKillError *) 0 ;
15152 int arg4 = (int) wxKILL_NOCHILDREN ;
15153 int result;
15154 long val1 ;
15155 int ecode1 = 0 ;
15156 int val2 ;
15157 int ecode2 = 0 ;
15158 wxKillError temp3 ;
15159 int val4 ;
15160 int ecode4 = 0 ;
15161 PyObject * obj0 = 0 ;
15162 PyObject * obj1 = 0 ;
15163 PyObject * obj2 = 0 ;
15164 char * kwnames[] = {
15165 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15166 };
15167
15168 {
15169 arg3 = &temp3;
15170 }
15171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15172 ecode1 = SWIG_AsVal_long(obj0, &val1);
15173 if (!SWIG_IsOK(ecode1)) {
15174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15175 }
15176 arg1 = static_cast< long >(val1);
15177 if (obj1) {
15178 ecode2 = SWIG_AsVal_int(obj1, &val2);
15179 if (!SWIG_IsOK(ecode2)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15181 }
15182 arg2 = static_cast< wxSignal >(val2);
15183 }
15184 if (obj2) {
15185 ecode4 = SWIG_AsVal_int(obj2, &val4);
15186 if (!SWIG_IsOK(ecode4)) {
15187 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15188 }
15189 arg4 = static_cast< int >(val4);
15190 }
15191 {
15192 PyThreadState* __tstate = wxPyBeginAllowThreads();
15193 result = (int)wxKill(arg1,arg2,arg3,arg4);
15194 wxPyEndAllowThreads(__tstate);
15195 if (PyErr_Occurred()) SWIG_fail;
15196 }
15197 resultobj = SWIG_From_int(static_cast< int >(result));
15198 {
15199 PyObject* o;
15200 o = PyInt_FromLong((long) (*arg3));
15201
15202
15203
15204 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15205
15206 }
15207 return resultobj;
15208 fail:
15209 return NULL;
15210 }
15211
15212
15213 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15214 PyObject *resultobj = 0;
15215 int arg1 = (int) wxJOYSTICK1 ;
15216 wxJoystick *result = 0 ;
15217 int val1 ;
15218 int ecode1 = 0 ;
15219 PyObject * obj0 = 0 ;
15220 char * kwnames[] = {
15221 (char *) "joystick", NULL
15222 };
15223
15224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15225 if (obj0) {
15226 ecode1 = SWIG_AsVal_int(obj0, &val1);
15227 if (!SWIG_IsOK(ecode1)) {
15228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15229 }
15230 arg1 = static_cast< int >(val1);
15231 }
15232 {
15233 if (!wxPyCheckForApp()) SWIG_fail;
15234 PyThreadState* __tstate = wxPyBeginAllowThreads();
15235 result = (wxJoystick *)new wxJoystick(arg1);
15236 wxPyEndAllowThreads(__tstate);
15237 if (PyErr_Occurred()) SWIG_fail;
15238 }
15239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15240 return resultobj;
15241 fail:
15242 return NULL;
15243 }
15244
15245
15246 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15247 PyObject *resultobj = 0;
15248 wxJoystick *arg1 = (wxJoystick *) 0 ;
15249 void *argp1 = 0 ;
15250 int res1 = 0 ;
15251 PyObject *swig_obj[1] ;
15252
15253 if (!args) SWIG_fail;
15254 swig_obj[0] = args;
15255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15256 if (!SWIG_IsOK(res1)) {
15257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15258 }
15259 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 delete arg1;
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 resultobj = SWIG_Py_Void();
15268 return resultobj;
15269 fail:
15270 return NULL;
15271 }
15272
15273
15274 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15275 PyObject *resultobj = 0;
15276 wxJoystick *arg1 = (wxJoystick *) 0 ;
15277 wxPoint result;
15278 void *argp1 = 0 ;
15279 int res1 = 0 ;
15280 PyObject *swig_obj[1] ;
15281
15282 if (!args) SWIG_fail;
15283 swig_obj[0] = args;
15284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15285 if (!SWIG_IsOK(res1)) {
15286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15287 }
15288 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15289 {
15290 PyThreadState* __tstate = wxPyBeginAllowThreads();
15291 result = (arg1)->GetPosition();
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15303 PyObject *resultobj = 0;
15304 wxJoystick *arg1 = (wxJoystick *) 0 ;
15305 int result;
15306 void *argp1 = 0 ;
15307 int res1 = 0 ;
15308 PyObject *swig_obj[1] ;
15309
15310 if (!args) SWIG_fail;
15311 swig_obj[0] = args;
15312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15315 }
15316 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (int)(arg1)->GetZPosition();
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 resultobj = SWIG_From_int(static_cast< int >(result));
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15331 PyObject *resultobj = 0;
15332 wxJoystick *arg1 = (wxJoystick *) 0 ;
15333 int result;
15334 void *argp1 = 0 ;
15335 int res1 = 0 ;
15336 PyObject *swig_obj[1] ;
15337
15338 if (!args) SWIG_fail;
15339 swig_obj[0] = args;
15340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15341 if (!SWIG_IsOK(res1)) {
15342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15343 }
15344 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15345 {
15346 PyThreadState* __tstate = wxPyBeginAllowThreads();
15347 result = (int)(arg1)->GetButtonState();
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 resultobj = SWIG_From_int(static_cast< int >(result));
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15359 PyObject *resultobj = 0;
15360 wxJoystick *arg1 = (wxJoystick *) 0 ;
15361 int result;
15362 void *argp1 = 0 ;
15363 int res1 = 0 ;
15364 PyObject *swig_obj[1] ;
15365
15366 if (!args) SWIG_fail;
15367 swig_obj[0] = args;
15368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15369 if (!SWIG_IsOK(res1)) {
15370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15371 }
15372 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15373 {
15374 PyThreadState* __tstate = wxPyBeginAllowThreads();
15375 result = (int)(arg1)->GetPOVPosition();
15376 wxPyEndAllowThreads(__tstate);
15377 if (PyErr_Occurred()) SWIG_fail;
15378 }
15379 resultobj = SWIG_From_int(static_cast< int >(result));
15380 return resultobj;
15381 fail:
15382 return NULL;
15383 }
15384
15385
15386 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15387 PyObject *resultobj = 0;
15388 wxJoystick *arg1 = (wxJoystick *) 0 ;
15389 int result;
15390 void *argp1 = 0 ;
15391 int res1 = 0 ;
15392 PyObject *swig_obj[1] ;
15393
15394 if (!args) SWIG_fail;
15395 swig_obj[0] = args;
15396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15397 if (!SWIG_IsOK(res1)) {
15398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15399 }
15400 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 result = (int)(arg1)->GetPOVCTSPosition();
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 resultobj = SWIG_From_int(static_cast< int >(result));
15408 return resultobj;
15409 fail:
15410 return NULL;
15411 }
15412
15413
15414 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15415 PyObject *resultobj = 0;
15416 wxJoystick *arg1 = (wxJoystick *) 0 ;
15417 int result;
15418 void *argp1 = 0 ;
15419 int res1 = 0 ;
15420 PyObject *swig_obj[1] ;
15421
15422 if (!args) SWIG_fail;
15423 swig_obj[0] = args;
15424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15425 if (!SWIG_IsOK(res1)) {
15426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15427 }
15428 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (int)(arg1)->GetRudderPosition();
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 resultobj = SWIG_From_int(static_cast< int >(result));
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15443 PyObject *resultobj = 0;
15444 wxJoystick *arg1 = (wxJoystick *) 0 ;
15445 int result;
15446 void *argp1 = 0 ;
15447 int res1 = 0 ;
15448 PyObject *swig_obj[1] ;
15449
15450 if (!args) SWIG_fail;
15451 swig_obj[0] = args;
15452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15453 if (!SWIG_IsOK(res1)) {
15454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15455 }
15456 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15457 {
15458 PyThreadState* __tstate = wxPyBeginAllowThreads();
15459 result = (int)(arg1)->GetUPosition();
15460 wxPyEndAllowThreads(__tstate);
15461 if (PyErr_Occurred()) SWIG_fail;
15462 }
15463 resultobj = SWIG_From_int(static_cast< int >(result));
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15471 PyObject *resultobj = 0;
15472 wxJoystick *arg1 = (wxJoystick *) 0 ;
15473 int result;
15474 void *argp1 = 0 ;
15475 int res1 = 0 ;
15476 PyObject *swig_obj[1] ;
15477
15478 if (!args) SWIG_fail;
15479 swig_obj[0] = args;
15480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15481 if (!SWIG_IsOK(res1)) {
15482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15483 }
15484 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15485 {
15486 PyThreadState* __tstate = wxPyBeginAllowThreads();
15487 result = (int)(arg1)->GetVPosition();
15488 wxPyEndAllowThreads(__tstate);
15489 if (PyErr_Occurred()) SWIG_fail;
15490 }
15491 resultobj = SWIG_From_int(static_cast< int >(result));
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15499 PyObject *resultobj = 0;
15500 wxJoystick *arg1 = (wxJoystick *) 0 ;
15501 int result;
15502 void *argp1 = 0 ;
15503 int res1 = 0 ;
15504 PyObject *swig_obj[1] ;
15505
15506 if (!args) SWIG_fail;
15507 swig_obj[0] = args;
15508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15509 if (!SWIG_IsOK(res1)) {
15510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15511 }
15512 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 result = (int)(arg1)->GetMovementThreshold();
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 resultobj = SWIG_From_int(static_cast< int >(result));
15520 return resultobj;
15521 fail:
15522 return NULL;
15523 }
15524
15525
15526 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15527 PyObject *resultobj = 0;
15528 wxJoystick *arg1 = (wxJoystick *) 0 ;
15529 int arg2 ;
15530 void *argp1 = 0 ;
15531 int res1 = 0 ;
15532 int val2 ;
15533 int ecode2 = 0 ;
15534 PyObject * obj0 = 0 ;
15535 PyObject * obj1 = 0 ;
15536 char * kwnames[] = {
15537 (char *) "self",(char *) "threshold", NULL
15538 };
15539
15540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15542 if (!SWIG_IsOK(res1)) {
15543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15544 }
15545 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15546 ecode2 = SWIG_AsVal_int(obj1, &val2);
15547 if (!SWIG_IsOK(ecode2)) {
15548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15549 }
15550 arg2 = static_cast< int >(val2);
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 (arg1)->SetMovementThreshold(arg2);
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 resultobj = SWIG_Py_Void();
15558 return resultobj;
15559 fail:
15560 return NULL;
15561 }
15562
15563
15564 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15565 PyObject *resultobj = 0;
15566 wxJoystick *arg1 = (wxJoystick *) 0 ;
15567 bool result;
15568 void *argp1 = 0 ;
15569 int res1 = 0 ;
15570 PyObject *swig_obj[1] ;
15571
15572 if (!args) SWIG_fail;
15573 swig_obj[0] = args;
15574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15575 if (!SWIG_IsOK(res1)) {
15576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15577 }
15578 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 result = (bool)(arg1)->IsOk();
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 {
15586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15587 }
15588 return resultobj;
15589 fail:
15590 return NULL;
15591 }
15592
15593
15594 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15595 PyObject *resultobj = 0;
15596 wxJoystick *arg1 = (wxJoystick *) 0 ;
15597 int result;
15598 void *argp1 = 0 ;
15599 int res1 = 0 ;
15600 PyObject *swig_obj[1] ;
15601
15602 if (!args) SWIG_fail;
15603 swig_obj[0] = args;
15604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15605 if (!SWIG_IsOK(res1)) {
15606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15607 }
15608 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15609 {
15610 PyThreadState* __tstate = wxPyBeginAllowThreads();
15611 result = (int)(arg1)->GetNumberJoysticks();
15612 wxPyEndAllowThreads(__tstate);
15613 if (PyErr_Occurred()) SWIG_fail;
15614 }
15615 resultobj = SWIG_From_int(static_cast< int >(result));
15616 return resultobj;
15617 fail:
15618 return NULL;
15619 }
15620
15621
15622 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15623 PyObject *resultobj = 0;
15624 wxJoystick *arg1 = (wxJoystick *) 0 ;
15625 int result;
15626 void *argp1 = 0 ;
15627 int res1 = 0 ;
15628 PyObject *swig_obj[1] ;
15629
15630 if (!args) SWIG_fail;
15631 swig_obj[0] = args;
15632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15633 if (!SWIG_IsOK(res1)) {
15634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15635 }
15636 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 result = (int)(arg1)->GetManufacturerId();
15640 wxPyEndAllowThreads(__tstate);
15641 if (PyErr_Occurred()) SWIG_fail;
15642 }
15643 resultobj = SWIG_From_int(static_cast< int >(result));
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15651 PyObject *resultobj = 0;
15652 wxJoystick *arg1 = (wxJoystick *) 0 ;
15653 int result;
15654 void *argp1 = 0 ;
15655 int res1 = 0 ;
15656 PyObject *swig_obj[1] ;
15657
15658 if (!args) SWIG_fail;
15659 swig_obj[0] = args;
15660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15661 if (!SWIG_IsOK(res1)) {
15662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15663 }
15664 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (int)(arg1)->GetProductId();
15668 wxPyEndAllowThreads(__tstate);
15669 if (PyErr_Occurred()) SWIG_fail;
15670 }
15671 resultobj = SWIG_From_int(static_cast< int >(result));
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15679 PyObject *resultobj = 0;
15680 wxJoystick *arg1 = (wxJoystick *) 0 ;
15681 wxString result;
15682 void *argp1 = 0 ;
15683 int res1 = 0 ;
15684 PyObject *swig_obj[1] ;
15685
15686 if (!args) SWIG_fail;
15687 swig_obj[0] = args;
15688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15689 if (!SWIG_IsOK(res1)) {
15690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15691 }
15692 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15693 {
15694 PyThreadState* __tstate = wxPyBeginAllowThreads();
15695 result = (arg1)->GetProductName();
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 {
15700 #if wxUSE_UNICODE
15701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15702 #else
15703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15704 #endif
15705 }
15706 return resultobj;
15707 fail:
15708 return NULL;
15709 }
15710
15711
15712 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15713 PyObject *resultobj = 0;
15714 wxJoystick *arg1 = (wxJoystick *) 0 ;
15715 int result;
15716 void *argp1 = 0 ;
15717 int res1 = 0 ;
15718 PyObject *swig_obj[1] ;
15719
15720 if (!args) SWIG_fail;
15721 swig_obj[0] = args;
15722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15723 if (!SWIG_IsOK(res1)) {
15724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15725 }
15726 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15727 {
15728 PyThreadState* __tstate = wxPyBeginAllowThreads();
15729 result = (int)(arg1)->GetXMin();
15730 wxPyEndAllowThreads(__tstate);
15731 if (PyErr_Occurred()) SWIG_fail;
15732 }
15733 resultobj = SWIG_From_int(static_cast< int >(result));
15734 return resultobj;
15735 fail:
15736 return NULL;
15737 }
15738
15739
15740 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15741 PyObject *resultobj = 0;
15742 wxJoystick *arg1 = (wxJoystick *) 0 ;
15743 int result;
15744 void *argp1 = 0 ;
15745 int res1 = 0 ;
15746 PyObject *swig_obj[1] ;
15747
15748 if (!args) SWIG_fail;
15749 swig_obj[0] = args;
15750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15751 if (!SWIG_IsOK(res1)) {
15752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15753 }
15754 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 result = (int)(arg1)->GetYMin();
15758 wxPyEndAllowThreads(__tstate);
15759 if (PyErr_Occurred()) SWIG_fail;
15760 }
15761 resultobj = SWIG_From_int(static_cast< int >(result));
15762 return resultobj;
15763 fail:
15764 return NULL;
15765 }
15766
15767
15768 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15769 PyObject *resultobj = 0;
15770 wxJoystick *arg1 = (wxJoystick *) 0 ;
15771 int result;
15772 void *argp1 = 0 ;
15773 int res1 = 0 ;
15774 PyObject *swig_obj[1] ;
15775
15776 if (!args) SWIG_fail;
15777 swig_obj[0] = args;
15778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15779 if (!SWIG_IsOK(res1)) {
15780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15781 }
15782 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15783 {
15784 PyThreadState* __tstate = wxPyBeginAllowThreads();
15785 result = (int)(arg1)->GetZMin();
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 resultobj = SWIG_From_int(static_cast< int >(result));
15790 return resultobj;
15791 fail:
15792 return NULL;
15793 }
15794
15795
15796 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15797 PyObject *resultobj = 0;
15798 wxJoystick *arg1 = (wxJoystick *) 0 ;
15799 int result;
15800 void *argp1 = 0 ;
15801 int res1 = 0 ;
15802 PyObject *swig_obj[1] ;
15803
15804 if (!args) SWIG_fail;
15805 swig_obj[0] = args;
15806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15807 if (!SWIG_IsOK(res1)) {
15808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15809 }
15810 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15811 {
15812 PyThreadState* __tstate = wxPyBeginAllowThreads();
15813 result = (int)(arg1)->GetXMax();
15814 wxPyEndAllowThreads(__tstate);
15815 if (PyErr_Occurred()) SWIG_fail;
15816 }
15817 resultobj = SWIG_From_int(static_cast< int >(result));
15818 return resultobj;
15819 fail:
15820 return NULL;
15821 }
15822
15823
15824 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15825 PyObject *resultobj = 0;
15826 wxJoystick *arg1 = (wxJoystick *) 0 ;
15827 int result;
15828 void *argp1 = 0 ;
15829 int res1 = 0 ;
15830 PyObject *swig_obj[1] ;
15831
15832 if (!args) SWIG_fail;
15833 swig_obj[0] = args;
15834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15835 if (!SWIG_IsOK(res1)) {
15836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15837 }
15838 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15839 {
15840 PyThreadState* __tstate = wxPyBeginAllowThreads();
15841 result = (int)(arg1)->GetYMax();
15842 wxPyEndAllowThreads(__tstate);
15843 if (PyErr_Occurred()) SWIG_fail;
15844 }
15845 resultobj = SWIG_From_int(static_cast< int >(result));
15846 return resultobj;
15847 fail:
15848 return NULL;
15849 }
15850
15851
15852 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15853 PyObject *resultobj = 0;
15854 wxJoystick *arg1 = (wxJoystick *) 0 ;
15855 int result;
15856 void *argp1 = 0 ;
15857 int res1 = 0 ;
15858 PyObject *swig_obj[1] ;
15859
15860 if (!args) SWIG_fail;
15861 swig_obj[0] = args;
15862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15863 if (!SWIG_IsOK(res1)) {
15864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15865 }
15866 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15867 {
15868 PyThreadState* __tstate = wxPyBeginAllowThreads();
15869 result = (int)(arg1)->GetZMax();
15870 wxPyEndAllowThreads(__tstate);
15871 if (PyErr_Occurred()) SWIG_fail;
15872 }
15873 resultobj = SWIG_From_int(static_cast< int >(result));
15874 return resultobj;
15875 fail:
15876 return NULL;
15877 }
15878
15879
15880 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15881 PyObject *resultobj = 0;
15882 wxJoystick *arg1 = (wxJoystick *) 0 ;
15883 int result;
15884 void *argp1 = 0 ;
15885 int res1 = 0 ;
15886 PyObject *swig_obj[1] ;
15887
15888 if (!args) SWIG_fail;
15889 swig_obj[0] = args;
15890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15891 if (!SWIG_IsOK(res1)) {
15892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15893 }
15894 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 result = (int)(arg1)->GetNumberButtons();
15898 wxPyEndAllowThreads(__tstate);
15899 if (PyErr_Occurred()) SWIG_fail;
15900 }
15901 resultobj = SWIG_From_int(static_cast< int >(result));
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15909 PyObject *resultobj = 0;
15910 wxJoystick *arg1 = (wxJoystick *) 0 ;
15911 int result;
15912 void *argp1 = 0 ;
15913 int res1 = 0 ;
15914 PyObject *swig_obj[1] ;
15915
15916 if (!args) SWIG_fail;
15917 swig_obj[0] = args;
15918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15919 if (!SWIG_IsOK(res1)) {
15920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15921 }
15922 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15923 {
15924 PyThreadState* __tstate = wxPyBeginAllowThreads();
15925 result = (int)(arg1)->GetNumberAxes();
15926 wxPyEndAllowThreads(__tstate);
15927 if (PyErr_Occurred()) SWIG_fail;
15928 }
15929 resultobj = SWIG_From_int(static_cast< int >(result));
15930 return resultobj;
15931 fail:
15932 return NULL;
15933 }
15934
15935
15936 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15937 PyObject *resultobj = 0;
15938 wxJoystick *arg1 = (wxJoystick *) 0 ;
15939 int result;
15940 void *argp1 = 0 ;
15941 int res1 = 0 ;
15942 PyObject *swig_obj[1] ;
15943
15944 if (!args) SWIG_fail;
15945 swig_obj[0] = args;
15946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15947 if (!SWIG_IsOK(res1)) {
15948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15949 }
15950 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 result = (int)(arg1)->GetMaxButtons();
15954 wxPyEndAllowThreads(__tstate);
15955 if (PyErr_Occurred()) SWIG_fail;
15956 }
15957 resultobj = SWIG_From_int(static_cast< int >(result));
15958 return resultobj;
15959 fail:
15960 return NULL;
15961 }
15962
15963
15964 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15965 PyObject *resultobj = 0;
15966 wxJoystick *arg1 = (wxJoystick *) 0 ;
15967 int result;
15968 void *argp1 = 0 ;
15969 int res1 = 0 ;
15970 PyObject *swig_obj[1] ;
15971
15972 if (!args) SWIG_fail;
15973 swig_obj[0] = args;
15974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15975 if (!SWIG_IsOK(res1)) {
15976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15977 }
15978 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 result = (int)(arg1)->GetMaxAxes();
15982 wxPyEndAllowThreads(__tstate);
15983 if (PyErr_Occurred()) SWIG_fail;
15984 }
15985 resultobj = SWIG_From_int(static_cast< int >(result));
15986 return resultobj;
15987 fail:
15988 return NULL;
15989 }
15990
15991
15992 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15993 PyObject *resultobj = 0;
15994 wxJoystick *arg1 = (wxJoystick *) 0 ;
15995 int result;
15996 void *argp1 = 0 ;
15997 int res1 = 0 ;
15998 PyObject *swig_obj[1] ;
15999
16000 if (!args) SWIG_fail;
16001 swig_obj[0] = args;
16002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16003 if (!SWIG_IsOK(res1)) {
16004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16005 }
16006 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 result = (int)(arg1)->GetPollingMin();
16010 wxPyEndAllowThreads(__tstate);
16011 if (PyErr_Occurred()) SWIG_fail;
16012 }
16013 resultobj = SWIG_From_int(static_cast< int >(result));
16014 return resultobj;
16015 fail:
16016 return NULL;
16017 }
16018
16019
16020 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16021 PyObject *resultobj = 0;
16022 wxJoystick *arg1 = (wxJoystick *) 0 ;
16023 int result;
16024 void *argp1 = 0 ;
16025 int res1 = 0 ;
16026 PyObject *swig_obj[1] ;
16027
16028 if (!args) SWIG_fail;
16029 swig_obj[0] = args;
16030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16031 if (!SWIG_IsOK(res1)) {
16032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16033 }
16034 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16035 {
16036 PyThreadState* __tstate = wxPyBeginAllowThreads();
16037 result = (int)(arg1)->GetPollingMax();
16038 wxPyEndAllowThreads(__tstate);
16039 if (PyErr_Occurred()) SWIG_fail;
16040 }
16041 resultobj = SWIG_From_int(static_cast< int >(result));
16042 return resultobj;
16043 fail:
16044 return NULL;
16045 }
16046
16047
16048 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16049 PyObject *resultobj = 0;
16050 wxJoystick *arg1 = (wxJoystick *) 0 ;
16051 int result;
16052 void *argp1 = 0 ;
16053 int res1 = 0 ;
16054 PyObject *swig_obj[1] ;
16055
16056 if (!args) SWIG_fail;
16057 swig_obj[0] = args;
16058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16059 if (!SWIG_IsOK(res1)) {
16060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16061 }
16062 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16063 {
16064 PyThreadState* __tstate = wxPyBeginAllowThreads();
16065 result = (int)(arg1)->GetRudderMin();
16066 wxPyEndAllowThreads(__tstate);
16067 if (PyErr_Occurred()) SWIG_fail;
16068 }
16069 resultobj = SWIG_From_int(static_cast< int >(result));
16070 return resultobj;
16071 fail:
16072 return NULL;
16073 }
16074
16075
16076 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16077 PyObject *resultobj = 0;
16078 wxJoystick *arg1 = (wxJoystick *) 0 ;
16079 int result;
16080 void *argp1 = 0 ;
16081 int res1 = 0 ;
16082 PyObject *swig_obj[1] ;
16083
16084 if (!args) SWIG_fail;
16085 swig_obj[0] = args;
16086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16087 if (!SWIG_IsOK(res1)) {
16088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16089 }
16090 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16091 {
16092 PyThreadState* __tstate = wxPyBeginAllowThreads();
16093 result = (int)(arg1)->GetRudderMax();
16094 wxPyEndAllowThreads(__tstate);
16095 if (PyErr_Occurred()) SWIG_fail;
16096 }
16097 resultobj = SWIG_From_int(static_cast< int >(result));
16098 return resultobj;
16099 fail:
16100 return NULL;
16101 }
16102
16103
16104 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16105 PyObject *resultobj = 0;
16106 wxJoystick *arg1 = (wxJoystick *) 0 ;
16107 int result;
16108 void *argp1 = 0 ;
16109 int res1 = 0 ;
16110 PyObject *swig_obj[1] ;
16111
16112 if (!args) SWIG_fail;
16113 swig_obj[0] = args;
16114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16115 if (!SWIG_IsOK(res1)) {
16116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16117 }
16118 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16119 {
16120 PyThreadState* __tstate = wxPyBeginAllowThreads();
16121 result = (int)(arg1)->GetUMin();
16122 wxPyEndAllowThreads(__tstate);
16123 if (PyErr_Occurred()) SWIG_fail;
16124 }
16125 resultobj = SWIG_From_int(static_cast< int >(result));
16126 return resultobj;
16127 fail:
16128 return NULL;
16129 }
16130
16131
16132 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16133 PyObject *resultobj = 0;
16134 wxJoystick *arg1 = (wxJoystick *) 0 ;
16135 int result;
16136 void *argp1 = 0 ;
16137 int res1 = 0 ;
16138 PyObject *swig_obj[1] ;
16139
16140 if (!args) SWIG_fail;
16141 swig_obj[0] = args;
16142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16143 if (!SWIG_IsOK(res1)) {
16144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16145 }
16146 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 result = (int)(arg1)->GetUMax();
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 resultobj = SWIG_From_int(static_cast< int >(result));
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16161 PyObject *resultobj = 0;
16162 wxJoystick *arg1 = (wxJoystick *) 0 ;
16163 int result;
16164 void *argp1 = 0 ;
16165 int res1 = 0 ;
16166 PyObject *swig_obj[1] ;
16167
16168 if (!args) SWIG_fail;
16169 swig_obj[0] = args;
16170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16171 if (!SWIG_IsOK(res1)) {
16172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16173 }
16174 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16175 {
16176 PyThreadState* __tstate = wxPyBeginAllowThreads();
16177 result = (int)(arg1)->GetVMin();
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 resultobj = SWIG_From_int(static_cast< int >(result));
16182 return resultobj;
16183 fail:
16184 return NULL;
16185 }
16186
16187
16188 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16189 PyObject *resultobj = 0;
16190 wxJoystick *arg1 = (wxJoystick *) 0 ;
16191 int result;
16192 void *argp1 = 0 ;
16193 int res1 = 0 ;
16194 PyObject *swig_obj[1] ;
16195
16196 if (!args) SWIG_fail;
16197 swig_obj[0] = args;
16198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16199 if (!SWIG_IsOK(res1)) {
16200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16201 }
16202 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16203 {
16204 PyThreadState* __tstate = wxPyBeginAllowThreads();
16205 result = (int)(arg1)->GetVMax();
16206 wxPyEndAllowThreads(__tstate);
16207 if (PyErr_Occurred()) SWIG_fail;
16208 }
16209 resultobj = SWIG_From_int(static_cast< int >(result));
16210 return resultobj;
16211 fail:
16212 return NULL;
16213 }
16214
16215
16216 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16217 PyObject *resultobj = 0;
16218 wxJoystick *arg1 = (wxJoystick *) 0 ;
16219 bool result;
16220 void *argp1 = 0 ;
16221 int res1 = 0 ;
16222 PyObject *swig_obj[1] ;
16223
16224 if (!args) SWIG_fail;
16225 swig_obj[0] = args;
16226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16227 if (!SWIG_IsOK(res1)) {
16228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16229 }
16230 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16231 {
16232 PyThreadState* __tstate = wxPyBeginAllowThreads();
16233 result = (bool)(arg1)->HasRudder();
16234 wxPyEndAllowThreads(__tstate);
16235 if (PyErr_Occurred()) SWIG_fail;
16236 }
16237 {
16238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16239 }
16240 return resultobj;
16241 fail:
16242 return NULL;
16243 }
16244
16245
16246 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16247 PyObject *resultobj = 0;
16248 wxJoystick *arg1 = (wxJoystick *) 0 ;
16249 bool result;
16250 void *argp1 = 0 ;
16251 int res1 = 0 ;
16252 PyObject *swig_obj[1] ;
16253
16254 if (!args) SWIG_fail;
16255 swig_obj[0] = args;
16256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16257 if (!SWIG_IsOK(res1)) {
16258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16259 }
16260 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16261 {
16262 PyThreadState* __tstate = wxPyBeginAllowThreads();
16263 result = (bool)(arg1)->HasZ();
16264 wxPyEndAllowThreads(__tstate);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 }
16267 {
16268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16269 }
16270 return resultobj;
16271 fail:
16272 return NULL;
16273 }
16274
16275
16276 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16277 PyObject *resultobj = 0;
16278 wxJoystick *arg1 = (wxJoystick *) 0 ;
16279 bool result;
16280 void *argp1 = 0 ;
16281 int res1 = 0 ;
16282 PyObject *swig_obj[1] ;
16283
16284 if (!args) SWIG_fail;
16285 swig_obj[0] = args;
16286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16287 if (!SWIG_IsOK(res1)) {
16288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16289 }
16290 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16291 {
16292 PyThreadState* __tstate = wxPyBeginAllowThreads();
16293 result = (bool)(arg1)->HasU();
16294 wxPyEndAllowThreads(__tstate);
16295 if (PyErr_Occurred()) SWIG_fail;
16296 }
16297 {
16298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16299 }
16300 return resultobj;
16301 fail:
16302 return NULL;
16303 }
16304
16305
16306 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16307 PyObject *resultobj = 0;
16308 wxJoystick *arg1 = (wxJoystick *) 0 ;
16309 bool result;
16310 void *argp1 = 0 ;
16311 int res1 = 0 ;
16312 PyObject *swig_obj[1] ;
16313
16314 if (!args) SWIG_fail;
16315 swig_obj[0] = args;
16316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16317 if (!SWIG_IsOK(res1)) {
16318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16319 }
16320 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 result = (bool)(arg1)->HasV();
16324 wxPyEndAllowThreads(__tstate);
16325 if (PyErr_Occurred()) SWIG_fail;
16326 }
16327 {
16328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16329 }
16330 return resultobj;
16331 fail:
16332 return NULL;
16333 }
16334
16335
16336 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16337 PyObject *resultobj = 0;
16338 wxJoystick *arg1 = (wxJoystick *) 0 ;
16339 bool result;
16340 void *argp1 = 0 ;
16341 int res1 = 0 ;
16342 PyObject *swig_obj[1] ;
16343
16344 if (!args) SWIG_fail;
16345 swig_obj[0] = args;
16346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16347 if (!SWIG_IsOK(res1)) {
16348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16349 }
16350 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (bool)(arg1)->HasPOV();
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 {
16358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16359 }
16360 return resultobj;
16361 fail:
16362 return NULL;
16363 }
16364
16365
16366 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16367 PyObject *resultobj = 0;
16368 wxJoystick *arg1 = (wxJoystick *) 0 ;
16369 bool result;
16370 void *argp1 = 0 ;
16371 int res1 = 0 ;
16372 PyObject *swig_obj[1] ;
16373
16374 if (!args) SWIG_fail;
16375 swig_obj[0] = args;
16376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16377 if (!SWIG_IsOK(res1)) {
16378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16379 }
16380 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (bool)(arg1)->HasPOV4Dir();
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 {
16388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16389 }
16390 return resultobj;
16391 fail:
16392 return NULL;
16393 }
16394
16395
16396 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16397 PyObject *resultobj = 0;
16398 wxJoystick *arg1 = (wxJoystick *) 0 ;
16399 bool result;
16400 void *argp1 = 0 ;
16401 int res1 = 0 ;
16402 PyObject *swig_obj[1] ;
16403
16404 if (!args) SWIG_fail;
16405 swig_obj[0] = args;
16406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16407 if (!SWIG_IsOK(res1)) {
16408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16409 }
16410 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16411 {
16412 PyThreadState* __tstate = wxPyBeginAllowThreads();
16413 result = (bool)(arg1)->HasPOVCTS();
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16419 }
16420 return resultobj;
16421 fail:
16422 return NULL;
16423 }
16424
16425
16426 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16427 PyObject *resultobj = 0;
16428 wxJoystick *arg1 = (wxJoystick *) 0 ;
16429 wxWindow *arg2 = (wxWindow *) 0 ;
16430 int arg3 = (int) 0 ;
16431 bool result;
16432 void *argp1 = 0 ;
16433 int res1 = 0 ;
16434 void *argp2 = 0 ;
16435 int res2 = 0 ;
16436 int val3 ;
16437 int ecode3 = 0 ;
16438 PyObject * obj0 = 0 ;
16439 PyObject * obj1 = 0 ;
16440 PyObject * obj2 = 0 ;
16441 char * kwnames[] = {
16442 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16443 };
16444
16445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16447 if (!SWIG_IsOK(res1)) {
16448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16449 }
16450 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16452 if (!SWIG_IsOK(res2)) {
16453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16454 }
16455 arg2 = reinterpret_cast< wxWindow * >(argp2);
16456 if (obj2) {
16457 ecode3 = SWIG_AsVal_int(obj2, &val3);
16458 if (!SWIG_IsOK(ecode3)) {
16459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16460 }
16461 arg3 = static_cast< int >(val3);
16462 }
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (bool)(arg1)->SetCapture(arg2,arg3);
16466 wxPyEndAllowThreads(__tstate);
16467 if (PyErr_Occurred()) SWIG_fail;
16468 }
16469 {
16470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16471 }
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16479 PyObject *resultobj = 0;
16480 wxJoystick *arg1 = (wxJoystick *) 0 ;
16481 bool result;
16482 void *argp1 = 0 ;
16483 int res1 = 0 ;
16484 PyObject *swig_obj[1] ;
16485
16486 if (!args) SWIG_fail;
16487 swig_obj[0] = args;
16488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16489 if (!SWIG_IsOK(res1)) {
16490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16491 }
16492 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (bool)(arg1)->ReleaseCapture();
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 {
16500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16501 }
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16509 PyObject *obj;
16510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16511 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16512 return SWIG_Py_Void();
16513 }
16514
16515 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16516 return SWIG_Python_InitShadowInstance(args);
16517 }
16518
16519 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj = 0;
16521 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16522 int arg2 = (int) 0 ;
16523 int arg3 = (int) wxJOYSTICK1 ;
16524 int arg4 = (int) 0 ;
16525 wxJoystickEvent *result = 0 ;
16526 int val1 ;
16527 int ecode1 = 0 ;
16528 int val2 ;
16529 int ecode2 = 0 ;
16530 int val3 ;
16531 int ecode3 = 0 ;
16532 int val4 ;
16533 int ecode4 = 0 ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 PyObject * obj2 = 0 ;
16537 PyObject * obj3 = 0 ;
16538 char * kwnames[] = {
16539 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16540 };
16541
16542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16543 if (obj0) {
16544 ecode1 = SWIG_AsVal_int(obj0, &val1);
16545 if (!SWIG_IsOK(ecode1)) {
16546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16547 }
16548 arg1 = static_cast< wxEventType >(val1);
16549 }
16550 if (obj1) {
16551 ecode2 = SWIG_AsVal_int(obj1, &val2);
16552 if (!SWIG_IsOK(ecode2)) {
16553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16554 }
16555 arg2 = static_cast< int >(val2);
16556 }
16557 if (obj2) {
16558 ecode3 = SWIG_AsVal_int(obj2, &val3);
16559 if (!SWIG_IsOK(ecode3)) {
16560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16561 }
16562 arg3 = static_cast< int >(val3);
16563 }
16564 if (obj3) {
16565 ecode4 = SWIG_AsVal_int(obj3, &val4);
16566 if (!SWIG_IsOK(ecode4)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16568 }
16569 arg4 = static_cast< int >(val4);
16570 }
16571 {
16572 PyThreadState* __tstate = wxPyBeginAllowThreads();
16573 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16574 wxPyEndAllowThreads(__tstate);
16575 if (PyErr_Occurred()) SWIG_fail;
16576 }
16577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16578 return resultobj;
16579 fail:
16580 return NULL;
16581 }
16582
16583
16584 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16585 PyObject *resultobj = 0;
16586 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16587 wxPoint result;
16588 void *argp1 = 0 ;
16589 int res1 = 0 ;
16590 PyObject *swig_obj[1] ;
16591
16592 if (!args) SWIG_fail;
16593 swig_obj[0] = args;
16594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16595 if (!SWIG_IsOK(res1)) {
16596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16597 }
16598 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16599 {
16600 PyThreadState* __tstate = wxPyBeginAllowThreads();
16601 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16602 wxPyEndAllowThreads(__tstate);
16603 if (PyErr_Occurred()) SWIG_fail;
16604 }
16605 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16606 return resultobj;
16607 fail:
16608 return NULL;
16609 }
16610
16611
16612 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16613 PyObject *resultobj = 0;
16614 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16615 int result;
16616 void *argp1 = 0 ;
16617 int res1 = 0 ;
16618 PyObject *swig_obj[1] ;
16619
16620 if (!args) SWIG_fail;
16621 swig_obj[0] = args;
16622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16623 if (!SWIG_IsOK(res1)) {
16624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16625 }
16626 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16627 {
16628 PyThreadState* __tstate = wxPyBeginAllowThreads();
16629 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16630 wxPyEndAllowThreads(__tstate);
16631 if (PyErr_Occurred()) SWIG_fail;
16632 }
16633 resultobj = SWIG_From_int(static_cast< int >(result));
16634 return resultobj;
16635 fail:
16636 return NULL;
16637 }
16638
16639
16640 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16641 PyObject *resultobj = 0;
16642 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16643 int result;
16644 void *argp1 = 0 ;
16645 int res1 = 0 ;
16646 PyObject *swig_obj[1] ;
16647
16648 if (!args) SWIG_fail;
16649 swig_obj[0] = args;
16650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16651 if (!SWIG_IsOK(res1)) {
16652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16653 }
16654 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16655 {
16656 PyThreadState* __tstate = wxPyBeginAllowThreads();
16657 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16658 wxPyEndAllowThreads(__tstate);
16659 if (PyErr_Occurred()) SWIG_fail;
16660 }
16661 resultobj = SWIG_From_int(static_cast< int >(result));
16662 return resultobj;
16663 fail:
16664 return NULL;
16665 }
16666
16667
16668 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16669 PyObject *resultobj = 0;
16670 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16671 int result;
16672 void *argp1 = 0 ;
16673 int res1 = 0 ;
16674 PyObject *swig_obj[1] ;
16675
16676 if (!args) SWIG_fail;
16677 swig_obj[0] = args;
16678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16679 if (!SWIG_IsOK(res1)) {
16680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16681 }
16682 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16683 {
16684 PyThreadState* __tstate = wxPyBeginAllowThreads();
16685 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 resultobj = SWIG_From_int(static_cast< int >(result));
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16697 PyObject *resultobj = 0;
16698 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16699 int result;
16700 void *argp1 = 0 ;
16701 int res1 = 0 ;
16702 PyObject *swig_obj[1] ;
16703
16704 if (!args) SWIG_fail;
16705 swig_obj[0] = args;
16706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16707 if (!SWIG_IsOK(res1)) {
16708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16709 }
16710 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16711 {
16712 PyThreadState* __tstate = wxPyBeginAllowThreads();
16713 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 resultobj = SWIG_From_int(static_cast< int >(result));
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj = 0;
16726 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16727 int arg2 ;
16728 void *argp1 = 0 ;
16729 int res1 = 0 ;
16730 int val2 ;
16731 int ecode2 = 0 ;
16732 PyObject * obj0 = 0 ;
16733 PyObject * obj1 = 0 ;
16734 char * kwnames[] = {
16735 (char *) "self",(char *) "stick", NULL
16736 };
16737
16738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16740 if (!SWIG_IsOK(res1)) {
16741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16742 }
16743 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16744 ecode2 = SWIG_AsVal_int(obj1, &val2);
16745 if (!SWIG_IsOK(ecode2)) {
16746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16747 }
16748 arg2 = static_cast< int >(val2);
16749 {
16750 PyThreadState* __tstate = wxPyBeginAllowThreads();
16751 (arg1)->SetJoystick(arg2);
16752 wxPyEndAllowThreads(__tstate);
16753 if (PyErr_Occurred()) SWIG_fail;
16754 }
16755 resultobj = SWIG_Py_Void();
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj = 0;
16764 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16765 int arg2 ;
16766 void *argp1 = 0 ;
16767 int res1 = 0 ;
16768 int val2 ;
16769 int ecode2 = 0 ;
16770 PyObject * obj0 = 0 ;
16771 PyObject * obj1 = 0 ;
16772 char * kwnames[] = {
16773 (char *) "self",(char *) "state", NULL
16774 };
16775
16776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16778 if (!SWIG_IsOK(res1)) {
16779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16780 }
16781 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16782 ecode2 = SWIG_AsVal_int(obj1, &val2);
16783 if (!SWIG_IsOK(ecode2)) {
16784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16785 }
16786 arg2 = static_cast< int >(val2);
16787 {
16788 PyThreadState* __tstate = wxPyBeginAllowThreads();
16789 (arg1)->SetButtonState(arg2);
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 resultobj = SWIG_Py_Void();
16794 return resultobj;
16795 fail:
16796 return NULL;
16797 }
16798
16799
16800 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj = 0;
16802 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16803 int arg2 ;
16804 void *argp1 = 0 ;
16805 int res1 = 0 ;
16806 int val2 ;
16807 int ecode2 = 0 ;
16808 PyObject * obj0 = 0 ;
16809 PyObject * obj1 = 0 ;
16810 char * kwnames[] = {
16811 (char *) "self",(char *) "change", NULL
16812 };
16813
16814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16816 if (!SWIG_IsOK(res1)) {
16817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16818 }
16819 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16820 ecode2 = SWIG_AsVal_int(obj1, &val2);
16821 if (!SWIG_IsOK(ecode2)) {
16822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16823 }
16824 arg2 = static_cast< int >(val2);
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 (arg1)->SetButtonChange(arg2);
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 resultobj = SWIG_Py_Void();
16832 return resultobj;
16833 fail:
16834 return NULL;
16835 }
16836
16837
16838 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16839 PyObject *resultobj = 0;
16840 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16841 wxPoint *arg2 = 0 ;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 wxPoint temp2 ;
16845 PyObject * obj0 = 0 ;
16846 PyObject * obj1 = 0 ;
16847 char * kwnames[] = {
16848 (char *) "self",(char *) "pos", NULL
16849 };
16850
16851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16853 if (!SWIG_IsOK(res1)) {
16854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16855 }
16856 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16857 {
16858 arg2 = &temp2;
16859 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16860 }
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 (arg1)->SetPosition((wxPoint const &)*arg2);
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 resultobj = SWIG_Py_Void();
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj = 0;
16876 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16877 int arg2 ;
16878 void *argp1 = 0 ;
16879 int res1 = 0 ;
16880 int val2 ;
16881 int ecode2 = 0 ;
16882 PyObject * obj0 = 0 ;
16883 PyObject * obj1 = 0 ;
16884 char * kwnames[] = {
16885 (char *) "self",(char *) "zPos", NULL
16886 };
16887
16888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16892 }
16893 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16894 ecode2 = SWIG_AsVal_int(obj1, &val2);
16895 if (!SWIG_IsOK(ecode2)) {
16896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16897 }
16898 arg2 = static_cast< int >(val2);
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 (arg1)->SetZPosition(arg2);
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 resultobj = SWIG_Py_Void();
16906 return resultobj;
16907 fail:
16908 return NULL;
16909 }
16910
16911
16912 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16913 PyObject *resultobj = 0;
16914 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16915 bool result;
16916 void *argp1 = 0 ;
16917 int res1 = 0 ;
16918 PyObject *swig_obj[1] ;
16919
16920 if (!args) SWIG_fail;
16921 swig_obj[0] = args;
16922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16923 if (!SWIG_IsOK(res1)) {
16924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16925 }
16926 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16927 {
16928 PyThreadState* __tstate = wxPyBeginAllowThreads();
16929 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16930 wxPyEndAllowThreads(__tstate);
16931 if (PyErr_Occurred()) SWIG_fail;
16932 }
16933 {
16934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16935 }
16936 return resultobj;
16937 fail:
16938 return NULL;
16939 }
16940
16941
16942 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16943 PyObject *resultobj = 0;
16944 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16945 bool result;
16946 void *argp1 = 0 ;
16947 int res1 = 0 ;
16948 PyObject *swig_obj[1] ;
16949
16950 if (!args) SWIG_fail;
16951 swig_obj[0] = args;
16952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16953 if (!SWIG_IsOK(res1)) {
16954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16955 }
16956 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 {
16964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16965 }
16966 return resultobj;
16967 fail:
16968 return NULL;
16969 }
16970
16971
16972 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16973 PyObject *resultobj = 0;
16974 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16975 bool result;
16976 void *argp1 = 0 ;
16977 int res1 = 0 ;
16978 PyObject *swig_obj[1] ;
16979
16980 if (!args) SWIG_fail;
16981 swig_obj[0] = args;
16982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16983 if (!SWIG_IsOK(res1)) {
16984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16985 }
16986 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16987 {
16988 PyThreadState* __tstate = wxPyBeginAllowThreads();
16989 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 {
16994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16995 }
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj = 0;
17004 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17005 int arg2 = (int) wxJOY_BUTTON_ANY ;
17006 bool result;
17007 void *argp1 = 0 ;
17008 int res1 = 0 ;
17009 int val2 ;
17010 int ecode2 = 0 ;
17011 PyObject * obj0 = 0 ;
17012 PyObject * obj1 = 0 ;
17013 char * kwnames[] = {
17014 (char *) "self",(char *) "but", NULL
17015 };
17016
17017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17019 if (!SWIG_IsOK(res1)) {
17020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17021 }
17022 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17023 if (obj1) {
17024 ecode2 = SWIG_AsVal_int(obj1, &val2);
17025 if (!SWIG_IsOK(ecode2)) {
17026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17027 }
17028 arg2 = static_cast< int >(val2);
17029 }
17030 {
17031 PyThreadState* __tstate = wxPyBeginAllowThreads();
17032 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 {
17037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17038 }
17039 return resultobj;
17040 fail:
17041 return NULL;
17042 }
17043
17044
17045 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17046 PyObject *resultobj = 0;
17047 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17048 int arg2 = (int) wxJOY_BUTTON_ANY ;
17049 bool result;
17050 void *argp1 = 0 ;
17051 int res1 = 0 ;
17052 int val2 ;
17053 int ecode2 = 0 ;
17054 PyObject * obj0 = 0 ;
17055 PyObject * obj1 = 0 ;
17056 char * kwnames[] = {
17057 (char *) "self",(char *) "but", NULL
17058 };
17059
17060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17062 if (!SWIG_IsOK(res1)) {
17063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17064 }
17065 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17066 if (obj1) {
17067 ecode2 = SWIG_AsVal_int(obj1, &val2);
17068 if (!SWIG_IsOK(ecode2)) {
17069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17070 }
17071 arg2 = static_cast< int >(val2);
17072 }
17073 {
17074 PyThreadState* __tstate = wxPyBeginAllowThreads();
17075 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17076 wxPyEndAllowThreads(__tstate);
17077 if (PyErr_Occurred()) SWIG_fail;
17078 }
17079 {
17080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17081 }
17082 return resultobj;
17083 fail:
17084 return NULL;
17085 }
17086
17087
17088 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17089 PyObject *resultobj = 0;
17090 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17091 int arg2 = (int) wxJOY_BUTTON_ANY ;
17092 bool result;
17093 void *argp1 = 0 ;
17094 int res1 = 0 ;
17095 int val2 ;
17096 int ecode2 = 0 ;
17097 PyObject * obj0 = 0 ;
17098 PyObject * obj1 = 0 ;
17099 char * kwnames[] = {
17100 (char *) "self",(char *) "but", NULL
17101 };
17102
17103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17105 if (!SWIG_IsOK(res1)) {
17106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17107 }
17108 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17109 if (obj1) {
17110 ecode2 = SWIG_AsVal_int(obj1, &val2);
17111 if (!SWIG_IsOK(ecode2)) {
17112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17113 }
17114 arg2 = static_cast< int >(val2);
17115 }
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17119 wxPyEndAllowThreads(__tstate);
17120 if (PyErr_Occurred()) SWIG_fail;
17121 }
17122 {
17123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17124 }
17125 return resultobj;
17126 fail:
17127 return NULL;
17128 }
17129
17130
17131 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17132 PyObject *obj;
17133 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17134 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17135 return SWIG_Py_Void();
17136 }
17137
17138 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17139 return SWIG_Python_InitShadowInstance(args);
17140 }
17141
17142 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17143 PyObject *resultobj = 0;
17144 wxString const &arg1_defvalue = wxPyEmptyString ;
17145 wxString *arg1 = (wxString *) &arg1_defvalue ;
17146 wxSound *result = 0 ;
17147 bool temp1 = false ;
17148 PyObject * obj0 = 0 ;
17149 char * kwnames[] = {
17150 (char *) "fileName", NULL
17151 };
17152
17153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17154 if (obj0) {
17155 {
17156 arg1 = wxString_in_helper(obj0);
17157 if (arg1 == NULL) SWIG_fail;
17158 temp1 = true;
17159 }
17160 }
17161 {
17162 if (!wxPyCheckForApp()) SWIG_fail;
17163 PyThreadState* __tstate = wxPyBeginAllowThreads();
17164 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17165 wxPyEndAllowThreads(__tstate);
17166 if (PyErr_Occurred()) SWIG_fail;
17167 }
17168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17169 {
17170 if (temp1)
17171 delete arg1;
17172 }
17173 return resultobj;
17174 fail:
17175 {
17176 if (temp1)
17177 delete arg1;
17178 }
17179 return NULL;
17180 }
17181
17182
17183 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj = 0;
17185 PyObject *arg1 = (PyObject *) 0 ;
17186 wxSound *result = 0 ;
17187 PyObject * obj0 = 0 ;
17188 char * kwnames[] = {
17189 (char *) "data", NULL
17190 };
17191
17192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17193 arg1 = obj0;
17194 {
17195 if (!wxPyCheckForApp()) SWIG_fail;
17196 PyThreadState* __tstate = wxPyBeginAllowThreads();
17197 result = (wxSound *)new_wxSound(arg1);
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17202 return resultobj;
17203 fail:
17204 return NULL;
17205 }
17206
17207
17208 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17209 PyObject *resultobj = 0;
17210 wxSound *arg1 = (wxSound *) 0 ;
17211 void *argp1 = 0 ;
17212 int res1 = 0 ;
17213 PyObject *swig_obj[1] ;
17214
17215 if (!args) SWIG_fail;
17216 swig_obj[0] = args;
17217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17218 if (!SWIG_IsOK(res1)) {
17219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17220 }
17221 arg1 = reinterpret_cast< wxSound * >(argp1);
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 delete arg1;
17225
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 resultobj = SWIG_Py_Void();
17230 return resultobj;
17231 fail:
17232 return NULL;
17233 }
17234
17235
17236 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17237 PyObject *resultobj = 0;
17238 wxSound *arg1 = (wxSound *) 0 ;
17239 wxString *arg2 = 0 ;
17240 bool result;
17241 void *argp1 = 0 ;
17242 int res1 = 0 ;
17243 bool temp2 = false ;
17244 PyObject * obj0 = 0 ;
17245 PyObject * obj1 = 0 ;
17246 char * kwnames[] = {
17247 (char *) "self",(char *) "fileName", NULL
17248 };
17249
17250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17252 if (!SWIG_IsOK(res1)) {
17253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17254 }
17255 arg1 = reinterpret_cast< wxSound * >(argp1);
17256 {
17257 arg2 = wxString_in_helper(obj1);
17258 if (arg2 == NULL) SWIG_fail;
17259 temp2 = true;
17260 }
17261 {
17262 PyThreadState* __tstate = wxPyBeginAllowThreads();
17263 result = (bool)(arg1)->Create((wxString const &)*arg2);
17264 wxPyEndAllowThreads(__tstate);
17265 if (PyErr_Occurred()) SWIG_fail;
17266 }
17267 {
17268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17269 }
17270 {
17271 if (temp2)
17272 delete arg2;
17273 }
17274 return resultobj;
17275 fail:
17276 {
17277 if (temp2)
17278 delete arg2;
17279 }
17280 return NULL;
17281 }
17282
17283
17284 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17285 PyObject *resultobj = 0;
17286 wxSound *arg1 = (wxSound *) 0 ;
17287 PyObject *arg2 = (PyObject *) 0 ;
17288 bool result;
17289 void *argp1 = 0 ;
17290 int res1 = 0 ;
17291 PyObject * obj0 = 0 ;
17292 PyObject * obj1 = 0 ;
17293 char * kwnames[] = {
17294 (char *) "self",(char *) "data", NULL
17295 };
17296
17297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17299 if (!SWIG_IsOK(res1)) {
17300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17301 }
17302 arg1 = reinterpret_cast< wxSound * >(argp1);
17303 arg2 = obj1;
17304 {
17305 PyThreadState* __tstate = wxPyBeginAllowThreads();
17306 result = (bool)wxSound_CreateFromData(arg1,arg2);
17307 wxPyEndAllowThreads(__tstate);
17308 if (PyErr_Occurred()) SWIG_fail;
17309 }
17310 {
17311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17312 }
17313 return resultobj;
17314 fail:
17315 return NULL;
17316 }
17317
17318
17319 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 PyObject *resultobj = 0;
17321 wxSound *arg1 = (wxSound *) 0 ;
17322 bool result;
17323 void *argp1 = 0 ;
17324 int res1 = 0 ;
17325 PyObject *swig_obj[1] ;
17326
17327 if (!args) SWIG_fail;
17328 swig_obj[0] = args;
17329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17330 if (!SWIG_IsOK(res1)) {
17331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17332 }
17333 arg1 = reinterpret_cast< wxSound * >(argp1);
17334 {
17335 PyThreadState* __tstate = wxPyBeginAllowThreads();
17336 result = (bool)(arg1)->IsOk();
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 {
17341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17342 }
17343 return resultobj;
17344 fail:
17345 return NULL;
17346 }
17347
17348
17349 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17350 PyObject *resultobj = 0;
17351 wxSound *arg1 = (wxSound *) 0 ;
17352 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17353 bool result;
17354 void *argp1 = 0 ;
17355 int res1 = 0 ;
17356 unsigned int val2 ;
17357 int ecode2 = 0 ;
17358 PyObject * obj0 = 0 ;
17359 PyObject * obj1 = 0 ;
17360 char * kwnames[] = {
17361 (char *) "self",(char *) "flags", NULL
17362 };
17363
17364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17366 if (!SWIG_IsOK(res1)) {
17367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17368 }
17369 arg1 = reinterpret_cast< wxSound * >(argp1);
17370 if (obj1) {
17371 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17372 if (!SWIG_IsOK(ecode2)) {
17373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17374 }
17375 arg2 = static_cast< unsigned int >(val2);
17376 }
17377 {
17378 if (!wxPyCheckForApp()) SWIG_fail;
17379 PyThreadState* __tstate = wxPyBeginAllowThreads();
17380 result = (bool)((wxSound const *)arg1)->Play(arg2);
17381 wxPyEndAllowThreads(__tstate);
17382 if (PyErr_Occurred()) SWIG_fail;
17383 }
17384 {
17385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17386 }
17387 return resultobj;
17388 fail:
17389 return NULL;
17390 }
17391
17392
17393 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17394 PyObject *resultobj = 0;
17395 wxString *arg1 = 0 ;
17396 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17397 bool result;
17398 bool temp1 = false ;
17399 unsigned int val2 ;
17400 int ecode2 = 0 ;
17401 PyObject * obj0 = 0 ;
17402 PyObject * obj1 = 0 ;
17403 char * kwnames[] = {
17404 (char *) "filename",(char *) "flags", NULL
17405 };
17406
17407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17408 {
17409 arg1 = wxString_in_helper(obj0);
17410 if (arg1 == NULL) SWIG_fail;
17411 temp1 = true;
17412 }
17413 if (obj1) {
17414 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17415 if (!SWIG_IsOK(ecode2)) {
17416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17417 }
17418 arg2 = static_cast< unsigned int >(val2);
17419 }
17420 {
17421 if (!wxPyCheckForApp()) SWIG_fail;
17422 PyThreadState* __tstate = wxPyBeginAllowThreads();
17423 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17424 wxPyEndAllowThreads(__tstate);
17425 if (PyErr_Occurred()) SWIG_fail;
17426 }
17427 {
17428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17429 }
17430 {
17431 if (temp1)
17432 delete arg1;
17433 }
17434 return resultobj;
17435 fail:
17436 {
17437 if (temp1)
17438 delete arg1;
17439 }
17440 return NULL;
17441 }
17442
17443
17444 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17445 PyObject *resultobj = 0;
17446
17447 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17448 {
17449 if (!wxPyCheckForApp()) SWIG_fail;
17450 PyThreadState* __tstate = wxPyBeginAllowThreads();
17451 wxSound::Stop();
17452 wxPyEndAllowThreads(__tstate);
17453 if (PyErr_Occurred()) SWIG_fail;
17454 }
17455 resultobj = SWIG_Py_Void();
17456 return resultobj;
17457 fail:
17458 return NULL;
17459 }
17460
17461
17462 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *obj;
17464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17465 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17466 return SWIG_Py_Void();
17467 }
17468
17469 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 return SWIG_Python_InitShadowInstance(args);
17471 }
17472
17473 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17474 PyObject *resultobj = 0;
17475 wxString *arg1 = 0 ;
17476 wxString *arg2 = 0 ;
17477 wxString *arg3 = 0 ;
17478 wxString *arg4 = 0 ;
17479 wxFileTypeInfo *result = 0 ;
17480 bool temp1 = false ;
17481 bool temp2 = false ;
17482 bool temp3 = false ;
17483 bool temp4 = false ;
17484 PyObject * obj0 = 0 ;
17485 PyObject * obj1 = 0 ;
17486 PyObject * obj2 = 0 ;
17487 PyObject * obj3 = 0 ;
17488 char * kwnames[] = {
17489 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17490 };
17491
17492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17493 {
17494 arg1 = wxString_in_helper(obj0);
17495 if (arg1 == NULL) SWIG_fail;
17496 temp1 = true;
17497 }
17498 {
17499 arg2 = wxString_in_helper(obj1);
17500 if (arg2 == NULL) SWIG_fail;
17501 temp2 = true;
17502 }
17503 {
17504 arg3 = wxString_in_helper(obj2);
17505 if (arg3 == NULL) SWIG_fail;
17506 temp3 = true;
17507 }
17508 {
17509 arg4 = wxString_in_helper(obj3);
17510 if (arg4 == NULL) SWIG_fail;
17511 temp4 = true;
17512 }
17513 {
17514 PyThreadState* __tstate = wxPyBeginAllowThreads();
17515 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17516 wxPyEndAllowThreads(__tstate);
17517 if (PyErr_Occurred()) SWIG_fail;
17518 }
17519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17520 {
17521 if (temp1)
17522 delete arg1;
17523 }
17524 {
17525 if (temp2)
17526 delete arg2;
17527 }
17528 {
17529 if (temp3)
17530 delete arg3;
17531 }
17532 {
17533 if (temp4)
17534 delete arg4;
17535 }
17536 return resultobj;
17537 fail:
17538 {
17539 if (temp1)
17540 delete arg1;
17541 }
17542 {
17543 if (temp2)
17544 delete arg2;
17545 }
17546 {
17547 if (temp3)
17548 delete arg3;
17549 }
17550 {
17551 if (temp4)
17552 delete arg4;
17553 }
17554 return NULL;
17555 }
17556
17557
17558 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17559 PyObject *resultobj = 0;
17560 wxArrayString *arg1 = 0 ;
17561 wxFileTypeInfo *result = 0 ;
17562 bool temp1 = false ;
17563 PyObject * obj0 = 0 ;
17564 char * kwnames[] = {
17565 (char *) "sArray", NULL
17566 };
17567
17568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17569 {
17570 if (! PySequence_Check(obj0)) {
17571 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17572 SWIG_fail;
17573 }
17574 arg1 = new wxArrayString;
17575 temp1 = true;
17576 int i, len=PySequence_Length(obj0);
17577 for (i=0; i<len; i++) {
17578 PyObject* item = PySequence_GetItem(obj0, i);
17579 wxString* s = wxString_in_helper(item);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 arg1->Add(*s);
17582 delete s;
17583 Py_DECREF(item);
17584 }
17585 }
17586 {
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17589 wxPyEndAllowThreads(__tstate);
17590 if (PyErr_Occurred()) SWIG_fail;
17591 }
17592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17593 {
17594 if (temp1) delete arg1;
17595 }
17596 return resultobj;
17597 fail:
17598 {
17599 if (temp1) delete arg1;
17600 }
17601 return NULL;
17602 }
17603
17604
17605 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17606 PyObject *resultobj = 0;
17607 wxFileTypeInfo *result = 0 ;
17608
17609 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17617 return resultobj;
17618 fail:
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17624 PyObject *resultobj = 0;
17625 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17626 bool result;
17627 void *argp1 = 0 ;
17628 int res1 = 0 ;
17629 PyObject *swig_obj[1] ;
17630
17631 if (!args) SWIG_fail;
17632 swig_obj[0] = args;
17633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17634 if (!SWIG_IsOK(res1)) {
17635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17636 }
17637 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 {
17645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj = 0;
17655 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17656 wxString *arg2 = 0 ;
17657 int arg3 = (int) 0 ;
17658 void *argp1 = 0 ;
17659 int res1 = 0 ;
17660 bool temp2 = false ;
17661 int val3 ;
17662 int ecode3 = 0 ;
17663 PyObject * obj0 = 0 ;
17664 PyObject * obj1 = 0 ;
17665 PyObject * obj2 = 0 ;
17666 char * kwnames[] = {
17667 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17668 };
17669
17670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17672 if (!SWIG_IsOK(res1)) {
17673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17674 }
17675 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17676 {
17677 arg2 = wxString_in_helper(obj1);
17678 if (arg2 == NULL) SWIG_fail;
17679 temp2 = true;
17680 }
17681 if (obj2) {
17682 ecode3 = SWIG_AsVal_int(obj2, &val3);
17683 if (!SWIG_IsOK(ecode3)) {
17684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17685 }
17686 arg3 = static_cast< int >(val3);
17687 }
17688 {
17689 PyThreadState* __tstate = wxPyBeginAllowThreads();
17690 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 resultobj = SWIG_Py_Void();
17695 {
17696 if (temp2)
17697 delete arg2;
17698 }
17699 return resultobj;
17700 fail:
17701 {
17702 if (temp2)
17703 delete arg2;
17704 }
17705 return NULL;
17706 }
17707
17708
17709 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17710 PyObject *resultobj = 0;
17711 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17712 wxString *arg2 = 0 ;
17713 void *argp1 = 0 ;
17714 int res1 = 0 ;
17715 bool temp2 = false ;
17716 PyObject * obj0 = 0 ;
17717 PyObject * obj1 = 0 ;
17718 char * kwnames[] = {
17719 (char *) "self",(char *) "shortDesc", NULL
17720 };
17721
17722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17724 if (!SWIG_IsOK(res1)) {
17725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17726 }
17727 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17728 {
17729 arg2 = wxString_in_helper(obj1);
17730 if (arg2 == NULL) SWIG_fail;
17731 temp2 = true;
17732 }
17733 {
17734 PyThreadState* __tstate = wxPyBeginAllowThreads();
17735 (arg1)->SetShortDesc((wxString const &)*arg2);
17736 wxPyEndAllowThreads(__tstate);
17737 if (PyErr_Occurred()) SWIG_fail;
17738 }
17739 resultobj = SWIG_Py_Void();
17740 {
17741 if (temp2)
17742 delete arg2;
17743 }
17744 return resultobj;
17745 fail:
17746 {
17747 if (temp2)
17748 delete arg2;
17749 }
17750 return NULL;
17751 }
17752
17753
17754 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17755 PyObject *resultobj = 0;
17756 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17757 wxString *result = 0 ;
17758 void *argp1 = 0 ;
17759 int res1 = 0 ;
17760 PyObject *swig_obj[1] ;
17761
17762 if (!args) SWIG_fail;
17763 swig_obj[0] = args;
17764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17765 if (!SWIG_IsOK(res1)) {
17766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17767 }
17768 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17769 {
17770 PyThreadState* __tstate = wxPyBeginAllowThreads();
17771 {
17772 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17773 result = (wxString *) &_result_ref;
17774 }
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 {
17779 #if wxUSE_UNICODE
17780 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17781 #else
17782 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17783 #endif
17784 }
17785 return resultobj;
17786 fail:
17787 return NULL;
17788 }
17789
17790
17791 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17792 PyObject *resultobj = 0;
17793 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17794 wxString *result = 0 ;
17795 void *argp1 = 0 ;
17796 int res1 = 0 ;
17797 PyObject *swig_obj[1] ;
17798
17799 if (!args) SWIG_fail;
17800 swig_obj[0] = args;
17801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17802 if (!SWIG_IsOK(res1)) {
17803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17804 }
17805 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17806 {
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 {
17809 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17810 result = (wxString *) &_result_ref;
17811 }
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 {
17816 #if wxUSE_UNICODE
17817 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17818 #else
17819 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17820 #endif
17821 }
17822 return resultobj;
17823 fail:
17824 return NULL;
17825 }
17826
17827
17828 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17829 PyObject *resultobj = 0;
17830 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17831 wxString *result = 0 ;
17832 void *argp1 = 0 ;
17833 int res1 = 0 ;
17834 PyObject *swig_obj[1] ;
17835
17836 if (!args) SWIG_fail;
17837 swig_obj[0] = args;
17838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17839 if (!SWIG_IsOK(res1)) {
17840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17841 }
17842 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17843 {
17844 PyThreadState* __tstate = wxPyBeginAllowThreads();
17845 {
17846 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17847 result = (wxString *) &_result_ref;
17848 }
17849 wxPyEndAllowThreads(__tstate);
17850 if (PyErr_Occurred()) SWIG_fail;
17851 }
17852 {
17853 #if wxUSE_UNICODE
17854 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17855 #else
17856 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17857 #endif
17858 }
17859 return resultobj;
17860 fail:
17861 return NULL;
17862 }
17863
17864
17865 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17866 PyObject *resultobj = 0;
17867 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17868 wxString *result = 0 ;
17869 void *argp1 = 0 ;
17870 int res1 = 0 ;
17871 PyObject *swig_obj[1] ;
17872
17873 if (!args) SWIG_fail;
17874 swig_obj[0] = args;
17875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17876 if (!SWIG_IsOK(res1)) {
17877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17878 }
17879 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17880 {
17881 PyThreadState* __tstate = wxPyBeginAllowThreads();
17882 {
17883 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17884 result = (wxString *) &_result_ref;
17885 }
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 {
17890 #if wxUSE_UNICODE
17891 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17892 #else
17893 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17894 #endif
17895 }
17896 return resultobj;
17897 fail:
17898 return NULL;
17899 }
17900
17901
17902 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17903 PyObject *resultobj = 0;
17904 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17905 wxString *result = 0 ;
17906 void *argp1 = 0 ;
17907 int res1 = 0 ;
17908 PyObject *swig_obj[1] ;
17909
17910 if (!args) SWIG_fail;
17911 swig_obj[0] = args;
17912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17913 if (!SWIG_IsOK(res1)) {
17914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17915 }
17916 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 {
17920 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17921 result = (wxString *) &_result_ref;
17922 }
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 {
17927 #if wxUSE_UNICODE
17928 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17929 #else
17930 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17931 #endif
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17940 PyObject *resultobj = 0;
17941 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17942 wxArrayString *result = 0 ;
17943 void *argp1 = 0 ;
17944 int res1 = 0 ;
17945 PyObject *swig_obj[1] ;
17946
17947 if (!args) SWIG_fail;
17948 swig_obj[0] = args;
17949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17950 if (!SWIG_IsOK(res1)) {
17951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17952 }
17953 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17954 {
17955 PyThreadState* __tstate = wxPyBeginAllowThreads();
17956 {
17957 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17958 result = (wxArrayString *) &_result_ref;
17959 }
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 {
17964 resultobj = wxArrayString2PyList_helper(*result);
17965 }
17966 return resultobj;
17967 fail:
17968 return NULL;
17969 }
17970
17971
17972 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17973 PyObject *resultobj = 0;
17974 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17975 size_t result;
17976 void *argp1 = 0 ;
17977 int res1 = 0 ;
17978 PyObject *swig_obj[1] ;
17979
17980 if (!args) SWIG_fail;
17981 swig_obj[0] = args;
17982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17983 if (!SWIG_IsOK(res1)) {
17984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17985 }
17986 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17987 {
17988 PyThreadState* __tstate = wxPyBeginAllowThreads();
17989 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17994 return resultobj;
17995 fail:
17996 return NULL;
17997 }
17998
17999
18000 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18001 PyObject *resultobj = 0;
18002 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18003 wxString *result = 0 ;
18004 void *argp1 = 0 ;
18005 int res1 = 0 ;
18006 PyObject *swig_obj[1] ;
18007
18008 if (!args) SWIG_fail;
18009 swig_obj[0] = args;
18010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18011 if (!SWIG_IsOK(res1)) {
18012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18013 }
18014 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18015 {
18016 PyThreadState* __tstate = wxPyBeginAllowThreads();
18017 {
18018 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18019 result = (wxString *) &_result_ref;
18020 }
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 {
18025 #if wxUSE_UNICODE
18026 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18027 #else
18028 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18029 #endif
18030 }
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18038 PyObject *resultobj = 0;
18039 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18040 int result;
18041 void *argp1 = 0 ;
18042 int res1 = 0 ;
18043 PyObject *swig_obj[1] ;
18044
18045 if (!args) SWIG_fail;
18046 swig_obj[0] = args;
18047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18048 if (!SWIG_IsOK(res1)) {
18049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18050 }
18051 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18052 {
18053 PyThreadState* __tstate = wxPyBeginAllowThreads();
18054 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 resultobj = SWIG_From_int(static_cast< int >(result));
18059 return resultobj;
18060 fail:
18061 return NULL;
18062 }
18063
18064
18065 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18066 PyObject *obj;
18067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18068 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18069 return SWIG_Py_Void();
18070 }
18071
18072 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18073 return SWIG_Python_InitShadowInstance(args);
18074 }
18075
18076 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18077 PyObject *resultobj = 0;
18078 wxFileTypeInfo *arg1 = 0 ;
18079 wxFileType *result = 0 ;
18080 void *argp1 = 0 ;
18081 int res1 = 0 ;
18082 PyObject * obj0 = 0 ;
18083 char * kwnames[] = {
18084 (char *) "ftInfo", NULL
18085 };
18086
18087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18088 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18089 if (!SWIG_IsOK(res1)) {
18090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18091 }
18092 if (!argp1) {
18093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18094 }
18095 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18096 {
18097 PyThreadState* __tstate = wxPyBeginAllowThreads();
18098 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18099 wxPyEndAllowThreads(__tstate);
18100 if (PyErr_Occurred()) SWIG_fail;
18101 }
18102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18110 PyObject *resultobj = 0;
18111 wxFileType *arg1 = (wxFileType *) 0 ;
18112 void *argp1 = 0 ;
18113 int res1 = 0 ;
18114 PyObject *swig_obj[1] ;
18115
18116 if (!args) SWIG_fail;
18117 swig_obj[0] = args;
18118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18119 if (!SWIG_IsOK(res1)) {
18120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18121 }
18122 arg1 = reinterpret_cast< wxFileType * >(argp1);
18123 {
18124 PyThreadState* __tstate = wxPyBeginAllowThreads();
18125 delete arg1;
18126
18127 wxPyEndAllowThreads(__tstate);
18128 if (PyErr_Occurred()) SWIG_fail;
18129 }
18130 resultobj = SWIG_Py_Void();
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18138 PyObject *resultobj = 0;
18139 wxFileType *arg1 = (wxFileType *) 0 ;
18140 PyObject *result = 0 ;
18141 void *argp1 = 0 ;
18142 int res1 = 0 ;
18143 PyObject *swig_obj[1] ;
18144
18145 if (!args) SWIG_fail;
18146 swig_obj[0] = args;
18147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18148 if (!SWIG_IsOK(res1)) {
18149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18150 }
18151 arg1 = reinterpret_cast< wxFileType * >(argp1);
18152 {
18153 PyThreadState* __tstate = wxPyBeginAllowThreads();
18154 result = (PyObject *)wxFileType_GetMimeType(arg1);
18155 wxPyEndAllowThreads(__tstate);
18156 if (PyErr_Occurred()) SWIG_fail;
18157 }
18158 resultobj = result;
18159 return resultobj;
18160 fail:
18161 return NULL;
18162 }
18163
18164
18165 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18166 PyObject *resultobj = 0;
18167 wxFileType *arg1 = (wxFileType *) 0 ;
18168 PyObject *result = 0 ;
18169 void *argp1 = 0 ;
18170 int res1 = 0 ;
18171 PyObject *swig_obj[1] ;
18172
18173 if (!args) SWIG_fail;
18174 swig_obj[0] = args;
18175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18176 if (!SWIG_IsOK(res1)) {
18177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18178 }
18179 arg1 = reinterpret_cast< wxFileType * >(argp1);
18180 {
18181 PyThreadState* __tstate = wxPyBeginAllowThreads();
18182 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18183 wxPyEndAllowThreads(__tstate);
18184 if (PyErr_Occurred()) SWIG_fail;
18185 }
18186 resultobj = result;
18187 return resultobj;
18188 fail:
18189 return NULL;
18190 }
18191
18192
18193 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18194 PyObject *resultobj = 0;
18195 wxFileType *arg1 = (wxFileType *) 0 ;
18196 PyObject *result = 0 ;
18197 void *argp1 = 0 ;
18198 int res1 = 0 ;
18199 PyObject *swig_obj[1] ;
18200
18201 if (!args) SWIG_fail;
18202 swig_obj[0] = args;
18203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18204 if (!SWIG_IsOK(res1)) {
18205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18206 }
18207 arg1 = reinterpret_cast< wxFileType * >(argp1);
18208 {
18209 PyThreadState* __tstate = wxPyBeginAllowThreads();
18210 result = (PyObject *)wxFileType_GetExtensions(arg1);
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 resultobj = result;
18215 return resultobj;
18216 fail:
18217 return NULL;
18218 }
18219
18220
18221 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18222 PyObject *resultobj = 0;
18223 wxFileType *arg1 = (wxFileType *) 0 ;
18224 wxIcon *result = 0 ;
18225 void *argp1 = 0 ;
18226 int res1 = 0 ;
18227 PyObject *swig_obj[1] ;
18228
18229 if (!args) SWIG_fail;
18230 swig_obj[0] = args;
18231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18232 if (!SWIG_IsOK(res1)) {
18233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18234 }
18235 arg1 = reinterpret_cast< wxFileType * >(argp1);
18236 {
18237 PyThreadState* __tstate = wxPyBeginAllowThreads();
18238 result = (wxIcon *)wxFileType_GetIcon(arg1);
18239 wxPyEndAllowThreads(__tstate);
18240 if (PyErr_Occurred()) SWIG_fail;
18241 }
18242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18243 return resultobj;
18244 fail:
18245 return NULL;
18246 }
18247
18248
18249 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18250 PyObject *resultobj = 0;
18251 wxFileType *arg1 = (wxFileType *) 0 ;
18252 PyObject *result = 0 ;
18253 void *argp1 = 0 ;
18254 int res1 = 0 ;
18255 PyObject *swig_obj[1] ;
18256
18257 if (!args) SWIG_fail;
18258 swig_obj[0] = args;
18259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18260 if (!SWIG_IsOK(res1)) {
18261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18262 }
18263 arg1 = reinterpret_cast< wxFileType * >(argp1);
18264 {
18265 PyThreadState* __tstate = wxPyBeginAllowThreads();
18266 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 resultobj = result;
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18278 PyObject *resultobj = 0;
18279 wxFileType *arg1 = (wxFileType *) 0 ;
18280 PyObject *result = 0 ;
18281 void *argp1 = 0 ;
18282 int res1 = 0 ;
18283 PyObject *swig_obj[1] ;
18284
18285 if (!args) SWIG_fail;
18286 swig_obj[0] = args;
18287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18288 if (!SWIG_IsOK(res1)) {
18289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18290 }
18291 arg1 = reinterpret_cast< wxFileType * >(argp1);
18292 {
18293 PyThreadState* __tstate = wxPyBeginAllowThreads();
18294 result = (PyObject *)wxFileType_GetDescription(arg1);
18295 wxPyEndAllowThreads(__tstate);
18296 if (PyErr_Occurred()) SWIG_fail;
18297 }
18298 resultobj = result;
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj = 0;
18307 wxFileType *arg1 = (wxFileType *) 0 ;
18308 wxString *arg2 = 0 ;
18309 wxString const &arg3_defvalue = wxPyEmptyString ;
18310 wxString *arg3 = (wxString *) &arg3_defvalue ;
18311 PyObject *result = 0 ;
18312 void *argp1 = 0 ;
18313 int res1 = 0 ;
18314 bool temp2 = false ;
18315 bool temp3 = false ;
18316 PyObject * obj0 = 0 ;
18317 PyObject * obj1 = 0 ;
18318 PyObject * obj2 = 0 ;
18319 char * kwnames[] = {
18320 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18321 };
18322
18323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18325 if (!SWIG_IsOK(res1)) {
18326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18327 }
18328 arg1 = reinterpret_cast< wxFileType * >(argp1);
18329 {
18330 arg2 = wxString_in_helper(obj1);
18331 if (arg2 == NULL) SWIG_fail;
18332 temp2 = true;
18333 }
18334 if (obj2) {
18335 {
18336 arg3 = wxString_in_helper(obj2);
18337 if (arg3 == NULL) SWIG_fail;
18338 temp3 = true;
18339 }
18340 }
18341 {
18342 PyThreadState* __tstate = wxPyBeginAllowThreads();
18343 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18344 wxPyEndAllowThreads(__tstate);
18345 if (PyErr_Occurred()) SWIG_fail;
18346 }
18347 resultobj = result;
18348 {
18349 if (temp2)
18350 delete arg2;
18351 }
18352 {
18353 if (temp3)
18354 delete arg3;
18355 }
18356 return resultobj;
18357 fail:
18358 {
18359 if (temp2)
18360 delete arg2;
18361 }
18362 {
18363 if (temp3)
18364 delete arg3;
18365 }
18366 return NULL;
18367 }
18368
18369
18370 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18371 PyObject *resultobj = 0;
18372 wxFileType *arg1 = (wxFileType *) 0 ;
18373 wxString *arg2 = 0 ;
18374 wxString const &arg3_defvalue = wxPyEmptyString ;
18375 wxString *arg3 = (wxString *) &arg3_defvalue ;
18376 PyObject *result = 0 ;
18377 void *argp1 = 0 ;
18378 int res1 = 0 ;
18379 bool temp2 = false ;
18380 bool temp3 = false ;
18381 PyObject * obj0 = 0 ;
18382 PyObject * obj1 = 0 ;
18383 PyObject * obj2 = 0 ;
18384 char * kwnames[] = {
18385 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18386 };
18387
18388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18390 if (!SWIG_IsOK(res1)) {
18391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18392 }
18393 arg1 = reinterpret_cast< wxFileType * >(argp1);
18394 {
18395 arg2 = wxString_in_helper(obj1);
18396 if (arg2 == NULL) SWIG_fail;
18397 temp2 = true;
18398 }
18399 if (obj2) {
18400 {
18401 arg3 = wxString_in_helper(obj2);
18402 if (arg3 == NULL) SWIG_fail;
18403 temp3 = true;
18404 }
18405 }
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18409 wxPyEndAllowThreads(__tstate);
18410 if (PyErr_Occurred()) SWIG_fail;
18411 }
18412 resultobj = result;
18413 {
18414 if (temp2)
18415 delete arg2;
18416 }
18417 {
18418 if (temp3)
18419 delete arg3;
18420 }
18421 return resultobj;
18422 fail:
18423 {
18424 if (temp2)
18425 delete arg2;
18426 }
18427 {
18428 if (temp3)
18429 delete arg3;
18430 }
18431 return NULL;
18432 }
18433
18434
18435 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18436 PyObject *resultobj = 0;
18437 wxFileType *arg1 = (wxFileType *) 0 ;
18438 wxString *arg2 = 0 ;
18439 wxString const &arg3_defvalue = wxPyEmptyString ;
18440 wxString *arg3 = (wxString *) &arg3_defvalue ;
18441 PyObject *result = 0 ;
18442 void *argp1 = 0 ;
18443 int res1 = 0 ;
18444 bool temp2 = false ;
18445 bool temp3 = false ;
18446 PyObject * obj0 = 0 ;
18447 PyObject * obj1 = 0 ;
18448 PyObject * obj2 = 0 ;
18449 char * kwnames[] = {
18450 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18451 };
18452
18453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18455 if (!SWIG_IsOK(res1)) {
18456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18457 }
18458 arg1 = reinterpret_cast< wxFileType * >(argp1);
18459 {
18460 arg2 = wxString_in_helper(obj1);
18461 if (arg2 == NULL) SWIG_fail;
18462 temp2 = true;
18463 }
18464 if (obj2) {
18465 {
18466 arg3 = wxString_in_helper(obj2);
18467 if (arg3 == NULL) SWIG_fail;
18468 temp3 = true;
18469 }
18470 }
18471 {
18472 PyThreadState* __tstate = wxPyBeginAllowThreads();
18473 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18474 wxPyEndAllowThreads(__tstate);
18475 if (PyErr_Occurred()) SWIG_fail;
18476 }
18477 resultobj = result;
18478 {
18479 if (temp2)
18480 delete arg2;
18481 }
18482 {
18483 if (temp3)
18484 delete arg3;
18485 }
18486 return resultobj;
18487 fail:
18488 {
18489 if (temp2)
18490 delete arg2;
18491 }
18492 {
18493 if (temp3)
18494 delete arg3;
18495 }
18496 return NULL;
18497 }
18498
18499
18500 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18501 PyObject *resultobj = 0;
18502 wxFileType *arg1 = (wxFileType *) 0 ;
18503 wxString *arg2 = 0 ;
18504 wxString *arg3 = 0 ;
18505 bool arg4 = (bool) true ;
18506 bool result;
18507 void *argp1 = 0 ;
18508 int res1 = 0 ;
18509 bool temp2 = false ;
18510 bool temp3 = false ;
18511 bool val4 ;
18512 int ecode4 = 0 ;
18513 PyObject * obj0 = 0 ;
18514 PyObject * obj1 = 0 ;
18515 PyObject * obj2 = 0 ;
18516 PyObject * obj3 = 0 ;
18517 char * kwnames[] = {
18518 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18519 };
18520
18521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18523 if (!SWIG_IsOK(res1)) {
18524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18525 }
18526 arg1 = reinterpret_cast< wxFileType * >(argp1);
18527 {
18528 arg2 = wxString_in_helper(obj1);
18529 if (arg2 == NULL) SWIG_fail;
18530 temp2 = true;
18531 }
18532 {
18533 arg3 = wxString_in_helper(obj2);
18534 if (arg3 == NULL) SWIG_fail;
18535 temp3 = true;
18536 }
18537 if (obj3) {
18538 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18539 if (!SWIG_IsOK(ecode4)) {
18540 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18541 }
18542 arg4 = static_cast< bool >(val4);
18543 }
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18547 wxPyEndAllowThreads(__tstate);
18548 if (PyErr_Occurred()) SWIG_fail;
18549 }
18550 {
18551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18552 }
18553 {
18554 if (temp2)
18555 delete arg2;
18556 }
18557 {
18558 if (temp3)
18559 delete arg3;
18560 }
18561 return resultobj;
18562 fail:
18563 {
18564 if (temp2)
18565 delete arg2;
18566 }
18567 {
18568 if (temp3)
18569 delete arg3;
18570 }
18571 return NULL;
18572 }
18573
18574
18575 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18576 PyObject *resultobj = 0;
18577 wxFileType *arg1 = (wxFileType *) 0 ;
18578 wxString const &arg2_defvalue = wxPyEmptyString ;
18579 wxString *arg2 = (wxString *) &arg2_defvalue ;
18580 int arg3 = (int) 0 ;
18581 bool result;
18582 void *argp1 = 0 ;
18583 int res1 = 0 ;
18584 bool temp2 = false ;
18585 int val3 ;
18586 int ecode3 = 0 ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 PyObject * obj2 = 0 ;
18590 char * kwnames[] = {
18591 (char *) "self",(char *) "cmd",(char *) "index", NULL
18592 };
18593
18594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18596 if (!SWIG_IsOK(res1)) {
18597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18598 }
18599 arg1 = reinterpret_cast< wxFileType * >(argp1);
18600 if (obj1) {
18601 {
18602 arg2 = wxString_in_helper(obj1);
18603 if (arg2 == NULL) SWIG_fail;
18604 temp2 = true;
18605 }
18606 }
18607 if (obj2) {
18608 ecode3 = SWIG_AsVal_int(obj2, &val3);
18609 if (!SWIG_IsOK(ecode3)) {
18610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18611 }
18612 arg3 = static_cast< int >(val3);
18613 }
18614 {
18615 PyThreadState* __tstate = wxPyBeginAllowThreads();
18616 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 {
18621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18622 }
18623 {
18624 if (temp2)
18625 delete arg2;
18626 }
18627 return resultobj;
18628 fail:
18629 {
18630 if (temp2)
18631 delete arg2;
18632 }
18633 return NULL;
18634 }
18635
18636
18637 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18638 PyObject *resultobj = 0;
18639 wxFileType *arg1 = (wxFileType *) 0 ;
18640 bool result;
18641 void *argp1 = 0 ;
18642 int res1 = 0 ;
18643 PyObject *swig_obj[1] ;
18644
18645 if (!args) SWIG_fail;
18646 swig_obj[0] = args;
18647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18648 if (!SWIG_IsOK(res1)) {
18649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18650 }
18651 arg1 = reinterpret_cast< wxFileType * >(argp1);
18652 {
18653 PyThreadState* __tstate = wxPyBeginAllowThreads();
18654 result = (bool)(arg1)->Unassociate();
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 {
18659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18660 }
18661 return resultobj;
18662 fail:
18663 return NULL;
18664 }
18665
18666
18667 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18668 PyObject *resultobj = 0;
18669 wxString *arg1 = 0 ;
18670 wxString *arg2 = 0 ;
18671 wxString const &arg3_defvalue = wxPyEmptyString ;
18672 wxString *arg3 = (wxString *) &arg3_defvalue ;
18673 wxString result;
18674 bool temp1 = false ;
18675 bool temp2 = false ;
18676 bool temp3 = false ;
18677 PyObject * obj0 = 0 ;
18678 PyObject * obj1 = 0 ;
18679 PyObject * obj2 = 0 ;
18680 char * kwnames[] = {
18681 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18682 };
18683
18684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18685 {
18686 arg1 = wxString_in_helper(obj0);
18687 if (arg1 == NULL) SWIG_fail;
18688 temp1 = true;
18689 }
18690 {
18691 arg2 = wxString_in_helper(obj1);
18692 if (arg2 == NULL) SWIG_fail;
18693 temp2 = true;
18694 }
18695 if (obj2) {
18696 {
18697 arg3 = wxString_in_helper(obj2);
18698 if (arg3 == NULL) SWIG_fail;
18699 temp3 = true;
18700 }
18701 }
18702 {
18703 PyThreadState* __tstate = wxPyBeginAllowThreads();
18704 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18705 wxPyEndAllowThreads(__tstate);
18706 if (PyErr_Occurred()) SWIG_fail;
18707 }
18708 {
18709 #if wxUSE_UNICODE
18710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18711 #else
18712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18713 #endif
18714 }
18715 {
18716 if (temp1)
18717 delete arg1;
18718 }
18719 {
18720 if (temp2)
18721 delete arg2;
18722 }
18723 {
18724 if (temp3)
18725 delete arg3;
18726 }
18727 return resultobj;
18728 fail:
18729 {
18730 if (temp1)
18731 delete arg1;
18732 }
18733 {
18734 if (temp2)
18735 delete arg2;
18736 }
18737 {
18738 if (temp3)
18739 delete arg3;
18740 }
18741 return NULL;
18742 }
18743
18744
18745 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18746 PyObject *obj;
18747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18748 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18749 return SWIG_Py_Void();
18750 }
18751
18752 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18753 return SWIG_Python_InitShadowInstance(args);
18754 }
18755
18756 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18757 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18758 return 1;
18759 }
18760
18761
18762 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18763 PyObject *pyobj = 0;
18764
18765 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18766 return pyobj;
18767 }
18768
18769
18770 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18771 PyObject *resultobj = 0;
18772 wxString *arg1 = 0 ;
18773 wxString *arg2 = 0 ;
18774 bool result;
18775 bool temp1 = false ;
18776 bool temp2 = false ;
18777 PyObject * obj0 = 0 ;
18778 PyObject * obj1 = 0 ;
18779 char * kwnames[] = {
18780 (char *) "mimeType",(char *) "wildcard", NULL
18781 };
18782
18783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18784 {
18785 arg1 = wxString_in_helper(obj0);
18786 if (arg1 == NULL) SWIG_fail;
18787 temp1 = true;
18788 }
18789 {
18790 arg2 = wxString_in_helper(obj1);
18791 if (arg2 == NULL) SWIG_fail;
18792 temp2 = true;
18793 }
18794 {
18795 PyThreadState* __tstate = wxPyBeginAllowThreads();
18796 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18797 wxPyEndAllowThreads(__tstate);
18798 if (PyErr_Occurred()) SWIG_fail;
18799 }
18800 {
18801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18802 }
18803 {
18804 if (temp1)
18805 delete arg1;
18806 }
18807 {
18808 if (temp2)
18809 delete arg2;
18810 }
18811 return resultobj;
18812 fail:
18813 {
18814 if (temp1)
18815 delete arg1;
18816 }
18817 {
18818 if (temp2)
18819 delete arg2;
18820 }
18821 return NULL;
18822 }
18823
18824
18825 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18826 PyObject *resultobj = 0;
18827 wxMimeTypesManager *result = 0 ;
18828
18829 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18846 int arg2 = (int) wxMAILCAP_ALL ;
18847 wxString const &arg3_defvalue = wxPyEmptyString ;
18848 wxString *arg3 = (wxString *) &arg3_defvalue ;
18849 void *argp1 = 0 ;
18850 int res1 = 0 ;
18851 int val2 ;
18852 int ecode2 = 0 ;
18853 bool temp3 = false ;
18854 PyObject * obj0 = 0 ;
18855 PyObject * obj1 = 0 ;
18856 PyObject * obj2 = 0 ;
18857 char * kwnames[] = {
18858 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18859 };
18860
18861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18863 if (!SWIG_IsOK(res1)) {
18864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18865 }
18866 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18867 if (obj1) {
18868 ecode2 = SWIG_AsVal_int(obj1, &val2);
18869 if (!SWIG_IsOK(ecode2)) {
18870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18871 }
18872 arg2 = static_cast< int >(val2);
18873 }
18874 if (obj2) {
18875 {
18876 arg3 = wxString_in_helper(obj2);
18877 if (arg3 == NULL) SWIG_fail;
18878 temp3 = true;
18879 }
18880 }
18881 {
18882 PyThreadState* __tstate = wxPyBeginAllowThreads();
18883 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18884 wxPyEndAllowThreads(__tstate);
18885 if (PyErr_Occurred()) SWIG_fail;
18886 }
18887 resultobj = SWIG_Py_Void();
18888 {
18889 if (temp3)
18890 delete arg3;
18891 }
18892 return resultobj;
18893 fail:
18894 {
18895 if (temp3)
18896 delete arg3;
18897 }
18898 return NULL;
18899 }
18900
18901
18902 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18903 PyObject *resultobj = 0;
18904 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18905 void *argp1 = 0 ;
18906 int res1 = 0 ;
18907 PyObject *swig_obj[1] ;
18908
18909 if (!args) SWIG_fail;
18910 swig_obj[0] = args;
18911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18912 if (!SWIG_IsOK(res1)) {
18913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18914 }
18915 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18916 {
18917 PyThreadState* __tstate = wxPyBeginAllowThreads();
18918 (arg1)->ClearData();
18919 wxPyEndAllowThreads(__tstate);
18920 if (PyErr_Occurred()) SWIG_fail;
18921 }
18922 resultobj = SWIG_Py_Void();
18923 return resultobj;
18924 fail:
18925 return NULL;
18926 }
18927
18928
18929 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18930 PyObject *resultobj = 0;
18931 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18932 wxString *arg2 = 0 ;
18933 wxFileType *result = 0 ;
18934 void *argp1 = 0 ;
18935 int res1 = 0 ;
18936 bool temp2 = false ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 char * kwnames[] = {
18940 (char *) "self",(char *) "ext", NULL
18941 };
18942
18943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18945 if (!SWIG_IsOK(res1)) {
18946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18947 }
18948 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18949 {
18950 arg2 = wxString_in_helper(obj1);
18951 if (arg2 == NULL) SWIG_fail;
18952 temp2 = true;
18953 }
18954 {
18955 PyThreadState* __tstate = wxPyBeginAllowThreads();
18956 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18957 wxPyEndAllowThreads(__tstate);
18958 if (PyErr_Occurred()) SWIG_fail;
18959 }
18960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18961 {
18962 if (temp2)
18963 delete arg2;
18964 }
18965 return resultobj;
18966 fail:
18967 {
18968 if (temp2)
18969 delete arg2;
18970 }
18971 return NULL;
18972 }
18973
18974
18975 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj = 0;
18977 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18978 wxString *arg2 = 0 ;
18979 wxFileType *result = 0 ;
18980 void *argp1 = 0 ;
18981 int res1 = 0 ;
18982 bool temp2 = false ;
18983 PyObject * obj0 = 0 ;
18984 PyObject * obj1 = 0 ;
18985 char * kwnames[] = {
18986 (char *) "self",(char *) "mimeType", NULL
18987 };
18988
18989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18991 if (!SWIG_IsOK(res1)) {
18992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18993 }
18994 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18995 {
18996 arg2 = wxString_in_helper(obj1);
18997 if (arg2 == NULL) SWIG_fail;
18998 temp2 = true;
18999 }
19000 {
19001 PyThreadState* __tstate = wxPyBeginAllowThreads();
19002 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19003 wxPyEndAllowThreads(__tstate);
19004 if (PyErr_Occurred()) SWIG_fail;
19005 }
19006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19007 {
19008 if (temp2)
19009 delete arg2;
19010 }
19011 return resultobj;
19012 fail:
19013 {
19014 if (temp2)
19015 delete arg2;
19016 }
19017 return NULL;
19018 }
19019
19020
19021 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19022 PyObject *resultobj = 0;
19023 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19024 wxString *arg2 = 0 ;
19025 bool arg3 = (bool) false ;
19026 bool result;
19027 void *argp1 = 0 ;
19028 int res1 = 0 ;
19029 bool temp2 = false ;
19030 bool val3 ;
19031 int ecode3 = 0 ;
19032 PyObject * obj0 = 0 ;
19033 PyObject * obj1 = 0 ;
19034 PyObject * obj2 = 0 ;
19035 char * kwnames[] = {
19036 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19037 };
19038
19039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19041 if (!SWIG_IsOK(res1)) {
19042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19043 }
19044 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19045 {
19046 arg2 = wxString_in_helper(obj1);
19047 if (arg2 == NULL) SWIG_fail;
19048 temp2 = true;
19049 }
19050 if (obj2) {
19051 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19052 if (!SWIG_IsOK(ecode3)) {
19053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19054 }
19055 arg3 = static_cast< bool >(val3);
19056 }
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19060 wxPyEndAllowThreads(__tstate);
19061 if (PyErr_Occurred()) SWIG_fail;
19062 }
19063 {
19064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19065 }
19066 {
19067 if (temp2)
19068 delete arg2;
19069 }
19070 return resultobj;
19071 fail:
19072 {
19073 if (temp2)
19074 delete arg2;
19075 }
19076 return NULL;
19077 }
19078
19079
19080 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19081 PyObject *resultobj = 0;
19082 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19083 wxString *arg2 = 0 ;
19084 bool result;
19085 void *argp1 = 0 ;
19086 int res1 = 0 ;
19087 bool temp2 = false ;
19088 PyObject * obj0 = 0 ;
19089 PyObject * obj1 = 0 ;
19090 char * kwnames[] = {
19091 (char *) "self",(char *) "filename", NULL
19092 };
19093
19094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19096 if (!SWIG_IsOK(res1)) {
19097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19098 }
19099 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19100 {
19101 arg2 = wxString_in_helper(obj1);
19102 if (arg2 == NULL) SWIG_fail;
19103 temp2 = true;
19104 }
19105 {
19106 PyThreadState* __tstate = wxPyBeginAllowThreads();
19107 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19108 wxPyEndAllowThreads(__tstate);
19109 if (PyErr_Occurred()) SWIG_fail;
19110 }
19111 {
19112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19113 }
19114 {
19115 if (temp2)
19116 delete arg2;
19117 }
19118 return resultobj;
19119 fail:
19120 {
19121 if (temp2)
19122 delete arg2;
19123 }
19124 return NULL;
19125 }
19126
19127
19128 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19129 PyObject *resultobj = 0;
19130 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19131 PyObject *result = 0 ;
19132 void *argp1 = 0 ;
19133 int res1 = 0 ;
19134 PyObject *swig_obj[1] ;
19135
19136 if (!args) SWIG_fail;
19137 swig_obj[0] = args;
19138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19139 if (!SWIG_IsOK(res1)) {
19140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19141 }
19142 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19143 {
19144 PyThreadState* __tstate = wxPyBeginAllowThreads();
19145 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19146 wxPyEndAllowThreads(__tstate);
19147 if (PyErr_Occurred()) SWIG_fail;
19148 }
19149 resultobj = result;
19150 return resultobj;
19151 fail:
19152 return NULL;
19153 }
19154
19155
19156 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19157 PyObject *resultobj = 0;
19158 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19159 wxFileTypeInfo *arg2 = 0 ;
19160 void *argp1 = 0 ;
19161 int res1 = 0 ;
19162 void *argp2 = 0 ;
19163 int res2 = 0 ;
19164 PyObject * obj0 = 0 ;
19165 PyObject * obj1 = 0 ;
19166 char * kwnames[] = {
19167 (char *) "self",(char *) "ft", NULL
19168 };
19169
19170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19172 if (!SWIG_IsOK(res1)) {
19173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19174 }
19175 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19176 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19177 if (!SWIG_IsOK(res2)) {
19178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19179 }
19180 if (!argp2) {
19181 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19182 }
19183 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19184 {
19185 PyThreadState* __tstate = wxPyBeginAllowThreads();
19186 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19187 wxPyEndAllowThreads(__tstate);
19188 if (PyErr_Occurred()) SWIG_fail;
19189 }
19190 resultobj = SWIG_Py_Void();
19191 return resultobj;
19192 fail:
19193 return NULL;
19194 }
19195
19196
19197 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19198 PyObject *resultobj = 0;
19199 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19200 wxFileTypeInfo *arg2 = 0 ;
19201 wxFileType *result = 0 ;
19202 void *argp1 = 0 ;
19203 int res1 = 0 ;
19204 void *argp2 = 0 ;
19205 int res2 = 0 ;
19206 PyObject * obj0 = 0 ;
19207 PyObject * obj1 = 0 ;
19208 char * kwnames[] = {
19209 (char *) "self",(char *) "ftInfo", NULL
19210 };
19211
19212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19214 if (!SWIG_IsOK(res1)) {
19215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19216 }
19217 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19218 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19219 if (!SWIG_IsOK(res2)) {
19220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19221 }
19222 if (!argp2) {
19223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19224 }
19225 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19226 {
19227 PyThreadState* __tstate = wxPyBeginAllowThreads();
19228 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19229 wxPyEndAllowThreads(__tstate);
19230 if (PyErr_Occurred()) SWIG_fail;
19231 }
19232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19233 return resultobj;
19234 fail:
19235 return NULL;
19236 }
19237
19238
19239 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19240 PyObject *resultobj = 0;
19241 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19242 wxFileType *arg2 = (wxFileType *) 0 ;
19243 bool result;
19244 void *argp1 = 0 ;
19245 int res1 = 0 ;
19246 void *argp2 = 0 ;
19247 int res2 = 0 ;
19248 PyObject * obj0 = 0 ;
19249 PyObject * obj1 = 0 ;
19250 char * kwnames[] = {
19251 (char *) "self",(char *) "ft", NULL
19252 };
19253
19254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19256 if (!SWIG_IsOK(res1)) {
19257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19258 }
19259 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19261 if (!SWIG_IsOK(res2)) {
19262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19263 }
19264 arg2 = reinterpret_cast< wxFileType * >(argp2);
19265 {
19266 PyThreadState* __tstate = wxPyBeginAllowThreads();
19267 result = (bool)(arg1)->Unassociate(arg2);
19268 wxPyEndAllowThreads(__tstate);
19269 if (PyErr_Occurred()) SWIG_fail;
19270 }
19271 {
19272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19273 }
19274 return resultobj;
19275 fail:
19276 return NULL;
19277 }
19278
19279
19280 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19281 PyObject *resultobj = 0;
19282 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19283 void *argp1 = 0 ;
19284 int res1 = 0 ;
19285 PyObject *swig_obj[1] ;
19286
19287 if (!args) SWIG_fail;
19288 swig_obj[0] = args;
19289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19290 if (!SWIG_IsOK(res1)) {
19291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19292 }
19293 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19294 {
19295 PyThreadState* __tstate = wxPyBeginAllowThreads();
19296 delete arg1;
19297
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 resultobj = SWIG_Py_Void();
19302 return resultobj;
19303 fail:
19304 return NULL;
19305 }
19306
19307
19308 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19309 PyObject *obj;
19310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19311 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19312 return SWIG_Py_Void();
19313 }
19314
19315 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19316 return SWIG_Python_InitShadowInstance(args);
19317 }
19318
19319 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19320 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19321 return 1;
19322 }
19323
19324
19325 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19326 PyObject *pyobj = 0;
19327
19328 {
19329 #if wxUSE_UNICODE
19330 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19331 #else
19332 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19333 #endif
19334 }
19335 return pyobj;
19336 }
19337
19338
19339 SWIGINTERN int ART_MENU_set(PyObject *) {
19340 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19341 return 1;
19342 }
19343
19344
19345 SWIGINTERN PyObject *ART_MENU_get(void) {
19346 PyObject *pyobj = 0;
19347
19348 {
19349 #if wxUSE_UNICODE
19350 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19351 #else
19352 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19353 #endif
19354 }
19355 return pyobj;
19356 }
19357
19358
19359 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19360 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19361 return 1;
19362 }
19363
19364
19365 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19366 PyObject *pyobj = 0;
19367
19368 {
19369 #if wxUSE_UNICODE
19370 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19371 #else
19372 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19373 #endif
19374 }
19375 return pyobj;
19376 }
19377
19378
19379 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19380 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19381 return 1;
19382 }
19383
19384
19385 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19386 PyObject *pyobj = 0;
19387
19388 {
19389 #if wxUSE_UNICODE
19390 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19391 #else
19392 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19393 #endif
19394 }
19395 return pyobj;
19396 }
19397
19398
19399 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19400 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19401 return 1;
19402 }
19403
19404
19405 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19406 PyObject *pyobj = 0;
19407
19408 {
19409 #if wxUSE_UNICODE
19410 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19411 #else
19412 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19413 #endif
19414 }
19415 return pyobj;
19416 }
19417
19418
19419 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19420 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19421 return 1;
19422 }
19423
19424
19425 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19426 PyObject *pyobj = 0;
19427
19428 {
19429 #if wxUSE_UNICODE
19430 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19431 #else
19432 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19433 #endif
19434 }
19435 return pyobj;
19436 }
19437
19438
19439 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19440 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19441 return 1;
19442 }
19443
19444
19445 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19446 PyObject *pyobj = 0;
19447
19448 {
19449 #if wxUSE_UNICODE
19450 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19451 #else
19452 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19453 #endif
19454 }
19455 return pyobj;
19456 }
19457
19458
19459 SWIGINTERN int ART_OTHER_set(PyObject *) {
19460 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19461 return 1;
19462 }
19463
19464
19465 SWIGINTERN PyObject *ART_OTHER_get(void) {
19466 PyObject *pyobj = 0;
19467
19468 {
19469 #if wxUSE_UNICODE
19470 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19471 #else
19472 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19473 #endif
19474 }
19475 return pyobj;
19476 }
19477
19478
19479 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19480 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19481 return 1;
19482 }
19483
19484
19485 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19486 PyObject *pyobj = 0;
19487
19488 {
19489 #if wxUSE_UNICODE
19490 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19491 #else
19492 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19493 #endif
19494 }
19495 return pyobj;
19496 }
19497
19498
19499 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19500 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19501 return 1;
19502 }
19503
19504
19505 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19506 PyObject *pyobj = 0;
19507
19508 {
19509 #if wxUSE_UNICODE
19510 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19511 #else
19512 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19513 #endif
19514 }
19515 return pyobj;
19516 }
19517
19518
19519 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19520 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19521 return 1;
19522 }
19523
19524
19525 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19526 PyObject *pyobj = 0;
19527
19528 {
19529 #if wxUSE_UNICODE
19530 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19531 #else
19532 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19533 #endif
19534 }
19535 return pyobj;
19536 }
19537
19538
19539 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19540 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19541 return 1;
19542 }
19543
19544
19545 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19546 PyObject *pyobj = 0;
19547
19548 {
19549 #if wxUSE_UNICODE
19550 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19551 #else
19552 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19553 #endif
19554 }
19555 return pyobj;
19556 }
19557
19558
19559 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19560 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19561 return 1;
19562 }
19563
19564
19565 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19566 PyObject *pyobj = 0;
19567
19568 {
19569 #if wxUSE_UNICODE
19570 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19571 #else
19572 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19573 #endif
19574 }
19575 return pyobj;
19576 }
19577
19578
19579 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19580 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19581 return 1;
19582 }
19583
19584
19585 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19586 PyObject *pyobj = 0;
19587
19588 {
19589 #if wxUSE_UNICODE
19590 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19591 #else
19592 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19593 #endif
19594 }
19595 return pyobj;
19596 }
19597
19598
19599 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19600 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19601 return 1;
19602 }
19603
19604
19605 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19606 PyObject *pyobj = 0;
19607
19608 {
19609 #if wxUSE_UNICODE
19610 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19611 #else
19612 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19613 #endif
19614 }
19615 return pyobj;
19616 }
19617
19618
19619 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19620 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19621 return 1;
19622 }
19623
19624
19625 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19626 PyObject *pyobj = 0;
19627
19628 {
19629 #if wxUSE_UNICODE
19630 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19631 #else
19632 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19633 #endif
19634 }
19635 return pyobj;
19636 }
19637
19638
19639 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19640 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19641 return 1;
19642 }
19643
19644
19645 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19646 PyObject *pyobj = 0;
19647
19648 {
19649 #if wxUSE_UNICODE
19650 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19651 #else
19652 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19653 #endif
19654 }
19655 return pyobj;
19656 }
19657
19658
19659 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19660 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19661 return 1;
19662 }
19663
19664
19665 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19666 PyObject *pyobj = 0;
19667
19668 {
19669 #if wxUSE_UNICODE
19670 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19671 #else
19672 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19673 #endif
19674 }
19675 return pyobj;
19676 }
19677
19678
19679 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19680 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19681 return 1;
19682 }
19683
19684
19685 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19686 PyObject *pyobj = 0;
19687
19688 {
19689 #if wxUSE_UNICODE
19690 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19691 #else
19692 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19693 #endif
19694 }
19695 return pyobj;
19696 }
19697
19698
19699 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19700 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19701 return 1;
19702 }
19703
19704
19705 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19706 PyObject *pyobj = 0;
19707
19708 {
19709 #if wxUSE_UNICODE
19710 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19711 #else
19712 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19713 #endif
19714 }
19715 return pyobj;
19716 }
19717
19718
19719 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19720 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19721 return 1;
19722 }
19723
19724
19725 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19726 PyObject *pyobj = 0;
19727
19728 {
19729 #if wxUSE_UNICODE
19730 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19731 #else
19732 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19733 #endif
19734 }
19735 return pyobj;
19736 }
19737
19738
19739 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19740 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19741 return 1;
19742 }
19743
19744
19745 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19746 PyObject *pyobj = 0;
19747
19748 {
19749 #if wxUSE_UNICODE
19750 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19751 #else
19752 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19753 #endif
19754 }
19755 return pyobj;
19756 }
19757
19758
19759 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19760 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19761 return 1;
19762 }
19763
19764
19765 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19766 PyObject *pyobj = 0;
19767
19768 {
19769 #if wxUSE_UNICODE
19770 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19771 #else
19772 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19773 #endif
19774 }
19775 return pyobj;
19776 }
19777
19778
19779 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19780 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19781 return 1;
19782 }
19783
19784
19785 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19786 PyObject *pyobj = 0;
19787
19788 {
19789 #if wxUSE_UNICODE
19790 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19791 #else
19792 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19793 #endif
19794 }
19795 return pyobj;
19796 }
19797
19798
19799 SWIGINTERN int ART_PRINT_set(PyObject *) {
19800 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19801 return 1;
19802 }
19803
19804
19805 SWIGINTERN PyObject *ART_PRINT_get(void) {
19806 PyObject *pyobj = 0;
19807
19808 {
19809 #if wxUSE_UNICODE
19810 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19811 #else
19812 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19813 #endif
19814 }
19815 return pyobj;
19816 }
19817
19818
19819 SWIGINTERN int ART_HELP_set(PyObject *) {
19820 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19821 return 1;
19822 }
19823
19824
19825 SWIGINTERN PyObject *ART_HELP_get(void) {
19826 PyObject *pyobj = 0;
19827
19828 {
19829 #if wxUSE_UNICODE
19830 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19831 #else
19832 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19833 #endif
19834 }
19835 return pyobj;
19836 }
19837
19838
19839 SWIGINTERN int ART_TIP_set(PyObject *) {
19840 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19841 return 1;
19842 }
19843
19844
19845 SWIGINTERN PyObject *ART_TIP_get(void) {
19846 PyObject *pyobj = 0;
19847
19848 {
19849 #if wxUSE_UNICODE
19850 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19851 #else
19852 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19853 #endif
19854 }
19855 return pyobj;
19856 }
19857
19858
19859 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19860 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19861 return 1;
19862 }
19863
19864
19865 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19866 PyObject *pyobj = 0;
19867
19868 {
19869 #if wxUSE_UNICODE
19870 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19871 #else
19872 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19873 #endif
19874 }
19875 return pyobj;
19876 }
19877
19878
19879 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19880 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19881 return 1;
19882 }
19883
19884
19885 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19886 PyObject *pyobj = 0;
19887
19888 {
19889 #if wxUSE_UNICODE
19890 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19891 #else
19892 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19893 #endif
19894 }
19895 return pyobj;
19896 }
19897
19898
19899 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19900 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19901 return 1;
19902 }
19903
19904
19905 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19906 PyObject *pyobj = 0;
19907
19908 {
19909 #if wxUSE_UNICODE
19910 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19911 #else
19912 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19913 #endif
19914 }
19915 return pyobj;
19916 }
19917
19918
19919 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19920 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19921 return 1;
19922 }
19923
19924
19925 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19926 PyObject *pyobj = 0;
19927
19928 {
19929 #if wxUSE_UNICODE
19930 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19931 #else
19932 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19933 #endif
19934 }
19935 return pyobj;
19936 }
19937
19938
19939 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19940 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19941 return 1;
19942 }
19943
19944
19945 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19946 PyObject *pyobj = 0;
19947
19948 {
19949 #if wxUSE_UNICODE
19950 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19951 #else
19952 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19953 #endif
19954 }
19955 return pyobj;
19956 }
19957
19958
19959 SWIGINTERN int ART_CDROM_set(PyObject *) {
19960 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19961 return 1;
19962 }
19963
19964
19965 SWIGINTERN PyObject *ART_CDROM_get(void) {
19966 PyObject *pyobj = 0;
19967
19968 {
19969 #if wxUSE_UNICODE
19970 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19971 #else
19972 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19973 #endif
19974 }
19975 return pyobj;
19976 }
19977
19978
19979 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19980 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19981 return 1;
19982 }
19983
19984
19985 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19986 PyObject *pyobj = 0;
19987
19988 {
19989 #if wxUSE_UNICODE
19990 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19991 #else
19992 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19993 #endif
19994 }
19995 return pyobj;
19996 }
19997
19998
19999 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20000 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20001 return 1;
20002 }
20003
20004
20005 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20006 PyObject *pyobj = 0;
20007
20008 {
20009 #if wxUSE_UNICODE
20010 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20011 #else
20012 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20013 #endif
20014 }
20015 return pyobj;
20016 }
20017
20018
20019 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20020 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20021 return 1;
20022 }
20023
20024
20025 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20026 PyObject *pyobj = 0;
20027
20028 {
20029 #if wxUSE_UNICODE
20030 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20031 #else
20032 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20033 #endif
20034 }
20035 return pyobj;
20036 }
20037
20038
20039 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20040 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20041 return 1;
20042 }
20043
20044
20045 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20046 PyObject *pyobj = 0;
20047
20048 {
20049 #if wxUSE_UNICODE
20050 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20051 #else
20052 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20053 #endif
20054 }
20055 return pyobj;
20056 }
20057
20058
20059 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20060 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20061 return 1;
20062 }
20063
20064
20065 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20066 PyObject *pyobj = 0;
20067
20068 {
20069 #if wxUSE_UNICODE
20070 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20071 #else
20072 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20073 #endif
20074 }
20075 return pyobj;
20076 }
20077
20078
20079 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20080 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20081 return 1;
20082 }
20083
20084
20085 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20086 PyObject *pyobj = 0;
20087
20088 {
20089 #if wxUSE_UNICODE
20090 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20091 #else
20092 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20093 #endif
20094 }
20095 return pyobj;
20096 }
20097
20098
20099 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20100 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20101 return 1;
20102 }
20103
20104
20105 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20106 PyObject *pyobj = 0;
20107
20108 {
20109 #if wxUSE_UNICODE
20110 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20111 #else
20112 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20113 #endif
20114 }
20115 return pyobj;
20116 }
20117
20118
20119 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20120 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20121 return 1;
20122 }
20123
20124
20125 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20126 PyObject *pyobj = 0;
20127
20128 {
20129 #if wxUSE_UNICODE
20130 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20131 #else
20132 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20133 #endif
20134 }
20135 return pyobj;
20136 }
20137
20138
20139 SWIGINTERN int ART_ERROR_set(PyObject *) {
20140 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20141 return 1;
20142 }
20143
20144
20145 SWIGINTERN PyObject *ART_ERROR_get(void) {
20146 PyObject *pyobj = 0;
20147
20148 {
20149 #if wxUSE_UNICODE
20150 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20151 #else
20152 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20153 #endif
20154 }
20155 return pyobj;
20156 }
20157
20158
20159 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20160 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20161 return 1;
20162 }
20163
20164
20165 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20166 PyObject *pyobj = 0;
20167
20168 {
20169 #if wxUSE_UNICODE
20170 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20171 #else
20172 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20173 #endif
20174 }
20175 return pyobj;
20176 }
20177
20178
20179 SWIGINTERN int ART_WARNING_set(PyObject *) {
20180 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20181 return 1;
20182 }
20183
20184
20185 SWIGINTERN PyObject *ART_WARNING_get(void) {
20186 PyObject *pyobj = 0;
20187
20188 {
20189 #if wxUSE_UNICODE
20190 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20191 #else
20192 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20193 #endif
20194 }
20195 return pyobj;
20196 }
20197
20198
20199 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20200 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20201 return 1;
20202 }
20203
20204
20205 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20206 PyObject *pyobj = 0;
20207
20208 {
20209 #if wxUSE_UNICODE
20210 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20211 #else
20212 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20213 #endif
20214 }
20215 return pyobj;
20216 }
20217
20218
20219 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20220 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20221 return 1;
20222 }
20223
20224
20225 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20226 PyObject *pyobj = 0;
20227
20228 {
20229 #if wxUSE_UNICODE
20230 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20231 #else
20232 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20233 #endif
20234 }
20235 return pyobj;
20236 }
20237
20238
20239 SWIGINTERN int ART_COPY_set(PyObject *) {
20240 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20241 return 1;
20242 }
20243
20244
20245 SWIGINTERN PyObject *ART_COPY_get(void) {
20246 PyObject *pyobj = 0;
20247
20248 {
20249 #if wxUSE_UNICODE
20250 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20251 #else
20252 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20253 #endif
20254 }
20255 return pyobj;
20256 }
20257
20258
20259 SWIGINTERN int ART_CUT_set(PyObject *) {
20260 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20261 return 1;
20262 }
20263
20264
20265 SWIGINTERN PyObject *ART_CUT_get(void) {
20266 PyObject *pyobj = 0;
20267
20268 {
20269 #if wxUSE_UNICODE
20270 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20271 #else
20272 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20273 #endif
20274 }
20275 return pyobj;
20276 }
20277
20278
20279 SWIGINTERN int ART_PASTE_set(PyObject *) {
20280 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20281 return 1;
20282 }
20283
20284
20285 SWIGINTERN PyObject *ART_PASTE_get(void) {
20286 PyObject *pyobj = 0;
20287
20288 {
20289 #if wxUSE_UNICODE
20290 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20291 #else
20292 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20293 #endif
20294 }
20295 return pyobj;
20296 }
20297
20298
20299 SWIGINTERN int ART_DELETE_set(PyObject *) {
20300 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20301 return 1;
20302 }
20303
20304
20305 SWIGINTERN PyObject *ART_DELETE_get(void) {
20306 PyObject *pyobj = 0;
20307
20308 {
20309 #if wxUSE_UNICODE
20310 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20311 #else
20312 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20313 #endif
20314 }
20315 return pyobj;
20316 }
20317
20318
20319 SWIGINTERN int ART_NEW_set(PyObject *) {
20320 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20321 return 1;
20322 }
20323
20324
20325 SWIGINTERN PyObject *ART_NEW_get(void) {
20326 PyObject *pyobj = 0;
20327
20328 {
20329 #if wxUSE_UNICODE
20330 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20331 #else
20332 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20333 #endif
20334 }
20335 return pyobj;
20336 }
20337
20338
20339 SWIGINTERN int ART_UNDO_set(PyObject *) {
20340 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20341 return 1;
20342 }
20343
20344
20345 SWIGINTERN PyObject *ART_UNDO_get(void) {
20346 PyObject *pyobj = 0;
20347
20348 {
20349 #if wxUSE_UNICODE
20350 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20351 #else
20352 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20353 #endif
20354 }
20355 return pyobj;
20356 }
20357
20358
20359 SWIGINTERN int ART_REDO_set(PyObject *) {
20360 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20361 return 1;
20362 }
20363
20364
20365 SWIGINTERN PyObject *ART_REDO_get(void) {
20366 PyObject *pyobj = 0;
20367
20368 {
20369 #if wxUSE_UNICODE
20370 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20371 #else
20372 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20373 #endif
20374 }
20375 return pyobj;
20376 }
20377
20378
20379 SWIGINTERN int ART_QUIT_set(PyObject *) {
20380 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20381 return 1;
20382 }
20383
20384
20385 SWIGINTERN PyObject *ART_QUIT_get(void) {
20386 PyObject *pyobj = 0;
20387
20388 {
20389 #if wxUSE_UNICODE
20390 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20391 #else
20392 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20393 #endif
20394 }
20395 return pyobj;
20396 }
20397
20398
20399 SWIGINTERN int ART_FIND_set(PyObject *) {
20400 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20401 return 1;
20402 }
20403
20404
20405 SWIGINTERN PyObject *ART_FIND_get(void) {
20406 PyObject *pyobj = 0;
20407
20408 {
20409 #if wxUSE_UNICODE
20410 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20411 #else
20412 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20413 #endif
20414 }
20415 return pyobj;
20416 }
20417
20418
20419 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20420 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20421 return 1;
20422 }
20423
20424
20425 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20426 PyObject *pyobj = 0;
20427
20428 {
20429 #if wxUSE_UNICODE
20430 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20431 #else
20432 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20433 #endif
20434 }
20435 return pyobj;
20436 }
20437
20438
20439 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20440 PyObject *resultobj = 0;
20441 wxPyArtProvider *result = 0 ;
20442
20443 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20444 {
20445 if (!wxPyCheckForApp()) SWIG_fail;
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 result = (wxPyArtProvider *)new wxPyArtProvider();
20448 wxPyEndAllowThreads(__tstate);
20449 if (PyErr_Occurred()) SWIG_fail;
20450 }
20451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20452 return resultobj;
20453 fail:
20454 return NULL;
20455 }
20456
20457
20458 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20459 PyObject *resultobj = 0;
20460 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20461 void *argp1 = 0 ;
20462 int res1 = 0 ;
20463 PyObject *swig_obj[1] ;
20464
20465 if (!args) SWIG_fail;
20466 swig_obj[0] = args;
20467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20468 if (!SWIG_IsOK(res1)) {
20469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20470 }
20471 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20472 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 delete arg1;
20475
20476 wxPyEndAllowThreads(__tstate);
20477 if (PyErr_Occurred()) SWIG_fail;
20478 }
20479 resultobj = SWIG_Py_Void();
20480 return resultobj;
20481 fail:
20482 return NULL;
20483 }
20484
20485
20486 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20487 PyObject *resultobj = 0;
20488 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20489 PyObject *arg2 = (PyObject *) 0 ;
20490 PyObject *arg3 = (PyObject *) 0 ;
20491 void *argp1 = 0 ;
20492 int res1 = 0 ;
20493 PyObject * obj0 = 0 ;
20494 PyObject * obj1 = 0 ;
20495 PyObject * obj2 = 0 ;
20496 char * kwnames[] = {
20497 (char *) "self",(char *) "self",(char *) "_class", NULL
20498 };
20499
20500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20502 if (!SWIG_IsOK(res1)) {
20503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20504 }
20505 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20506 arg2 = obj1;
20507 arg3 = obj2;
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 (arg1)->_setCallbackInfo(arg2,arg3);
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 resultobj = SWIG_Py_Void();
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20522 PyObject *resultobj = 0;
20523 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20524 int res1 = 0 ;
20525 PyObject * obj0 = 0 ;
20526 char * kwnames[] = {
20527 (char *) "provider", NULL
20528 };
20529
20530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20531 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20532 if (!SWIG_IsOK(res1)) {
20533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20534 }
20535 {
20536 PyThreadState* __tstate = wxPyBeginAllowThreads();
20537 wxPyArtProvider::Push(arg1);
20538 wxPyEndAllowThreads(__tstate);
20539 if (PyErr_Occurred()) SWIG_fail;
20540 }
20541 resultobj = SWIG_Py_Void();
20542 return resultobj;
20543 fail:
20544 return NULL;
20545 }
20546
20547
20548 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20549 PyObject *resultobj = 0;
20550 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20551 int res1 = 0 ;
20552 PyObject * obj0 = 0 ;
20553 char * kwnames[] = {
20554 (char *) "provider", NULL
20555 };
20556
20557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20558 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20559 if (!SWIG_IsOK(res1)) {
20560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20561 }
20562 {
20563 PyThreadState* __tstate = wxPyBeginAllowThreads();
20564 wxPyArtProvider::Insert(arg1);
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 resultobj = SWIG_Py_Void();
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20576 PyObject *resultobj = 0;
20577 bool result;
20578
20579 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 result = (bool)wxPyArtProvider::Pop();
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20596 PyObject *resultobj = 0;
20597 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20598 bool result;
20599 void *argp1 = 0 ;
20600 int res1 = 0 ;
20601 PyObject * obj0 = 0 ;
20602 char * kwnames[] = {
20603 (char *) "provider", NULL
20604 };
20605
20606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20608 if (!SWIG_IsOK(res1)) {
20609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20610 }
20611 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20612 {
20613 PyThreadState* __tstate = wxPyBeginAllowThreads();
20614 result = (bool)wxPyArtProvider::Delete(arg1);
20615 wxPyEndAllowThreads(__tstate);
20616 if (PyErr_Occurred()) SWIG_fail;
20617 }
20618 {
20619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20620 }
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20628 PyObject *resultobj = 0;
20629 wxString *arg1 = 0 ;
20630 wxString const &arg2_defvalue = wxPyART_OTHER ;
20631 wxString *arg2 = (wxString *) &arg2_defvalue ;
20632 wxSize const &arg3_defvalue = wxDefaultSize ;
20633 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20634 wxBitmap result;
20635 bool temp1 = false ;
20636 bool temp2 = false ;
20637 wxSize temp3 ;
20638 PyObject * obj0 = 0 ;
20639 PyObject * obj1 = 0 ;
20640 PyObject * obj2 = 0 ;
20641 char * kwnames[] = {
20642 (char *) "id",(char *) "client",(char *) "size", NULL
20643 };
20644
20645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20646 {
20647 arg1 = wxString_in_helper(obj0);
20648 if (arg1 == NULL) SWIG_fail;
20649 temp1 = true;
20650 }
20651 if (obj1) {
20652 {
20653 arg2 = wxString_in_helper(obj1);
20654 if (arg2 == NULL) SWIG_fail;
20655 temp2 = true;
20656 }
20657 }
20658 if (obj2) {
20659 {
20660 arg3 = &temp3;
20661 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20662 }
20663 }
20664 {
20665 if (!wxPyCheckForApp()) SWIG_fail;
20666 PyThreadState* __tstate = wxPyBeginAllowThreads();
20667 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20668 wxPyEndAllowThreads(__tstate);
20669 if (PyErr_Occurred()) SWIG_fail;
20670 }
20671 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20672 {
20673 if (temp1)
20674 delete arg1;
20675 }
20676 {
20677 if (temp2)
20678 delete arg2;
20679 }
20680 return resultobj;
20681 fail:
20682 {
20683 if (temp1)
20684 delete arg1;
20685 }
20686 {
20687 if (temp2)
20688 delete arg2;
20689 }
20690 return NULL;
20691 }
20692
20693
20694 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20695 PyObject *resultobj = 0;
20696 wxString *arg1 = 0 ;
20697 wxString const &arg2_defvalue = wxPyART_OTHER ;
20698 wxString *arg2 = (wxString *) &arg2_defvalue ;
20699 wxSize const &arg3_defvalue = wxDefaultSize ;
20700 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20701 wxIcon result;
20702 bool temp1 = false ;
20703 bool temp2 = false ;
20704 wxSize temp3 ;
20705 PyObject * obj0 = 0 ;
20706 PyObject * obj1 = 0 ;
20707 PyObject * obj2 = 0 ;
20708 char * kwnames[] = {
20709 (char *) "id",(char *) "client",(char *) "size", NULL
20710 };
20711
20712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20713 {
20714 arg1 = wxString_in_helper(obj0);
20715 if (arg1 == NULL) SWIG_fail;
20716 temp1 = true;
20717 }
20718 if (obj1) {
20719 {
20720 arg2 = wxString_in_helper(obj1);
20721 if (arg2 == NULL) SWIG_fail;
20722 temp2 = true;
20723 }
20724 }
20725 if (obj2) {
20726 {
20727 arg3 = &temp3;
20728 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20729 }
20730 }
20731 {
20732 if (!wxPyCheckForApp()) SWIG_fail;
20733 PyThreadState* __tstate = wxPyBeginAllowThreads();
20734 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20735 wxPyEndAllowThreads(__tstate);
20736 if (PyErr_Occurred()) SWIG_fail;
20737 }
20738 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20739 {
20740 if (temp1)
20741 delete arg1;
20742 }
20743 {
20744 if (temp2)
20745 delete arg2;
20746 }
20747 return resultobj;
20748 fail:
20749 {
20750 if (temp1)
20751 delete arg1;
20752 }
20753 {
20754 if (temp2)
20755 delete arg2;
20756 }
20757 return NULL;
20758 }
20759
20760
20761 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20762 PyObject *resultobj = 0;
20763 wxString *arg1 = 0 ;
20764 bool arg2 = (bool) false ;
20765 wxSize result;
20766 bool temp1 = false ;
20767 bool val2 ;
20768 int ecode2 = 0 ;
20769 PyObject * obj0 = 0 ;
20770 PyObject * obj1 = 0 ;
20771 char * kwnames[] = {
20772 (char *) "client",(char *) "platform_dependent", NULL
20773 };
20774
20775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20776 {
20777 arg1 = wxString_in_helper(obj0);
20778 if (arg1 == NULL) SWIG_fail;
20779 temp1 = true;
20780 }
20781 if (obj1) {
20782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20783 if (!SWIG_IsOK(ecode2)) {
20784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20785 }
20786 arg2 = static_cast< bool >(val2);
20787 }
20788 {
20789 PyThreadState* __tstate = wxPyBeginAllowThreads();
20790 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20791 wxPyEndAllowThreads(__tstate);
20792 if (PyErr_Occurred()) SWIG_fail;
20793 }
20794 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20795 {
20796 if (temp1)
20797 delete arg1;
20798 }
20799 return resultobj;
20800 fail:
20801 {
20802 if (temp1)
20803 delete arg1;
20804 }
20805 return NULL;
20806 }
20807
20808
20809 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20810 PyObject *resultobj = 0;
20811 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20812 void *argp1 = 0 ;
20813 int res1 = 0 ;
20814 PyObject *swig_obj[1] ;
20815
20816 if (!args) SWIG_fail;
20817 swig_obj[0] = args;
20818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20819 if (!SWIG_IsOK(res1)) {
20820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20821 }
20822 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20823 {
20824 PyThreadState* __tstate = wxPyBeginAllowThreads();
20825 wxPyArtProvider_Destroy(arg1);
20826 wxPyEndAllowThreads(__tstate);
20827 if (PyErr_Occurred()) SWIG_fail;
20828 }
20829 resultobj = SWIG_Py_Void();
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20837 PyObject *obj;
20838 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20839 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20840 return SWIG_Py_Void();
20841 }
20842
20843 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20844 return SWIG_Python_InitShadowInstance(args);
20845 }
20846
20847 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20848 PyObject *resultobj = 0;
20849 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20850 void *argp1 = 0 ;
20851 int res1 = 0 ;
20852 PyObject *swig_obj[1] ;
20853
20854 if (!args) SWIG_fail;
20855 swig_obj[0] = args;
20856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20857 if (!SWIG_IsOK(res1)) {
20858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20859 }
20860 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20861 {
20862 PyThreadState* __tstate = wxPyBeginAllowThreads();
20863 delete arg1;
20864
20865 wxPyEndAllowThreads(__tstate);
20866 if (PyErr_Occurred()) SWIG_fail;
20867 }
20868 resultobj = SWIG_Py_Void();
20869 return resultobj;
20870 fail:
20871 return NULL;
20872 }
20873
20874
20875 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20876 PyObject *resultobj = 0;
20877 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20878 wxConfigBase *result = 0 ;
20879 int res1 = 0 ;
20880 PyObject * obj0 = 0 ;
20881 char * kwnames[] = {
20882 (char *) "config", NULL
20883 };
20884
20885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20886 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20887 if (!SWIG_IsOK(res1)) {
20888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20889 }
20890 {
20891 PyThreadState* __tstate = wxPyBeginAllowThreads();
20892 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20893 wxPyEndAllowThreads(__tstate);
20894 if (PyErr_Occurred()) SWIG_fail;
20895 }
20896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20897 return resultobj;
20898 fail:
20899 return NULL;
20900 }
20901
20902
20903 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20904 PyObject *resultobj = 0;
20905 bool arg1 = (bool) true ;
20906 wxConfigBase *result = 0 ;
20907 bool val1 ;
20908 int ecode1 = 0 ;
20909 PyObject * obj0 = 0 ;
20910 char * kwnames[] = {
20911 (char *) "createOnDemand", NULL
20912 };
20913
20914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20915 if (obj0) {
20916 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20917 if (!SWIG_IsOK(ecode1)) {
20918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20919 }
20920 arg1 = static_cast< bool >(val1);
20921 }
20922 {
20923 PyThreadState* __tstate = wxPyBeginAllowThreads();
20924 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20925 wxPyEndAllowThreads(__tstate);
20926 if (PyErr_Occurred()) SWIG_fail;
20927 }
20928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20929 return resultobj;
20930 fail:
20931 return NULL;
20932 }
20933
20934
20935 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20936 PyObject *resultobj = 0;
20937 wxConfigBase *result = 0 ;
20938
20939 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (wxConfigBase *)wxConfigBase::Create();
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20954 PyObject *resultobj = 0;
20955
20956 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 wxConfigBase::DontCreateOnDemand();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 resultobj = SWIG_Py_Void();
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj = 0;
20972 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20973 wxString *arg2 = 0 ;
20974 void *argp1 = 0 ;
20975 int res1 = 0 ;
20976 bool temp2 = false ;
20977 PyObject * obj0 = 0 ;
20978 PyObject * obj1 = 0 ;
20979 char * kwnames[] = {
20980 (char *) "self",(char *) "path", NULL
20981 };
20982
20983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20985 if (!SWIG_IsOK(res1)) {
20986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20987 }
20988 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20989 {
20990 arg2 = wxString_in_helper(obj1);
20991 if (arg2 == NULL) SWIG_fail;
20992 temp2 = true;
20993 }
20994 {
20995 PyThreadState* __tstate = wxPyBeginAllowThreads();
20996 (arg1)->SetPath((wxString const &)*arg2);
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 resultobj = SWIG_Py_Void();
21001 {
21002 if (temp2)
21003 delete arg2;
21004 }
21005 return resultobj;
21006 fail:
21007 {
21008 if (temp2)
21009 delete arg2;
21010 }
21011 return NULL;
21012 }
21013
21014
21015 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21016 PyObject *resultobj = 0;
21017 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21018 wxString *result = 0 ;
21019 void *argp1 = 0 ;
21020 int res1 = 0 ;
21021 PyObject *swig_obj[1] ;
21022
21023 if (!args) SWIG_fail;
21024 swig_obj[0] = args;
21025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21026 if (!SWIG_IsOK(res1)) {
21027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21028 }
21029 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21030 {
21031 PyThreadState* __tstate = wxPyBeginAllowThreads();
21032 {
21033 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21034 result = (wxString *) &_result_ref;
21035 }
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 {
21040 #if wxUSE_UNICODE
21041 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21042 #else
21043 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21044 #endif
21045 }
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21053 PyObject *resultobj = 0;
21054 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21055 PyObject *result = 0 ;
21056 void *argp1 = 0 ;
21057 int res1 = 0 ;
21058 PyObject *swig_obj[1] ;
21059
21060 if (!args) SWIG_fail;
21061 swig_obj[0] = args;
21062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21063 if (!SWIG_IsOK(res1)) {
21064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21065 }
21066 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 resultobj = result;
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21081 PyObject *resultobj = 0;
21082 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21083 long arg2 ;
21084 PyObject *result = 0 ;
21085 void *argp1 = 0 ;
21086 int res1 = 0 ;
21087 long val2 ;
21088 int ecode2 = 0 ;
21089 PyObject * obj0 = 0 ;
21090 PyObject * obj1 = 0 ;
21091 char * kwnames[] = {
21092 (char *) "self",(char *) "index", NULL
21093 };
21094
21095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21097 if (!SWIG_IsOK(res1)) {
21098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21099 }
21100 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21101 ecode2 = SWIG_AsVal_long(obj1, &val2);
21102 if (!SWIG_IsOK(ecode2)) {
21103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21104 }
21105 arg2 = static_cast< long >(val2);
21106 {
21107 PyThreadState* __tstate = wxPyBeginAllowThreads();
21108 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21109 wxPyEndAllowThreads(__tstate);
21110 if (PyErr_Occurred()) SWIG_fail;
21111 }
21112 resultobj = result;
21113 return resultobj;
21114 fail:
21115 return NULL;
21116 }
21117
21118
21119 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21120 PyObject *resultobj = 0;
21121 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21122 PyObject *result = 0 ;
21123 void *argp1 = 0 ;
21124 int res1 = 0 ;
21125 PyObject *swig_obj[1] ;
21126
21127 if (!args) SWIG_fail;
21128 swig_obj[0] = args;
21129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21130 if (!SWIG_IsOK(res1)) {
21131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21132 }
21133 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = result;
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21148 PyObject *resultobj = 0;
21149 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21150 long arg2 ;
21151 PyObject *result = 0 ;
21152 void *argp1 = 0 ;
21153 int res1 = 0 ;
21154 long val2 ;
21155 int ecode2 = 0 ;
21156 PyObject * obj0 = 0 ;
21157 PyObject * obj1 = 0 ;
21158 char * kwnames[] = {
21159 (char *) "self",(char *) "index", NULL
21160 };
21161
21162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21164 if (!SWIG_IsOK(res1)) {
21165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21166 }
21167 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21168 ecode2 = SWIG_AsVal_long(obj1, &val2);
21169 if (!SWIG_IsOK(ecode2)) {
21170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21171 }
21172 arg2 = static_cast< long >(val2);
21173 {
21174 PyThreadState* __tstate = wxPyBeginAllowThreads();
21175 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21176 wxPyEndAllowThreads(__tstate);
21177 if (PyErr_Occurred()) SWIG_fail;
21178 }
21179 resultobj = result;
21180 return resultobj;
21181 fail:
21182 return NULL;
21183 }
21184
21185
21186 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21187 PyObject *resultobj = 0;
21188 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21189 bool arg2 = (bool) false ;
21190 size_t result;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 bool val2 ;
21194 int ecode2 = 0 ;
21195 PyObject * obj0 = 0 ;
21196 PyObject * obj1 = 0 ;
21197 char * kwnames[] = {
21198 (char *) "self",(char *) "recursive", NULL
21199 };
21200
21201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21203 if (!SWIG_IsOK(res1)) {
21204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21205 }
21206 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21207 if (obj1) {
21208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21209 if (!SWIG_IsOK(ecode2)) {
21210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21211 }
21212 arg2 = static_cast< bool >(val2);
21213 }
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21217 wxPyEndAllowThreads(__tstate);
21218 if (PyErr_Occurred()) SWIG_fail;
21219 }
21220 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21228 PyObject *resultobj = 0;
21229 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21230 bool arg2 = (bool) false ;
21231 size_t result;
21232 void *argp1 = 0 ;
21233 int res1 = 0 ;
21234 bool val2 ;
21235 int ecode2 = 0 ;
21236 PyObject * obj0 = 0 ;
21237 PyObject * obj1 = 0 ;
21238 char * kwnames[] = {
21239 (char *) "self",(char *) "recursive", NULL
21240 };
21241
21242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21244 if (!SWIG_IsOK(res1)) {
21245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21246 }
21247 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21248 if (obj1) {
21249 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21250 if (!SWIG_IsOK(ecode2)) {
21251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21252 }
21253 arg2 = static_cast< bool >(val2);
21254 }
21255 {
21256 PyThreadState* __tstate = wxPyBeginAllowThreads();
21257 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21258 wxPyEndAllowThreads(__tstate);
21259 if (PyErr_Occurred()) SWIG_fail;
21260 }
21261 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21269 PyObject *resultobj = 0;
21270 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21271 wxString *arg2 = 0 ;
21272 bool result;
21273 void *argp1 = 0 ;
21274 int res1 = 0 ;
21275 bool temp2 = false ;
21276 PyObject * obj0 = 0 ;
21277 PyObject * obj1 = 0 ;
21278 char * kwnames[] = {
21279 (char *) "self",(char *) "name", NULL
21280 };
21281
21282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21284 if (!SWIG_IsOK(res1)) {
21285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21286 }
21287 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21288 {
21289 arg2 = wxString_in_helper(obj1);
21290 if (arg2 == NULL) SWIG_fail;
21291 temp2 = true;
21292 }
21293 {
21294 PyThreadState* __tstate = wxPyBeginAllowThreads();
21295 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21296 wxPyEndAllowThreads(__tstate);
21297 if (PyErr_Occurred()) SWIG_fail;
21298 }
21299 {
21300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21301 }
21302 {
21303 if (temp2)
21304 delete arg2;
21305 }
21306 return resultobj;
21307 fail:
21308 {
21309 if (temp2)
21310 delete arg2;
21311 }
21312 return NULL;
21313 }
21314
21315
21316 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21317 PyObject *resultobj = 0;
21318 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21319 wxString *arg2 = 0 ;
21320 bool result;
21321 void *argp1 = 0 ;
21322 int res1 = 0 ;
21323 bool temp2 = false ;
21324 PyObject * obj0 = 0 ;
21325 PyObject * obj1 = 0 ;
21326 char * kwnames[] = {
21327 (char *) "self",(char *) "name", NULL
21328 };
21329
21330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21332 if (!SWIG_IsOK(res1)) {
21333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21334 }
21335 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21336 {
21337 arg2 = wxString_in_helper(obj1);
21338 if (arg2 == NULL) SWIG_fail;
21339 temp2 = true;
21340 }
21341 {
21342 PyThreadState* __tstate = wxPyBeginAllowThreads();
21343 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21344 wxPyEndAllowThreads(__tstate);
21345 if (PyErr_Occurred()) SWIG_fail;
21346 }
21347 {
21348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21349 }
21350 {
21351 if (temp2)
21352 delete arg2;
21353 }
21354 return resultobj;
21355 fail:
21356 {
21357 if (temp2)
21358 delete arg2;
21359 }
21360 return NULL;
21361 }
21362
21363
21364 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21365 PyObject *resultobj = 0;
21366 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21367 wxString *arg2 = 0 ;
21368 bool result;
21369 void *argp1 = 0 ;
21370 int res1 = 0 ;
21371 bool temp2 = false ;
21372 PyObject * obj0 = 0 ;
21373 PyObject * obj1 = 0 ;
21374 char * kwnames[] = {
21375 (char *) "self",(char *) "name", NULL
21376 };
21377
21378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21380 if (!SWIG_IsOK(res1)) {
21381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21382 }
21383 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21384 {
21385 arg2 = wxString_in_helper(obj1);
21386 if (arg2 == NULL) SWIG_fail;
21387 temp2 = true;
21388 }
21389 {
21390 PyThreadState* __tstate = wxPyBeginAllowThreads();
21391 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21392 wxPyEndAllowThreads(__tstate);
21393 if (PyErr_Occurred()) SWIG_fail;
21394 }
21395 {
21396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21397 }
21398 {
21399 if (temp2)
21400 delete arg2;
21401 }
21402 return resultobj;
21403 fail:
21404 {
21405 if (temp2)
21406 delete arg2;
21407 }
21408 return NULL;
21409 }
21410
21411
21412 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21413 PyObject *resultobj = 0;
21414 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21415 wxString *arg2 = 0 ;
21416 wxConfigBase::EntryType result;
21417 void *argp1 = 0 ;
21418 int res1 = 0 ;
21419 bool temp2 = false ;
21420 PyObject * obj0 = 0 ;
21421 PyObject * obj1 = 0 ;
21422 char * kwnames[] = {
21423 (char *) "self",(char *) "name", NULL
21424 };
21425
21426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21428 if (!SWIG_IsOK(res1)) {
21429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21430 }
21431 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21432 {
21433 arg2 = wxString_in_helper(obj1);
21434 if (arg2 == NULL) SWIG_fail;
21435 temp2 = true;
21436 }
21437 {
21438 PyThreadState* __tstate = wxPyBeginAllowThreads();
21439 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21440 wxPyEndAllowThreads(__tstate);
21441 if (PyErr_Occurred()) SWIG_fail;
21442 }
21443 resultobj = SWIG_From_int(static_cast< int >(result));
21444 {
21445 if (temp2)
21446 delete arg2;
21447 }
21448 return resultobj;
21449 fail:
21450 {
21451 if (temp2)
21452 delete arg2;
21453 }
21454 return NULL;
21455 }
21456
21457
21458 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21459 PyObject *resultobj = 0;
21460 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21461 wxString *arg2 = 0 ;
21462 wxString const &arg3_defvalue = wxPyEmptyString ;
21463 wxString *arg3 = (wxString *) &arg3_defvalue ;
21464 wxString result;
21465 void *argp1 = 0 ;
21466 int res1 = 0 ;
21467 bool temp2 = false ;
21468 bool temp3 = false ;
21469 PyObject * obj0 = 0 ;
21470 PyObject * obj1 = 0 ;
21471 PyObject * obj2 = 0 ;
21472 char * kwnames[] = {
21473 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21474 };
21475
21476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21478 if (!SWIG_IsOK(res1)) {
21479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21480 }
21481 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21482 {
21483 arg2 = wxString_in_helper(obj1);
21484 if (arg2 == NULL) SWIG_fail;
21485 temp2 = true;
21486 }
21487 if (obj2) {
21488 {
21489 arg3 = wxString_in_helper(obj2);
21490 if (arg3 == NULL) SWIG_fail;
21491 temp3 = true;
21492 }
21493 }
21494 {
21495 PyThreadState* __tstate = wxPyBeginAllowThreads();
21496 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21497 wxPyEndAllowThreads(__tstate);
21498 if (PyErr_Occurred()) SWIG_fail;
21499 }
21500 {
21501 #if wxUSE_UNICODE
21502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21503 #else
21504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21505 #endif
21506 }
21507 {
21508 if (temp2)
21509 delete arg2;
21510 }
21511 {
21512 if (temp3)
21513 delete arg3;
21514 }
21515 return resultobj;
21516 fail:
21517 {
21518 if (temp2)
21519 delete arg2;
21520 }
21521 {
21522 if (temp3)
21523 delete arg3;
21524 }
21525 return NULL;
21526 }
21527
21528
21529 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21530 PyObject *resultobj = 0;
21531 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21532 wxString *arg2 = 0 ;
21533 long arg3 = (long) 0 ;
21534 long result;
21535 void *argp1 = 0 ;
21536 int res1 = 0 ;
21537 bool temp2 = false ;
21538 long val3 ;
21539 int ecode3 = 0 ;
21540 PyObject * obj0 = 0 ;
21541 PyObject * obj1 = 0 ;
21542 PyObject * obj2 = 0 ;
21543 char * kwnames[] = {
21544 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21545 };
21546
21547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21549 if (!SWIG_IsOK(res1)) {
21550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21551 }
21552 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21553 {
21554 arg2 = wxString_in_helper(obj1);
21555 if (arg2 == NULL) SWIG_fail;
21556 temp2 = true;
21557 }
21558 if (obj2) {
21559 ecode3 = SWIG_AsVal_long(obj2, &val3);
21560 if (!SWIG_IsOK(ecode3)) {
21561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21562 }
21563 arg3 = static_cast< long >(val3);
21564 }
21565 {
21566 PyThreadState* __tstate = wxPyBeginAllowThreads();
21567 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21568 wxPyEndAllowThreads(__tstate);
21569 if (PyErr_Occurred()) SWIG_fail;
21570 }
21571 resultobj = SWIG_From_long(static_cast< long >(result));
21572 {
21573 if (temp2)
21574 delete arg2;
21575 }
21576 return resultobj;
21577 fail:
21578 {
21579 if (temp2)
21580 delete arg2;
21581 }
21582 return NULL;
21583 }
21584
21585
21586 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21587 PyObject *resultobj = 0;
21588 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21589 wxString *arg2 = 0 ;
21590 double arg3 = (double) 0.0 ;
21591 double result;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 bool temp2 = false ;
21595 double val3 ;
21596 int ecode3 = 0 ;
21597 PyObject * obj0 = 0 ;
21598 PyObject * obj1 = 0 ;
21599 PyObject * obj2 = 0 ;
21600 char * kwnames[] = {
21601 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21602 };
21603
21604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21606 if (!SWIG_IsOK(res1)) {
21607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21608 }
21609 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21610 {
21611 arg2 = wxString_in_helper(obj1);
21612 if (arg2 == NULL) SWIG_fail;
21613 temp2 = true;
21614 }
21615 if (obj2) {
21616 ecode3 = SWIG_AsVal_double(obj2, &val3);
21617 if (!SWIG_IsOK(ecode3)) {
21618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21619 }
21620 arg3 = static_cast< double >(val3);
21621 }
21622 {
21623 PyThreadState* __tstate = wxPyBeginAllowThreads();
21624 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21625 wxPyEndAllowThreads(__tstate);
21626 if (PyErr_Occurred()) SWIG_fail;
21627 }
21628 resultobj = SWIG_From_double(static_cast< double >(result));
21629 {
21630 if (temp2)
21631 delete arg2;
21632 }
21633 return resultobj;
21634 fail:
21635 {
21636 if (temp2)
21637 delete arg2;
21638 }
21639 return NULL;
21640 }
21641
21642
21643 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21644 PyObject *resultobj = 0;
21645 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21646 wxString *arg2 = 0 ;
21647 bool arg3 = (bool) false ;
21648 bool result;
21649 void *argp1 = 0 ;
21650 int res1 = 0 ;
21651 bool temp2 = false ;
21652 bool val3 ;
21653 int ecode3 = 0 ;
21654 PyObject * obj0 = 0 ;
21655 PyObject * obj1 = 0 ;
21656 PyObject * obj2 = 0 ;
21657 char * kwnames[] = {
21658 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21659 };
21660
21661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21663 if (!SWIG_IsOK(res1)) {
21664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21665 }
21666 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21667 {
21668 arg2 = wxString_in_helper(obj1);
21669 if (arg2 == NULL) SWIG_fail;
21670 temp2 = true;
21671 }
21672 if (obj2) {
21673 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21674 if (!SWIG_IsOK(ecode3)) {
21675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21676 }
21677 arg3 = static_cast< bool >(val3);
21678 }
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21682 wxPyEndAllowThreads(__tstate);
21683 if (PyErr_Occurred()) SWIG_fail;
21684 }
21685 {
21686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21687 }
21688 {
21689 if (temp2)
21690 delete arg2;
21691 }
21692 return resultobj;
21693 fail:
21694 {
21695 if (temp2)
21696 delete arg2;
21697 }
21698 return NULL;
21699 }
21700
21701
21702 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21703 PyObject *resultobj = 0;
21704 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21705 wxString *arg2 = 0 ;
21706 wxString *arg3 = 0 ;
21707 bool result;
21708 void *argp1 = 0 ;
21709 int res1 = 0 ;
21710 bool temp2 = false ;
21711 bool temp3 = false ;
21712 PyObject * obj0 = 0 ;
21713 PyObject * obj1 = 0 ;
21714 PyObject * obj2 = 0 ;
21715 char * kwnames[] = {
21716 (char *) "self",(char *) "key",(char *) "value", NULL
21717 };
21718
21719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21723 }
21724 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21725 {
21726 arg2 = wxString_in_helper(obj1);
21727 if (arg2 == NULL) SWIG_fail;
21728 temp2 = true;
21729 }
21730 {
21731 arg3 = wxString_in_helper(obj2);
21732 if (arg3 == NULL) SWIG_fail;
21733 temp3 = true;
21734 }
21735 {
21736 PyThreadState* __tstate = wxPyBeginAllowThreads();
21737 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21738 wxPyEndAllowThreads(__tstate);
21739 if (PyErr_Occurred()) SWIG_fail;
21740 }
21741 {
21742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21743 }
21744 {
21745 if (temp2)
21746 delete arg2;
21747 }
21748 {
21749 if (temp3)
21750 delete arg3;
21751 }
21752 return resultobj;
21753 fail:
21754 {
21755 if (temp2)
21756 delete arg2;
21757 }
21758 {
21759 if (temp3)
21760 delete arg3;
21761 }
21762 return NULL;
21763 }
21764
21765
21766 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21767 PyObject *resultobj = 0;
21768 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21769 wxString *arg2 = 0 ;
21770 long arg3 ;
21771 bool result;
21772 void *argp1 = 0 ;
21773 int res1 = 0 ;
21774 bool temp2 = false ;
21775 long val3 ;
21776 int ecode3 = 0 ;
21777 PyObject * obj0 = 0 ;
21778 PyObject * obj1 = 0 ;
21779 PyObject * obj2 = 0 ;
21780 char * kwnames[] = {
21781 (char *) "self",(char *) "key",(char *) "value", NULL
21782 };
21783
21784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21786 if (!SWIG_IsOK(res1)) {
21787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21788 }
21789 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21790 {
21791 arg2 = wxString_in_helper(obj1);
21792 if (arg2 == NULL) SWIG_fail;
21793 temp2 = true;
21794 }
21795 ecode3 = SWIG_AsVal_long(obj2, &val3);
21796 if (!SWIG_IsOK(ecode3)) {
21797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21798 }
21799 arg3 = static_cast< long >(val3);
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 {
21807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21808 }
21809 {
21810 if (temp2)
21811 delete arg2;
21812 }
21813 return resultobj;
21814 fail:
21815 {
21816 if (temp2)
21817 delete arg2;
21818 }
21819 return NULL;
21820 }
21821
21822
21823 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj = 0;
21825 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21826 wxString *arg2 = 0 ;
21827 double arg3 ;
21828 bool result;
21829 void *argp1 = 0 ;
21830 int res1 = 0 ;
21831 bool temp2 = false ;
21832 double val3 ;
21833 int ecode3 = 0 ;
21834 PyObject * obj0 = 0 ;
21835 PyObject * obj1 = 0 ;
21836 PyObject * obj2 = 0 ;
21837 char * kwnames[] = {
21838 (char *) "self",(char *) "key",(char *) "value", NULL
21839 };
21840
21841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21843 if (!SWIG_IsOK(res1)) {
21844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21845 }
21846 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21847 {
21848 arg2 = wxString_in_helper(obj1);
21849 if (arg2 == NULL) SWIG_fail;
21850 temp2 = true;
21851 }
21852 ecode3 = SWIG_AsVal_double(obj2, &val3);
21853 if (!SWIG_IsOK(ecode3)) {
21854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21855 }
21856 arg3 = static_cast< double >(val3);
21857 {
21858 PyThreadState* __tstate = wxPyBeginAllowThreads();
21859 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21860 wxPyEndAllowThreads(__tstate);
21861 if (PyErr_Occurred()) SWIG_fail;
21862 }
21863 {
21864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21865 }
21866 {
21867 if (temp2)
21868 delete arg2;
21869 }
21870 return resultobj;
21871 fail:
21872 {
21873 if (temp2)
21874 delete arg2;
21875 }
21876 return NULL;
21877 }
21878
21879
21880 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21881 PyObject *resultobj = 0;
21882 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21883 wxString *arg2 = 0 ;
21884 bool arg3 ;
21885 bool result;
21886 void *argp1 = 0 ;
21887 int res1 = 0 ;
21888 bool temp2 = false ;
21889 bool val3 ;
21890 int ecode3 = 0 ;
21891 PyObject * obj0 = 0 ;
21892 PyObject * obj1 = 0 ;
21893 PyObject * obj2 = 0 ;
21894 char * kwnames[] = {
21895 (char *) "self",(char *) "key",(char *) "value", NULL
21896 };
21897
21898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21900 if (!SWIG_IsOK(res1)) {
21901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21902 }
21903 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21904 {
21905 arg2 = wxString_in_helper(obj1);
21906 if (arg2 == NULL) SWIG_fail;
21907 temp2 = true;
21908 }
21909 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21910 if (!SWIG_IsOK(ecode3)) {
21911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21912 }
21913 arg3 = static_cast< bool >(val3);
21914 {
21915 PyThreadState* __tstate = wxPyBeginAllowThreads();
21916 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 {
21921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21922 }
21923 {
21924 if (temp2)
21925 delete arg2;
21926 }
21927 return resultobj;
21928 fail:
21929 {
21930 if (temp2)
21931 delete arg2;
21932 }
21933 return NULL;
21934 }
21935
21936
21937 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21938 PyObject *resultobj = 0;
21939 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21940 bool arg2 = (bool) false ;
21941 bool result;
21942 void *argp1 = 0 ;
21943 int res1 = 0 ;
21944 bool val2 ;
21945 int ecode2 = 0 ;
21946 PyObject * obj0 = 0 ;
21947 PyObject * obj1 = 0 ;
21948 char * kwnames[] = {
21949 (char *) "self",(char *) "currentOnly", NULL
21950 };
21951
21952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21954 if (!SWIG_IsOK(res1)) {
21955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21956 }
21957 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21958 if (obj1) {
21959 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21960 if (!SWIG_IsOK(ecode2)) {
21961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21962 }
21963 arg2 = static_cast< bool >(val2);
21964 }
21965 {
21966 PyThreadState* __tstate = wxPyBeginAllowThreads();
21967 result = (bool)(arg1)->Flush(arg2);
21968 wxPyEndAllowThreads(__tstate);
21969 if (PyErr_Occurred()) SWIG_fail;
21970 }
21971 {
21972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21973 }
21974 return resultobj;
21975 fail:
21976 return NULL;
21977 }
21978
21979
21980 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21981 PyObject *resultobj = 0;
21982 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21983 wxString *arg2 = 0 ;
21984 wxString *arg3 = 0 ;
21985 bool result;
21986 void *argp1 = 0 ;
21987 int res1 = 0 ;
21988 bool temp2 = false ;
21989 bool temp3 = false ;
21990 PyObject * obj0 = 0 ;
21991 PyObject * obj1 = 0 ;
21992 PyObject * obj2 = 0 ;
21993 char * kwnames[] = {
21994 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21995 };
21996
21997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21999 if (!SWIG_IsOK(res1)) {
22000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22001 }
22002 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22003 {
22004 arg2 = wxString_in_helper(obj1);
22005 if (arg2 == NULL) SWIG_fail;
22006 temp2 = true;
22007 }
22008 {
22009 arg3 = wxString_in_helper(obj2);
22010 if (arg3 == NULL) SWIG_fail;
22011 temp3 = true;
22012 }
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 {
22020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22021 }
22022 {
22023 if (temp2)
22024 delete arg2;
22025 }
22026 {
22027 if (temp3)
22028 delete arg3;
22029 }
22030 return resultobj;
22031 fail:
22032 {
22033 if (temp2)
22034 delete arg2;
22035 }
22036 {
22037 if (temp3)
22038 delete arg3;
22039 }
22040 return NULL;
22041 }
22042
22043
22044 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22045 PyObject *resultobj = 0;
22046 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22047 wxString *arg2 = 0 ;
22048 wxString *arg3 = 0 ;
22049 bool result;
22050 void *argp1 = 0 ;
22051 int res1 = 0 ;
22052 bool temp2 = false ;
22053 bool temp3 = false ;
22054 PyObject * obj0 = 0 ;
22055 PyObject * obj1 = 0 ;
22056 PyObject * obj2 = 0 ;
22057 char * kwnames[] = {
22058 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22059 };
22060
22061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22063 if (!SWIG_IsOK(res1)) {
22064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22065 }
22066 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22067 {
22068 arg2 = wxString_in_helper(obj1);
22069 if (arg2 == NULL) SWIG_fail;
22070 temp2 = true;
22071 }
22072 {
22073 arg3 = wxString_in_helper(obj2);
22074 if (arg3 == NULL) SWIG_fail;
22075 temp3 = true;
22076 }
22077 {
22078 PyThreadState* __tstate = wxPyBeginAllowThreads();
22079 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22080 wxPyEndAllowThreads(__tstate);
22081 if (PyErr_Occurred()) SWIG_fail;
22082 }
22083 {
22084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22085 }
22086 {
22087 if (temp2)
22088 delete arg2;
22089 }
22090 {
22091 if (temp3)
22092 delete arg3;
22093 }
22094 return resultobj;
22095 fail:
22096 {
22097 if (temp2)
22098 delete arg2;
22099 }
22100 {
22101 if (temp3)
22102 delete arg3;
22103 }
22104 return NULL;
22105 }
22106
22107
22108 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22109 PyObject *resultobj = 0;
22110 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22111 wxString *arg2 = 0 ;
22112 bool arg3 = (bool) true ;
22113 bool result;
22114 void *argp1 = 0 ;
22115 int res1 = 0 ;
22116 bool temp2 = false ;
22117 bool val3 ;
22118 int ecode3 = 0 ;
22119 PyObject * obj0 = 0 ;
22120 PyObject * obj1 = 0 ;
22121 PyObject * obj2 = 0 ;
22122 char * kwnames[] = {
22123 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22124 };
22125
22126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22130 }
22131 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22132 {
22133 arg2 = wxString_in_helper(obj1);
22134 if (arg2 == NULL) SWIG_fail;
22135 temp2 = true;
22136 }
22137 if (obj2) {
22138 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22139 if (!SWIG_IsOK(ecode3)) {
22140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22141 }
22142 arg3 = static_cast< bool >(val3);
22143 }
22144 {
22145 PyThreadState* __tstate = wxPyBeginAllowThreads();
22146 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22147 wxPyEndAllowThreads(__tstate);
22148 if (PyErr_Occurred()) SWIG_fail;
22149 }
22150 {
22151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22152 }
22153 {
22154 if (temp2)
22155 delete arg2;
22156 }
22157 return resultobj;
22158 fail:
22159 {
22160 if (temp2)
22161 delete arg2;
22162 }
22163 return NULL;
22164 }
22165
22166
22167 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj = 0;
22169 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22170 wxString *arg2 = 0 ;
22171 bool result;
22172 void *argp1 = 0 ;
22173 int res1 = 0 ;
22174 bool temp2 = false ;
22175 PyObject * obj0 = 0 ;
22176 PyObject * obj1 = 0 ;
22177 char * kwnames[] = {
22178 (char *) "self",(char *) "key", NULL
22179 };
22180
22181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22183 if (!SWIG_IsOK(res1)) {
22184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22185 }
22186 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22187 {
22188 arg2 = wxString_in_helper(obj1);
22189 if (arg2 == NULL) SWIG_fail;
22190 temp2 = true;
22191 }
22192 {
22193 PyThreadState* __tstate = wxPyBeginAllowThreads();
22194 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 {
22199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22200 }
22201 {
22202 if (temp2)
22203 delete arg2;
22204 }
22205 return resultobj;
22206 fail:
22207 {
22208 if (temp2)
22209 delete arg2;
22210 }
22211 return NULL;
22212 }
22213
22214
22215 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22216 PyObject *resultobj = 0;
22217 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22218 bool result;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 PyObject *swig_obj[1] ;
22222
22223 if (!args) SWIG_fail;
22224 swig_obj[0] = args;
22225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22226 if (!SWIG_IsOK(res1)) {
22227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22228 }
22229 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = (bool)(arg1)->DeleteAll();
22233 wxPyEndAllowThreads(__tstate);
22234 if (PyErr_Occurred()) SWIG_fail;
22235 }
22236 {
22237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22238 }
22239 return resultobj;
22240 fail:
22241 return NULL;
22242 }
22243
22244
22245 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22246 PyObject *resultobj = 0;
22247 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22248 bool arg2 = (bool) true ;
22249 void *argp1 = 0 ;
22250 int res1 = 0 ;
22251 bool val2 ;
22252 int ecode2 = 0 ;
22253 PyObject * obj0 = 0 ;
22254 PyObject * obj1 = 0 ;
22255 char * kwnames[] = {
22256 (char *) "self",(char *) "doIt", NULL
22257 };
22258
22259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22261 if (!SWIG_IsOK(res1)) {
22262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22263 }
22264 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22265 if (obj1) {
22266 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22267 if (!SWIG_IsOK(ecode2)) {
22268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22269 }
22270 arg2 = static_cast< bool >(val2);
22271 }
22272 {
22273 PyThreadState* __tstate = wxPyBeginAllowThreads();
22274 (arg1)->SetExpandEnvVars(arg2);
22275 wxPyEndAllowThreads(__tstate);
22276 if (PyErr_Occurred()) SWIG_fail;
22277 }
22278 resultobj = SWIG_Py_Void();
22279 return resultobj;
22280 fail:
22281 return NULL;
22282 }
22283
22284
22285 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22286 PyObject *resultobj = 0;
22287 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22288 bool result;
22289 void *argp1 = 0 ;
22290 int res1 = 0 ;
22291 PyObject *swig_obj[1] ;
22292
22293 if (!args) SWIG_fail;
22294 swig_obj[0] = args;
22295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22296 if (!SWIG_IsOK(res1)) {
22297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22298 }
22299 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 {
22307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22308 }
22309 return resultobj;
22310 fail:
22311 return NULL;
22312 }
22313
22314
22315 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22316 PyObject *resultobj = 0;
22317 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22318 bool arg2 = (bool) true ;
22319 void *argp1 = 0 ;
22320 int res1 = 0 ;
22321 bool val2 ;
22322 int ecode2 = 0 ;
22323 PyObject * obj0 = 0 ;
22324 PyObject * obj1 = 0 ;
22325 char * kwnames[] = {
22326 (char *) "self",(char *) "doIt", NULL
22327 };
22328
22329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22331 if (!SWIG_IsOK(res1)) {
22332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22333 }
22334 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22335 if (obj1) {
22336 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22337 if (!SWIG_IsOK(ecode2)) {
22338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22339 }
22340 arg2 = static_cast< bool >(val2);
22341 }
22342 {
22343 PyThreadState* __tstate = wxPyBeginAllowThreads();
22344 (arg1)->SetRecordDefaults(arg2);
22345 wxPyEndAllowThreads(__tstate);
22346 if (PyErr_Occurred()) SWIG_fail;
22347 }
22348 resultobj = SWIG_Py_Void();
22349 return resultobj;
22350 fail:
22351 return NULL;
22352 }
22353
22354
22355 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22356 PyObject *resultobj = 0;
22357 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22358 bool result;
22359 void *argp1 = 0 ;
22360 int res1 = 0 ;
22361 PyObject *swig_obj[1] ;
22362
22363 if (!args) SWIG_fail;
22364 swig_obj[0] = args;
22365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22366 if (!SWIG_IsOK(res1)) {
22367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22368 }
22369 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22370 {
22371 PyThreadState* __tstate = wxPyBeginAllowThreads();
22372 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 {
22377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22378 }
22379 return resultobj;
22380 fail:
22381 return NULL;
22382 }
22383
22384
22385 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22386 PyObject *resultobj = 0;
22387 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22388 wxString *arg2 = 0 ;
22389 wxString result;
22390 void *argp1 = 0 ;
22391 int res1 = 0 ;
22392 bool temp2 = false ;
22393 PyObject * obj0 = 0 ;
22394 PyObject * obj1 = 0 ;
22395 char * kwnames[] = {
22396 (char *) "self",(char *) "str", NULL
22397 };
22398
22399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22401 if (!SWIG_IsOK(res1)) {
22402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22403 }
22404 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22405 {
22406 arg2 = wxString_in_helper(obj1);
22407 if (arg2 == NULL) SWIG_fail;
22408 temp2 = true;
22409 }
22410 {
22411 PyThreadState* __tstate = wxPyBeginAllowThreads();
22412 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22413 wxPyEndAllowThreads(__tstate);
22414 if (PyErr_Occurred()) SWIG_fail;
22415 }
22416 {
22417 #if wxUSE_UNICODE
22418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22419 #else
22420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22421 #endif
22422 }
22423 {
22424 if (temp2)
22425 delete arg2;
22426 }
22427 return resultobj;
22428 fail:
22429 {
22430 if (temp2)
22431 delete arg2;
22432 }
22433 return NULL;
22434 }
22435
22436
22437 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22438 PyObject *resultobj = 0;
22439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22440 wxString result;
22441 void *argp1 = 0 ;
22442 int res1 = 0 ;
22443 PyObject *swig_obj[1] ;
22444
22445 if (!args) SWIG_fail;
22446 swig_obj[0] = args;
22447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22448 if (!SWIG_IsOK(res1)) {
22449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22450 }
22451 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 result = ((wxConfigBase const *)arg1)->GetAppName();
22455 wxPyEndAllowThreads(__tstate);
22456 if (PyErr_Occurred()) SWIG_fail;
22457 }
22458 {
22459 #if wxUSE_UNICODE
22460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22461 #else
22462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22463 #endif
22464 }
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22472 PyObject *resultobj = 0;
22473 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22474 wxString result;
22475 void *argp1 = 0 ;
22476 int res1 = 0 ;
22477 PyObject *swig_obj[1] ;
22478
22479 if (!args) SWIG_fail;
22480 swig_obj[0] = args;
22481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22482 if (!SWIG_IsOK(res1)) {
22483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22484 }
22485 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22486 {
22487 PyThreadState* __tstate = wxPyBeginAllowThreads();
22488 result = ((wxConfigBase const *)arg1)->GetVendorName();
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 {
22493 #if wxUSE_UNICODE
22494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22495 #else
22496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22497 #endif
22498 }
22499 return resultobj;
22500 fail:
22501 return NULL;
22502 }
22503
22504
22505 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22506 PyObject *resultobj = 0;
22507 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22508 wxString *arg2 = 0 ;
22509 void *argp1 = 0 ;
22510 int res1 = 0 ;
22511 bool temp2 = false ;
22512 PyObject * obj0 = 0 ;
22513 PyObject * obj1 = 0 ;
22514 char * kwnames[] = {
22515 (char *) "self",(char *) "appName", NULL
22516 };
22517
22518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22520 if (!SWIG_IsOK(res1)) {
22521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22522 }
22523 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22524 {
22525 arg2 = wxString_in_helper(obj1);
22526 if (arg2 == NULL) SWIG_fail;
22527 temp2 = true;
22528 }
22529 {
22530 PyThreadState* __tstate = wxPyBeginAllowThreads();
22531 (arg1)->SetAppName((wxString const &)*arg2);
22532 wxPyEndAllowThreads(__tstate);
22533 if (PyErr_Occurred()) SWIG_fail;
22534 }
22535 resultobj = SWIG_Py_Void();
22536 {
22537 if (temp2)
22538 delete arg2;
22539 }
22540 return resultobj;
22541 fail:
22542 {
22543 if (temp2)
22544 delete arg2;
22545 }
22546 return NULL;
22547 }
22548
22549
22550 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22551 PyObject *resultobj = 0;
22552 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22553 wxString *arg2 = 0 ;
22554 void *argp1 = 0 ;
22555 int res1 = 0 ;
22556 bool temp2 = false ;
22557 PyObject * obj0 = 0 ;
22558 PyObject * obj1 = 0 ;
22559 char * kwnames[] = {
22560 (char *) "self",(char *) "vendorName", NULL
22561 };
22562
22563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22565 if (!SWIG_IsOK(res1)) {
22566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22567 }
22568 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22569 {
22570 arg2 = wxString_in_helper(obj1);
22571 if (arg2 == NULL) SWIG_fail;
22572 temp2 = true;
22573 }
22574 {
22575 PyThreadState* __tstate = wxPyBeginAllowThreads();
22576 (arg1)->SetVendorName((wxString const &)*arg2);
22577 wxPyEndAllowThreads(__tstate);
22578 if (PyErr_Occurred()) SWIG_fail;
22579 }
22580 resultobj = SWIG_Py_Void();
22581 {
22582 if (temp2)
22583 delete arg2;
22584 }
22585 return resultobj;
22586 fail:
22587 {
22588 if (temp2)
22589 delete arg2;
22590 }
22591 return NULL;
22592 }
22593
22594
22595 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22596 PyObject *resultobj = 0;
22597 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22598 long arg2 ;
22599 void *argp1 = 0 ;
22600 int res1 = 0 ;
22601 long val2 ;
22602 int ecode2 = 0 ;
22603 PyObject * obj0 = 0 ;
22604 PyObject * obj1 = 0 ;
22605 char * kwnames[] = {
22606 (char *) "self",(char *) "style", NULL
22607 };
22608
22609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22611 if (!SWIG_IsOK(res1)) {
22612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22613 }
22614 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22615 ecode2 = SWIG_AsVal_long(obj1, &val2);
22616 if (!SWIG_IsOK(ecode2)) {
22617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22618 }
22619 arg2 = static_cast< long >(val2);
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 (arg1)->SetStyle(arg2);
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 resultobj = SWIG_Py_Void();
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22634 PyObject *resultobj = 0;
22635 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22636 long result;
22637 void *argp1 = 0 ;
22638 int res1 = 0 ;
22639 PyObject *swig_obj[1] ;
22640
22641 if (!args) SWIG_fail;
22642 swig_obj[0] = args;
22643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22644 if (!SWIG_IsOK(res1)) {
22645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22646 }
22647 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22648 {
22649 PyThreadState* __tstate = wxPyBeginAllowThreads();
22650 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22651 wxPyEndAllowThreads(__tstate);
22652 if (PyErr_Occurred()) SWIG_fail;
22653 }
22654 resultobj = SWIG_From_long(static_cast< long >(result));
22655 return resultobj;
22656 fail:
22657 return NULL;
22658 }
22659
22660
22661 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22662 PyObject *obj;
22663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22664 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22665 return SWIG_Py_Void();
22666 }
22667
22668 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22669 PyObject *resultobj = 0;
22670 wxString const &arg1_defvalue = wxPyEmptyString ;
22671 wxString *arg1 = (wxString *) &arg1_defvalue ;
22672 wxString const &arg2_defvalue = wxPyEmptyString ;
22673 wxString *arg2 = (wxString *) &arg2_defvalue ;
22674 wxString const &arg3_defvalue = wxPyEmptyString ;
22675 wxString *arg3 = (wxString *) &arg3_defvalue ;
22676 wxString const &arg4_defvalue = wxPyEmptyString ;
22677 wxString *arg4 = (wxString *) &arg4_defvalue ;
22678 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22679 wxConfig *result = 0 ;
22680 bool temp1 = false ;
22681 bool temp2 = false ;
22682 bool temp3 = false ;
22683 bool temp4 = false ;
22684 long val5 ;
22685 int ecode5 = 0 ;
22686 PyObject * obj0 = 0 ;
22687 PyObject * obj1 = 0 ;
22688 PyObject * obj2 = 0 ;
22689 PyObject * obj3 = 0 ;
22690 PyObject * obj4 = 0 ;
22691 char * kwnames[] = {
22692 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22693 };
22694
22695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22696 if (obj0) {
22697 {
22698 arg1 = wxString_in_helper(obj0);
22699 if (arg1 == NULL) SWIG_fail;
22700 temp1 = true;
22701 }
22702 }
22703 if (obj1) {
22704 {
22705 arg2 = wxString_in_helper(obj1);
22706 if (arg2 == NULL) SWIG_fail;
22707 temp2 = true;
22708 }
22709 }
22710 if (obj2) {
22711 {
22712 arg3 = wxString_in_helper(obj2);
22713 if (arg3 == NULL) SWIG_fail;
22714 temp3 = true;
22715 }
22716 }
22717 if (obj3) {
22718 {
22719 arg4 = wxString_in_helper(obj3);
22720 if (arg4 == NULL) SWIG_fail;
22721 temp4 = true;
22722 }
22723 }
22724 if (obj4) {
22725 ecode5 = SWIG_AsVal_long(obj4, &val5);
22726 if (!SWIG_IsOK(ecode5)) {
22727 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22728 }
22729 arg5 = static_cast< long >(val5);
22730 }
22731 {
22732 PyThreadState* __tstate = wxPyBeginAllowThreads();
22733 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22734 wxPyEndAllowThreads(__tstate);
22735 if (PyErr_Occurred()) SWIG_fail;
22736 }
22737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22738 {
22739 if (temp1)
22740 delete arg1;
22741 }
22742 {
22743 if (temp2)
22744 delete arg2;
22745 }
22746 {
22747 if (temp3)
22748 delete arg3;
22749 }
22750 {
22751 if (temp4)
22752 delete arg4;
22753 }
22754 return resultobj;
22755 fail:
22756 {
22757 if (temp1)
22758 delete arg1;
22759 }
22760 {
22761 if (temp2)
22762 delete arg2;
22763 }
22764 {
22765 if (temp3)
22766 delete arg3;
22767 }
22768 {
22769 if (temp4)
22770 delete arg4;
22771 }
22772 return NULL;
22773 }
22774
22775
22776 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22777 PyObject *resultobj = 0;
22778 wxConfig *arg1 = (wxConfig *) 0 ;
22779 void *argp1 = 0 ;
22780 int res1 = 0 ;
22781 PyObject *swig_obj[1] ;
22782
22783 if (!args) SWIG_fail;
22784 swig_obj[0] = args;
22785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22786 if (!SWIG_IsOK(res1)) {
22787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22788 }
22789 arg1 = reinterpret_cast< wxConfig * >(argp1);
22790 {
22791 PyThreadState* __tstate = wxPyBeginAllowThreads();
22792 delete arg1;
22793
22794 wxPyEndAllowThreads(__tstate);
22795 if (PyErr_Occurred()) SWIG_fail;
22796 }
22797 resultobj = SWIG_Py_Void();
22798 return resultobj;
22799 fail:
22800 return NULL;
22801 }
22802
22803
22804 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22805 PyObject *obj;
22806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22807 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22808 return SWIG_Py_Void();
22809 }
22810
22811 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22812 return SWIG_Python_InitShadowInstance(args);
22813 }
22814
22815 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22816 PyObject *resultobj = 0;
22817 wxString const &arg1_defvalue = wxPyEmptyString ;
22818 wxString *arg1 = (wxString *) &arg1_defvalue ;
22819 wxString const &arg2_defvalue = wxPyEmptyString ;
22820 wxString *arg2 = (wxString *) &arg2_defvalue ;
22821 wxString const &arg3_defvalue = wxPyEmptyString ;
22822 wxString *arg3 = (wxString *) &arg3_defvalue ;
22823 wxString const &arg4_defvalue = wxPyEmptyString ;
22824 wxString *arg4 = (wxString *) &arg4_defvalue ;
22825 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22826 wxFileConfig *result = 0 ;
22827 bool temp1 = false ;
22828 bool temp2 = false ;
22829 bool temp3 = false ;
22830 bool temp4 = false ;
22831 long val5 ;
22832 int ecode5 = 0 ;
22833 PyObject * obj0 = 0 ;
22834 PyObject * obj1 = 0 ;
22835 PyObject * obj2 = 0 ;
22836 PyObject * obj3 = 0 ;
22837 PyObject * obj4 = 0 ;
22838 char * kwnames[] = {
22839 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22840 };
22841
22842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22843 if (obj0) {
22844 {
22845 arg1 = wxString_in_helper(obj0);
22846 if (arg1 == NULL) SWIG_fail;
22847 temp1 = true;
22848 }
22849 }
22850 if (obj1) {
22851 {
22852 arg2 = wxString_in_helper(obj1);
22853 if (arg2 == NULL) SWIG_fail;
22854 temp2 = true;
22855 }
22856 }
22857 if (obj2) {
22858 {
22859 arg3 = wxString_in_helper(obj2);
22860 if (arg3 == NULL) SWIG_fail;
22861 temp3 = true;
22862 }
22863 }
22864 if (obj3) {
22865 {
22866 arg4 = wxString_in_helper(obj3);
22867 if (arg4 == NULL) SWIG_fail;
22868 temp4 = true;
22869 }
22870 }
22871 if (obj4) {
22872 ecode5 = SWIG_AsVal_long(obj4, &val5);
22873 if (!SWIG_IsOK(ecode5)) {
22874 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22875 }
22876 arg5 = static_cast< long >(val5);
22877 }
22878 {
22879 PyThreadState* __tstate = wxPyBeginAllowThreads();
22880 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22881 wxPyEndAllowThreads(__tstate);
22882 if (PyErr_Occurred()) SWIG_fail;
22883 }
22884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22885 {
22886 if (temp1)
22887 delete arg1;
22888 }
22889 {
22890 if (temp2)
22891 delete arg2;
22892 }
22893 {
22894 if (temp3)
22895 delete arg3;
22896 }
22897 {
22898 if (temp4)
22899 delete arg4;
22900 }
22901 return resultobj;
22902 fail:
22903 {
22904 if (temp1)
22905 delete arg1;
22906 }
22907 {
22908 if (temp2)
22909 delete arg2;
22910 }
22911 {
22912 if (temp3)
22913 delete arg3;
22914 }
22915 {
22916 if (temp4)
22917 delete arg4;
22918 }
22919 return NULL;
22920 }
22921
22922
22923 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22924 PyObject *resultobj = 0;
22925 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22926 void *argp1 = 0 ;
22927 int res1 = 0 ;
22928 PyObject *swig_obj[1] ;
22929
22930 if (!args) SWIG_fail;
22931 swig_obj[0] = args;
22932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22933 if (!SWIG_IsOK(res1)) {
22934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22935 }
22936 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22937 {
22938 PyThreadState* __tstate = wxPyBeginAllowThreads();
22939 delete arg1;
22940
22941 wxPyEndAllowThreads(__tstate);
22942 if (PyErr_Occurred()) SWIG_fail;
22943 }
22944 resultobj = SWIG_Py_Void();
22945 return resultobj;
22946 fail:
22947 return NULL;
22948 }
22949
22950
22951 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22952 PyObject *obj;
22953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22954 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22955 return SWIG_Py_Void();
22956 }
22957
22958 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22959 return SWIG_Python_InitShadowInstance(args);
22960 }
22961
22962 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22963 PyObject *resultobj = 0;
22964 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22965 wxString *arg2 = 0 ;
22966 wxConfigPathChanger *result = 0 ;
22967 void *argp1 = 0 ;
22968 int res1 = 0 ;
22969 bool temp2 = false ;
22970 PyObject * obj0 = 0 ;
22971 PyObject * obj1 = 0 ;
22972 char * kwnames[] = {
22973 (char *) "config",(char *) "entry", NULL
22974 };
22975
22976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22978 if (!SWIG_IsOK(res1)) {
22979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22980 }
22981 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22982 {
22983 arg2 = wxString_in_helper(obj1);
22984 if (arg2 == NULL) SWIG_fail;
22985 temp2 = true;
22986 }
22987 {
22988 PyThreadState* __tstate = wxPyBeginAllowThreads();
22989 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22990 wxPyEndAllowThreads(__tstate);
22991 if (PyErr_Occurred()) SWIG_fail;
22992 }
22993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22994 {
22995 if (temp2)
22996 delete arg2;
22997 }
22998 return resultobj;
22999 fail:
23000 {
23001 if (temp2)
23002 delete arg2;
23003 }
23004 return NULL;
23005 }
23006
23007
23008 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23009 PyObject *resultobj = 0;
23010 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23011 void *argp1 = 0 ;
23012 int res1 = 0 ;
23013 PyObject *swig_obj[1] ;
23014
23015 if (!args) SWIG_fail;
23016 swig_obj[0] = args;
23017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23018 if (!SWIG_IsOK(res1)) {
23019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23020 }
23021 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23022 {
23023 PyThreadState* __tstate = wxPyBeginAllowThreads();
23024 delete arg1;
23025
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 resultobj = SWIG_Py_Void();
23030 return resultobj;
23031 fail:
23032 return NULL;
23033 }
23034
23035
23036 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23037 PyObject *resultobj = 0;
23038 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23039 wxString *result = 0 ;
23040 void *argp1 = 0 ;
23041 int res1 = 0 ;
23042 PyObject *swig_obj[1] ;
23043
23044 if (!args) SWIG_fail;
23045 swig_obj[0] = args;
23046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23047 if (!SWIG_IsOK(res1)) {
23048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23049 }
23050 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23051 {
23052 PyThreadState* __tstate = wxPyBeginAllowThreads();
23053 {
23054 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23055 result = (wxString *) &_result_ref;
23056 }
23057 wxPyEndAllowThreads(__tstate);
23058 if (PyErr_Occurred()) SWIG_fail;
23059 }
23060 {
23061 #if wxUSE_UNICODE
23062 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23063 #else
23064 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23065 #endif
23066 }
23067 return resultobj;
23068 fail:
23069 return NULL;
23070 }
23071
23072
23073 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23074 PyObject *obj;
23075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23076 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23077 return SWIG_Py_Void();
23078 }
23079
23080 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 return SWIG_Python_InitShadowInstance(args);
23082 }
23083
23084 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23085 PyObject *resultobj = 0;
23086 wxString *arg1 = 0 ;
23087 wxString result;
23088 bool temp1 = false ;
23089 PyObject * obj0 = 0 ;
23090 char * kwnames[] = {
23091 (char *) "sz", NULL
23092 };
23093
23094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23095 {
23096 arg1 = wxString_in_helper(obj0);
23097 if (arg1 == NULL) SWIG_fail;
23098 temp1 = true;
23099 }
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = wxExpandEnvVars((wxString const &)*arg1);
23103 wxPyEndAllowThreads(__tstate);
23104 if (PyErr_Occurred()) SWIG_fail;
23105 }
23106 {
23107 #if wxUSE_UNICODE
23108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23109 #else
23110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23111 #endif
23112 }
23113 {
23114 if (temp1)
23115 delete arg1;
23116 }
23117 return resultobj;
23118 fail:
23119 {
23120 if (temp1)
23121 delete arg1;
23122 }
23123 return NULL;
23124 }
23125
23126
23127 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23128 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23129 return 1;
23130 }
23131
23132
23133 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23134 PyObject *pyobj = 0;
23135
23136 {
23137 #if wxUSE_UNICODE
23138 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23139 #else
23140 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23141 #endif
23142 }
23143 return pyobj;
23144 }
23145
23146
23147 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23148 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23149 return 1;
23150 }
23151
23152
23153 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23154 PyObject *pyobj = 0;
23155
23156 {
23157 #if wxUSE_UNICODE
23158 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23159 #else
23160 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23161 #endif
23162 }
23163 return pyobj;
23164 }
23165
23166
23167 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23168 PyObject *resultobj = 0;
23169 wxDateTime::Country arg1 ;
23170 int val1 ;
23171 int ecode1 = 0 ;
23172 PyObject * obj0 = 0 ;
23173 char * kwnames[] = {
23174 (char *) "country", NULL
23175 };
23176
23177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23178 ecode1 = SWIG_AsVal_int(obj0, &val1);
23179 if (!SWIG_IsOK(ecode1)) {
23180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23181 }
23182 arg1 = static_cast< wxDateTime::Country >(val1);
23183 {
23184 PyThreadState* __tstate = wxPyBeginAllowThreads();
23185 wxDateTime::SetCountry(arg1);
23186 wxPyEndAllowThreads(__tstate);
23187 if (PyErr_Occurred()) SWIG_fail;
23188 }
23189 resultobj = SWIG_Py_Void();
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23197 PyObject *resultobj = 0;
23198 wxDateTime::Country result;
23199
23200 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23201 {
23202 PyThreadState* __tstate = wxPyBeginAllowThreads();
23203 result = (wxDateTime::Country)wxDateTime::GetCountry();
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 resultobj = SWIG_From_int(static_cast< int >(result));
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23215 PyObject *resultobj = 0;
23216 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23217 bool result;
23218 int val1 ;
23219 int ecode1 = 0 ;
23220 PyObject * obj0 = 0 ;
23221 char * kwnames[] = {
23222 (char *) "country", NULL
23223 };
23224
23225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23226 if (obj0) {
23227 ecode1 = SWIG_AsVal_int(obj0, &val1);
23228 if (!SWIG_IsOK(ecode1)) {
23229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23230 }
23231 arg1 = static_cast< wxDateTime::Country >(val1);
23232 }
23233 {
23234 PyThreadState* __tstate = wxPyBeginAllowThreads();
23235 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23236 wxPyEndAllowThreads(__tstate);
23237 if (PyErr_Occurred()) SWIG_fail;
23238 }
23239 {
23240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23241 }
23242 return resultobj;
23243 fail:
23244 return NULL;
23245 }
23246
23247
23248 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23249 PyObject *resultobj = 0;
23250 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23251 int result;
23252 int val1 ;
23253 int ecode1 = 0 ;
23254 PyObject * obj0 = 0 ;
23255 char * kwnames[] = {
23256 (char *) "cal", NULL
23257 };
23258
23259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23260 if (obj0) {
23261 ecode1 = SWIG_AsVal_int(obj0, &val1);
23262 if (!SWIG_IsOK(ecode1)) {
23263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23264 }
23265 arg1 = static_cast< wxDateTime::Calendar >(val1);
23266 }
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 result = (int)wxDateTime::GetCurrentYear(arg1);
23270 wxPyEndAllowThreads(__tstate);
23271 if (PyErr_Occurred()) SWIG_fail;
23272 }
23273 resultobj = SWIG_From_int(static_cast< int >(result));
23274 return resultobj;
23275 fail:
23276 return NULL;
23277 }
23278
23279
23280 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23281 PyObject *resultobj = 0;
23282 int arg1 ;
23283 int result;
23284 int val1 ;
23285 int ecode1 = 0 ;
23286 PyObject * obj0 = 0 ;
23287 char * kwnames[] = {
23288 (char *) "year", NULL
23289 };
23290
23291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23292 ecode1 = SWIG_AsVal_int(obj0, &val1);
23293 if (!SWIG_IsOK(ecode1)) {
23294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23295 }
23296 arg1 = static_cast< int >(val1);
23297 {
23298 PyThreadState* __tstate = wxPyBeginAllowThreads();
23299 result = (int)wxDateTime::ConvertYearToBC(arg1);
23300 wxPyEndAllowThreads(__tstate);
23301 if (PyErr_Occurred()) SWIG_fail;
23302 }
23303 resultobj = SWIG_From_int(static_cast< int >(result));
23304 return resultobj;
23305 fail:
23306 return NULL;
23307 }
23308
23309
23310 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23311 PyObject *resultobj = 0;
23312 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23313 wxDateTime::Month result;
23314 int val1 ;
23315 int ecode1 = 0 ;
23316 PyObject * obj0 = 0 ;
23317 char * kwnames[] = {
23318 (char *) "cal", NULL
23319 };
23320
23321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23322 if (obj0) {
23323 ecode1 = SWIG_AsVal_int(obj0, &val1);
23324 if (!SWIG_IsOK(ecode1)) {
23325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23326 }
23327 arg1 = static_cast< wxDateTime::Calendar >(val1);
23328 }
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 resultobj = SWIG_From_int(static_cast< int >(result));
23336 return resultobj;
23337 fail:
23338 return NULL;
23339 }
23340
23341
23342 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23343 PyObject *resultobj = 0;
23344 int arg1 = (int) wxDateTime::Inv_Year ;
23345 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23346 bool result;
23347 int val1 ;
23348 int ecode1 = 0 ;
23349 int val2 ;
23350 int ecode2 = 0 ;
23351 PyObject * obj0 = 0 ;
23352 PyObject * obj1 = 0 ;
23353 char * kwnames[] = {
23354 (char *) "year",(char *) "cal", NULL
23355 };
23356
23357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23358 if (obj0) {
23359 ecode1 = SWIG_AsVal_int(obj0, &val1);
23360 if (!SWIG_IsOK(ecode1)) {
23361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23362 }
23363 arg1 = static_cast< int >(val1);
23364 }
23365 if (obj1) {
23366 ecode2 = SWIG_AsVal_int(obj1, &val2);
23367 if (!SWIG_IsOK(ecode2)) {
23368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23369 }
23370 arg2 = static_cast< wxDateTime::Calendar >(val2);
23371 }
23372 {
23373 PyThreadState* __tstate = wxPyBeginAllowThreads();
23374 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23375 wxPyEndAllowThreads(__tstate);
23376 if (PyErr_Occurred()) SWIG_fail;
23377 }
23378 {
23379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23380 }
23381 return resultobj;
23382 fail:
23383 return NULL;
23384 }
23385
23386
23387 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23388 PyObject *resultobj = 0;
23389 int arg1 = (int) wxDateTime::Inv_Year ;
23390 int result;
23391 int val1 ;
23392 int ecode1 = 0 ;
23393 PyObject * obj0 = 0 ;
23394 char * kwnames[] = {
23395 (char *) "year", NULL
23396 };
23397
23398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23399 if (obj0) {
23400 ecode1 = SWIG_AsVal_int(obj0, &val1);
23401 if (!SWIG_IsOK(ecode1)) {
23402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23403 }
23404 arg1 = static_cast< int >(val1);
23405 }
23406 {
23407 PyThreadState* __tstate = wxPyBeginAllowThreads();
23408 result = (int)wxDateTime::GetCentury(arg1);
23409 wxPyEndAllowThreads(__tstate);
23410 if (PyErr_Occurred()) SWIG_fail;
23411 }
23412 resultobj = SWIG_From_int(static_cast< int >(result));
23413 return resultobj;
23414 fail:
23415 return NULL;
23416 }
23417
23418
23419 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23420 PyObject *resultobj = 0;
23421 int arg1 ;
23422 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23423 int result;
23424 int val1 ;
23425 int ecode1 = 0 ;
23426 int val2 ;
23427 int ecode2 = 0 ;
23428 PyObject * obj0 = 0 ;
23429 PyObject * obj1 = 0 ;
23430 char * kwnames[] = {
23431 (char *) "year",(char *) "cal", NULL
23432 };
23433
23434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23435 ecode1 = SWIG_AsVal_int(obj0, &val1);
23436 if (!SWIG_IsOK(ecode1)) {
23437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23438 }
23439 arg1 = static_cast< int >(val1);
23440 if (obj1) {
23441 ecode2 = SWIG_AsVal_int(obj1, &val2);
23442 if (!SWIG_IsOK(ecode2)) {
23443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23444 }
23445 arg2 = static_cast< wxDateTime::Calendar >(val2);
23446 }
23447 {
23448 PyThreadState* __tstate = wxPyBeginAllowThreads();
23449 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23450 wxPyEndAllowThreads(__tstate);
23451 if (PyErr_Occurred()) SWIG_fail;
23452 }
23453 resultobj = SWIG_From_int(static_cast< int >(result));
23454 return resultobj;
23455 fail:
23456 return NULL;
23457 }
23458
23459
23460 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23461 PyObject *resultobj = 0;
23462 wxDateTime::Month arg1 ;
23463 int arg2 = (int) wxDateTime::Inv_Year ;
23464 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23465 int result;
23466 int val1 ;
23467 int ecode1 = 0 ;
23468 int val2 ;
23469 int ecode2 = 0 ;
23470 int val3 ;
23471 int ecode3 = 0 ;
23472 PyObject * obj0 = 0 ;
23473 PyObject * obj1 = 0 ;
23474 PyObject * obj2 = 0 ;
23475 char * kwnames[] = {
23476 (char *) "month",(char *) "year",(char *) "cal", NULL
23477 };
23478
23479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23480 ecode1 = SWIG_AsVal_int(obj0, &val1);
23481 if (!SWIG_IsOK(ecode1)) {
23482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23483 }
23484 arg1 = static_cast< wxDateTime::Month >(val1);
23485 if (obj1) {
23486 ecode2 = SWIG_AsVal_int(obj1, &val2);
23487 if (!SWIG_IsOK(ecode2)) {
23488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23489 }
23490 arg2 = static_cast< int >(val2);
23491 }
23492 if (obj2) {
23493 ecode3 = SWIG_AsVal_int(obj2, &val3);
23494 if (!SWIG_IsOK(ecode3)) {
23495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23496 }
23497 arg3 = static_cast< wxDateTime::Calendar >(val3);
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23502 wxPyEndAllowThreads(__tstate);
23503 if (PyErr_Occurred()) SWIG_fail;
23504 }
23505 resultobj = SWIG_From_int(static_cast< int >(result));
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23513 PyObject *resultobj = 0;
23514 wxDateTime::Month arg1 ;
23515 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23516 wxString result;
23517 int val1 ;
23518 int ecode1 = 0 ;
23519 int val2 ;
23520 int ecode2 = 0 ;
23521 PyObject * obj0 = 0 ;
23522 PyObject * obj1 = 0 ;
23523 char * kwnames[] = {
23524 (char *) "month",(char *) "flags", NULL
23525 };
23526
23527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23528 ecode1 = SWIG_AsVal_int(obj0, &val1);
23529 if (!SWIG_IsOK(ecode1)) {
23530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23531 }
23532 arg1 = static_cast< wxDateTime::Month >(val1);
23533 if (obj1) {
23534 ecode2 = SWIG_AsVal_int(obj1, &val2);
23535 if (!SWIG_IsOK(ecode2)) {
23536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23537 }
23538 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23539 }
23540 {
23541 PyThreadState* __tstate = wxPyBeginAllowThreads();
23542 result = wxDateTime::GetMonthName(arg1,arg2);
23543 wxPyEndAllowThreads(__tstate);
23544 if (PyErr_Occurred()) SWIG_fail;
23545 }
23546 {
23547 #if wxUSE_UNICODE
23548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23549 #else
23550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23551 #endif
23552 }
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj = 0;
23561 wxDateTime::WeekDay arg1 ;
23562 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23563 wxString result;
23564 int val1 ;
23565 int ecode1 = 0 ;
23566 int val2 ;
23567 int ecode2 = 0 ;
23568 PyObject * obj0 = 0 ;
23569 PyObject * obj1 = 0 ;
23570 char * kwnames[] = {
23571 (char *) "weekday",(char *) "flags", NULL
23572 };
23573
23574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23575 ecode1 = SWIG_AsVal_int(obj0, &val1);
23576 if (!SWIG_IsOK(ecode1)) {
23577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23578 }
23579 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23580 if (obj1) {
23581 ecode2 = SWIG_AsVal_int(obj1, &val2);
23582 if (!SWIG_IsOK(ecode2)) {
23583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23584 }
23585 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23586 }
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = wxDateTime::GetWeekDayName(arg1,arg2);
23590 wxPyEndAllowThreads(__tstate);
23591 if (PyErr_Occurred()) SWIG_fail;
23592 }
23593 {
23594 #if wxUSE_UNICODE
23595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23596 #else
23597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23598 #endif
23599 }
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23607 PyObject *resultobj = 0;
23608 PyObject *result = 0 ;
23609
23610 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23611 {
23612 PyThreadState* __tstate = wxPyBeginAllowThreads();
23613 result = (PyObject *)wxDateTime_GetAmPmStrings();
23614 wxPyEndAllowThreads(__tstate);
23615 if (PyErr_Occurred()) SWIG_fail;
23616 }
23617 resultobj = result;
23618 return resultobj;
23619 fail:
23620 return NULL;
23621 }
23622
23623
23624 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23625 PyObject *resultobj = 0;
23626 int arg1 = (int) wxDateTime::Inv_Year ;
23627 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23628 bool result;
23629 int val1 ;
23630 int ecode1 = 0 ;
23631 int val2 ;
23632 int ecode2 = 0 ;
23633 PyObject * obj0 = 0 ;
23634 PyObject * obj1 = 0 ;
23635 char * kwnames[] = {
23636 (char *) "year",(char *) "country", NULL
23637 };
23638
23639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23640 if (obj0) {
23641 ecode1 = SWIG_AsVal_int(obj0, &val1);
23642 if (!SWIG_IsOK(ecode1)) {
23643 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23644 }
23645 arg1 = static_cast< int >(val1);
23646 }
23647 if (obj1) {
23648 ecode2 = SWIG_AsVal_int(obj1, &val2);
23649 if (!SWIG_IsOK(ecode2)) {
23650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23651 }
23652 arg2 = static_cast< wxDateTime::Country >(val2);
23653 }
23654 {
23655 PyThreadState* __tstate = wxPyBeginAllowThreads();
23656 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23657 wxPyEndAllowThreads(__tstate);
23658 if (PyErr_Occurred()) SWIG_fail;
23659 }
23660 {
23661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23662 }
23663 return resultobj;
23664 fail:
23665 return NULL;
23666 }
23667
23668
23669 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj = 0;
23671 int arg1 = (int) wxDateTime::Inv_Year ;
23672 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23673 wxDateTime result;
23674 int val1 ;
23675 int ecode1 = 0 ;
23676 int val2 ;
23677 int ecode2 = 0 ;
23678 PyObject * obj0 = 0 ;
23679 PyObject * obj1 = 0 ;
23680 char * kwnames[] = {
23681 (char *) "year",(char *) "country", NULL
23682 };
23683
23684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23685 if (obj0) {
23686 ecode1 = SWIG_AsVal_int(obj0, &val1);
23687 if (!SWIG_IsOK(ecode1)) {
23688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23689 }
23690 arg1 = static_cast< int >(val1);
23691 }
23692 if (obj1) {
23693 ecode2 = SWIG_AsVal_int(obj1, &val2);
23694 if (!SWIG_IsOK(ecode2)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23696 }
23697 arg2 = static_cast< wxDateTime::Country >(val2);
23698 }
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 result = wxDateTime::GetBeginDST(arg1,arg2);
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23706 return resultobj;
23707 fail:
23708 return NULL;
23709 }
23710
23711
23712 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23713 PyObject *resultobj = 0;
23714 int arg1 = (int) wxDateTime::Inv_Year ;
23715 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23716 wxDateTime result;
23717 int val1 ;
23718 int ecode1 = 0 ;
23719 int val2 ;
23720 int ecode2 = 0 ;
23721 PyObject * obj0 = 0 ;
23722 PyObject * obj1 = 0 ;
23723 char * kwnames[] = {
23724 (char *) "year",(char *) "country", NULL
23725 };
23726
23727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23728 if (obj0) {
23729 ecode1 = SWIG_AsVal_int(obj0, &val1);
23730 if (!SWIG_IsOK(ecode1)) {
23731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23732 }
23733 arg1 = static_cast< int >(val1);
23734 }
23735 if (obj1) {
23736 ecode2 = SWIG_AsVal_int(obj1, &val2);
23737 if (!SWIG_IsOK(ecode2)) {
23738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23739 }
23740 arg2 = static_cast< wxDateTime::Country >(val2);
23741 }
23742 {
23743 PyThreadState* __tstate = wxPyBeginAllowThreads();
23744 result = wxDateTime::GetEndDST(arg1,arg2);
23745 wxPyEndAllowThreads(__tstate);
23746 if (PyErr_Occurred()) SWIG_fail;
23747 }
23748 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23749 return resultobj;
23750 fail:
23751 return NULL;
23752 }
23753
23754
23755 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23756 PyObject *resultobj = 0;
23757 wxDateTime result;
23758
23759 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23760 {
23761 PyThreadState* __tstate = wxPyBeginAllowThreads();
23762 result = wxDateTime::Now();
23763 wxPyEndAllowThreads(__tstate);
23764 if (PyErr_Occurred()) SWIG_fail;
23765 }
23766 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23767 return resultobj;
23768 fail:
23769 return NULL;
23770 }
23771
23772
23773 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23774 PyObject *resultobj = 0;
23775 wxDateTime result;
23776
23777 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23778 {
23779 PyThreadState* __tstate = wxPyBeginAllowThreads();
23780 result = wxDateTime::UNow();
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23785 return resultobj;
23786 fail:
23787 return NULL;
23788 }
23789
23790
23791 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23792 PyObject *resultobj = 0;
23793 wxDateTime result;
23794
23795 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 result = wxDateTime::Today();
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *resultobj = 0;
23811 wxDateTime *result = 0 ;
23812
23813 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23814 {
23815 PyThreadState* __tstate = wxPyBeginAllowThreads();
23816 result = (wxDateTime *)new wxDateTime();
23817 wxPyEndAllowThreads(__tstate);
23818 if (PyErr_Occurred()) SWIG_fail;
23819 }
23820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23821 return resultobj;
23822 fail:
23823 return NULL;
23824 }
23825
23826
23827 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23828 PyObject *resultobj = 0;
23829 time_t arg1 ;
23830 wxDateTime *result = 0 ;
23831 unsigned int val1 ;
23832 int ecode1 = 0 ;
23833 PyObject * obj0 = 0 ;
23834 char * kwnames[] = {
23835 (char *) "timet", NULL
23836 };
23837
23838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23839 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23840 if (!SWIG_IsOK(ecode1)) {
23841 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23842 }
23843 arg1 = static_cast< time_t >(val1);
23844 {
23845 PyThreadState* __tstate = wxPyBeginAllowThreads();
23846 result = (wxDateTime *)new wxDateTime(arg1);
23847 wxPyEndAllowThreads(__tstate);
23848 if (PyErr_Occurred()) SWIG_fail;
23849 }
23850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23851 return resultobj;
23852 fail:
23853 return NULL;
23854 }
23855
23856
23857 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23858 PyObject *resultobj = 0;
23859 double arg1 ;
23860 wxDateTime *result = 0 ;
23861 double val1 ;
23862 int ecode1 = 0 ;
23863 PyObject * obj0 = 0 ;
23864 char * kwnames[] = {
23865 (char *) "jdn", NULL
23866 };
23867
23868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23869 ecode1 = SWIG_AsVal_double(obj0, &val1);
23870 if (!SWIG_IsOK(ecode1)) {
23871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23872 }
23873 arg1 = static_cast< double >(val1);
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 result = (wxDateTime *)new wxDateTime(arg1);
23877 wxPyEndAllowThreads(__tstate);
23878 if (PyErr_Occurred()) SWIG_fail;
23879 }
23880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23881 return resultobj;
23882 fail:
23883 return NULL;
23884 }
23885
23886
23887 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23888 PyObject *resultobj = 0;
23889 int arg1 ;
23890 int arg2 = (int) 0 ;
23891 int arg3 = (int) 0 ;
23892 int arg4 = (int) 0 ;
23893 wxDateTime *result = 0 ;
23894 int val1 ;
23895 int ecode1 = 0 ;
23896 int val2 ;
23897 int ecode2 = 0 ;
23898 int val3 ;
23899 int ecode3 = 0 ;
23900 int val4 ;
23901 int ecode4 = 0 ;
23902 PyObject * obj0 = 0 ;
23903 PyObject * obj1 = 0 ;
23904 PyObject * obj2 = 0 ;
23905 PyObject * obj3 = 0 ;
23906 char * kwnames[] = {
23907 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23908 };
23909
23910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23911 ecode1 = SWIG_AsVal_int(obj0, &val1);
23912 if (!SWIG_IsOK(ecode1)) {
23913 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23914 }
23915 arg1 = static_cast< int >(val1);
23916 if (obj1) {
23917 ecode2 = SWIG_AsVal_int(obj1, &val2);
23918 if (!SWIG_IsOK(ecode2)) {
23919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23920 }
23921 arg2 = static_cast< int >(val2);
23922 }
23923 if (obj2) {
23924 ecode3 = SWIG_AsVal_int(obj2, &val3);
23925 if (!SWIG_IsOK(ecode3)) {
23926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23927 }
23928 arg3 = static_cast< int >(val3);
23929 }
23930 if (obj3) {
23931 ecode4 = SWIG_AsVal_int(obj3, &val4);
23932 if (!SWIG_IsOK(ecode4)) {
23933 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23934 }
23935 arg4 = static_cast< int >(val4);
23936 }
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23944 return resultobj;
23945 fail:
23946 return NULL;
23947 }
23948
23949
23950 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23951 PyObject *resultobj = 0;
23952 int arg1 ;
23953 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23954 int arg3 = (int) wxDateTime::Inv_Year ;
23955 int arg4 = (int) 0 ;
23956 int arg5 = (int) 0 ;
23957 int arg6 = (int) 0 ;
23958 int arg7 = (int) 0 ;
23959 wxDateTime *result = 0 ;
23960 int val1 ;
23961 int ecode1 = 0 ;
23962 int val2 ;
23963 int ecode2 = 0 ;
23964 int val3 ;
23965 int ecode3 = 0 ;
23966 int val4 ;
23967 int ecode4 = 0 ;
23968 int val5 ;
23969 int ecode5 = 0 ;
23970 int val6 ;
23971 int ecode6 = 0 ;
23972 int val7 ;
23973 int ecode7 = 0 ;
23974 PyObject * obj0 = 0 ;
23975 PyObject * obj1 = 0 ;
23976 PyObject * obj2 = 0 ;
23977 PyObject * obj3 = 0 ;
23978 PyObject * obj4 = 0 ;
23979 PyObject * obj5 = 0 ;
23980 PyObject * obj6 = 0 ;
23981 char * kwnames[] = {
23982 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23983 };
23984
23985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23986 ecode1 = SWIG_AsVal_int(obj0, &val1);
23987 if (!SWIG_IsOK(ecode1)) {
23988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23989 }
23990 arg1 = static_cast< int >(val1);
23991 if (obj1) {
23992 ecode2 = SWIG_AsVal_int(obj1, &val2);
23993 if (!SWIG_IsOK(ecode2)) {
23994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23995 }
23996 arg2 = static_cast< wxDateTime::Month >(val2);
23997 }
23998 if (obj2) {
23999 ecode3 = SWIG_AsVal_int(obj2, &val3);
24000 if (!SWIG_IsOK(ecode3)) {
24001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24002 }
24003 arg3 = static_cast< int >(val3);
24004 }
24005 if (obj3) {
24006 ecode4 = SWIG_AsVal_int(obj3, &val4);
24007 if (!SWIG_IsOK(ecode4)) {
24008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24009 }
24010 arg4 = static_cast< int >(val4);
24011 }
24012 if (obj4) {
24013 ecode5 = SWIG_AsVal_int(obj4, &val5);
24014 if (!SWIG_IsOK(ecode5)) {
24015 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24016 }
24017 arg5 = static_cast< int >(val5);
24018 }
24019 if (obj5) {
24020 ecode6 = SWIG_AsVal_int(obj5, &val6);
24021 if (!SWIG_IsOK(ecode6)) {
24022 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24023 }
24024 arg6 = static_cast< int >(val6);
24025 }
24026 if (obj6) {
24027 ecode7 = SWIG_AsVal_int(obj6, &val7);
24028 if (!SWIG_IsOK(ecode7)) {
24029 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24030 }
24031 arg7 = static_cast< int >(val7);
24032 }
24033 {
24034 PyThreadState* __tstate = wxPyBeginAllowThreads();
24035 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24036 wxPyEndAllowThreads(__tstate);
24037 if (PyErr_Occurred()) SWIG_fail;
24038 }
24039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24040 return resultobj;
24041 fail:
24042 return NULL;
24043 }
24044
24045
24046 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24047 PyObject *resultobj = 0;
24048 wxDateTime *arg1 = 0 ;
24049 wxDateTime *result = 0 ;
24050 void *argp1 = 0 ;
24051 int res1 = 0 ;
24052 PyObject * obj0 = 0 ;
24053 char * kwnames[] = {
24054 (char *) "date", NULL
24055 };
24056
24057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24058 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24059 if (!SWIG_IsOK(res1)) {
24060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24061 }
24062 if (!argp1) {
24063 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24064 }
24065 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24066 {
24067 PyThreadState* __tstate = wxPyBeginAllowThreads();
24068 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24069 wxPyEndAllowThreads(__tstate);
24070 if (PyErr_Occurred()) SWIG_fail;
24071 }
24072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24080 PyObject *resultobj = 0;
24081 wxDateTime *arg1 = (wxDateTime *) 0 ;
24082 void *argp1 = 0 ;
24083 int res1 = 0 ;
24084 PyObject *swig_obj[1] ;
24085
24086 if (!args) SWIG_fail;
24087 swig_obj[0] = args;
24088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24089 if (!SWIG_IsOK(res1)) {
24090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24091 }
24092 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24093 {
24094 PyThreadState* __tstate = wxPyBeginAllowThreads();
24095 delete arg1;
24096
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 resultobj = SWIG_Py_Void();
24101 return resultobj;
24102 fail:
24103 return NULL;
24104 }
24105
24106
24107 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24108 PyObject *resultobj = 0;
24109 wxDateTime *arg1 = (wxDateTime *) 0 ;
24110 wxDateTime *result = 0 ;
24111 void *argp1 = 0 ;
24112 int res1 = 0 ;
24113 PyObject *swig_obj[1] ;
24114
24115 if (!args) SWIG_fail;
24116 swig_obj[0] = args;
24117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24118 if (!SWIG_IsOK(res1)) {
24119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24120 }
24121 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24122 {
24123 PyThreadState* __tstate = wxPyBeginAllowThreads();
24124 {
24125 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24126 result = (wxDateTime *) &_result_ref;
24127 }
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj = 0;
24140 wxDateTime *arg1 = (wxDateTime *) 0 ;
24141 time_t arg2 ;
24142 wxDateTime *result = 0 ;
24143 void *argp1 = 0 ;
24144 int res1 = 0 ;
24145 unsigned int val2 ;
24146 int ecode2 = 0 ;
24147 PyObject * obj0 = 0 ;
24148 PyObject * obj1 = 0 ;
24149 char * kwnames[] = {
24150 (char *) "self",(char *) "timet", NULL
24151 };
24152
24153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24155 if (!SWIG_IsOK(res1)) {
24156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24157 }
24158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24159 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24160 if (!SWIG_IsOK(ecode2)) {
24161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24162 }
24163 arg2 = static_cast< time_t >(val2);
24164 {
24165 PyThreadState* __tstate = wxPyBeginAllowThreads();
24166 {
24167 wxDateTime &_result_ref = (arg1)->Set(arg2);
24168 result = (wxDateTime *) &_result_ref;
24169 }
24170 wxPyEndAllowThreads(__tstate);
24171 if (PyErr_Occurred()) SWIG_fail;
24172 }
24173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24174 return resultobj;
24175 fail:
24176 return NULL;
24177 }
24178
24179
24180 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24181 PyObject *resultobj = 0;
24182 wxDateTime *arg1 = (wxDateTime *) 0 ;
24183 double arg2 ;
24184 wxDateTime *result = 0 ;
24185 void *argp1 = 0 ;
24186 int res1 = 0 ;
24187 double val2 ;
24188 int ecode2 = 0 ;
24189 PyObject * obj0 = 0 ;
24190 PyObject * obj1 = 0 ;
24191 char * kwnames[] = {
24192 (char *) "self",(char *) "jdn", NULL
24193 };
24194
24195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24197 if (!SWIG_IsOK(res1)) {
24198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24199 }
24200 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24201 ecode2 = SWIG_AsVal_double(obj1, &val2);
24202 if (!SWIG_IsOK(ecode2)) {
24203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24204 }
24205 arg2 = static_cast< double >(val2);
24206 {
24207 PyThreadState* __tstate = wxPyBeginAllowThreads();
24208 {
24209 wxDateTime &_result_ref = (arg1)->Set(arg2);
24210 result = (wxDateTime *) &_result_ref;
24211 }
24212 wxPyEndAllowThreads(__tstate);
24213 if (PyErr_Occurred()) SWIG_fail;
24214 }
24215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24216 return resultobj;
24217 fail:
24218 return NULL;
24219 }
24220
24221
24222 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24223 PyObject *resultobj = 0;
24224 wxDateTime *arg1 = (wxDateTime *) 0 ;
24225 int arg2 ;
24226 int arg3 = (int) 0 ;
24227 int arg4 = (int) 0 ;
24228 int arg5 = (int) 0 ;
24229 wxDateTime *result = 0 ;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 int val2 ;
24233 int ecode2 = 0 ;
24234 int val3 ;
24235 int ecode3 = 0 ;
24236 int val4 ;
24237 int ecode4 = 0 ;
24238 int val5 ;
24239 int ecode5 = 0 ;
24240 PyObject * obj0 = 0 ;
24241 PyObject * obj1 = 0 ;
24242 PyObject * obj2 = 0 ;
24243 PyObject * obj3 = 0 ;
24244 PyObject * obj4 = 0 ;
24245 char * kwnames[] = {
24246 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24247 };
24248
24249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24251 if (!SWIG_IsOK(res1)) {
24252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24253 }
24254 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24255 ecode2 = SWIG_AsVal_int(obj1, &val2);
24256 if (!SWIG_IsOK(ecode2)) {
24257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24258 }
24259 arg2 = static_cast< int >(val2);
24260 if (obj2) {
24261 ecode3 = SWIG_AsVal_int(obj2, &val3);
24262 if (!SWIG_IsOK(ecode3)) {
24263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24264 }
24265 arg3 = static_cast< int >(val3);
24266 }
24267 if (obj3) {
24268 ecode4 = SWIG_AsVal_int(obj3, &val4);
24269 if (!SWIG_IsOK(ecode4)) {
24270 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24271 }
24272 arg4 = static_cast< int >(val4);
24273 }
24274 if (obj4) {
24275 ecode5 = SWIG_AsVal_int(obj4, &val5);
24276 if (!SWIG_IsOK(ecode5)) {
24277 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24278 }
24279 arg5 = static_cast< int >(val5);
24280 }
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 {
24284 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24285 result = (wxDateTime *) &_result_ref;
24286 }
24287 wxPyEndAllowThreads(__tstate);
24288 if (PyErr_Occurred()) SWIG_fail;
24289 }
24290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24291 return resultobj;
24292 fail:
24293 return NULL;
24294 }
24295
24296
24297 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24298 PyObject *resultobj = 0;
24299 wxDateTime *arg1 = (wxDateTime *) 0 ;
24300 int arg2 ;
24301 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24302 int arg4 = (int) wxDateTime::Inv_Year ;
24303 int arg5 = (int) 0 ;
24304 int arg6 = (int) 0 ;
24305 int arg7 = (int) 0 ;
24306 int arg8 = (int) 0 ;
24307 wxDateTime *result = 0 ;
24308 void *argp1 = 0 ;
24309 int res1 = 0 ;
24310 int val2 ;
24311 int ecode2 = 0 ;
24312 int val3 ;
24313 int ecode3 = 0 ;
24314 int val4 ;
24315 int ecode4 = 0 ;
24316 int val5 ;
24317 int ecode5 = 0 ;
24318 int val6 ;
24319 int ecode6 = 0 ;
24320 int val7 ;
24321 int ecode7 = 0 ;
24322 int val8 ;
24323 int ecode8 = 0 ;
24324 PyObject * obj0 = 0 ;
24325 PyObject * obj1 = 0 ;
24326 PyObject * obj2 = 0 ;
24327 PyObject * obj3 = 0 ;
24328 PyObject * obj4 = 0 ;
24329 PyObject * obj5 = 0 ;
24330 PyObject * obj6 = 0 ;
24331 PyObject * obj7 = 0 ;
24332 char * kwnames[] = {
24333 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24334 };
24335
24336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24338 if (!SWIG_IsOK(res1)) {
24339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24340 }
24341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24342 ecode2 = SWIG_AsVal_int(obj1, &val2);
24343 if (!SWIG_IsOK(ecode2)) {
24344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24345 }
24346 arg2 = static_cast< int >(val2);
24347 if (obj2) {
24348 ecode3 = SWIG_AsVal_int(obj2, &val3);
24349 if (!SWIG_IsOK(ecode3)) {
24350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24351 }
24352 arg3 = static_cast< wxDateTime::Month >(val3);
24353 }
24354 if (obj3) {
24355 ecode4 = SWIG_AsVal_int(obj3, &val4);
24356 if (!SWIG_IsOK(ecode4)) {
24357 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24358 }
24359 arg4 = static_cast< int >(val4);
24360 }
24361 if (obj4) {
24362 ecode5 = SWIG_AsVal_int(obj4, &val5);
24363 if (!SWIG_IsOK(ecode5)) {
24364 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24365 }
24366 arg5 = static_cast< int >(val5);
24367 }
24368 if (obj5) {
24369 ecode6 = SWIG_AsVal_int(obj5, &val6);
24370 if (!SWIG_IsOK(ecode6)) {
24371 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24372 }
24373 arg6 = static_cast< int >(val6);
24374 }
24375 if (obj6) {
24376 ecode7 = SWIG_AsVal_int(obj6, &val7);
24377 if (!SWIG_IsOK(ecode7)) {
24378 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24379 }
24380 arg7 = static_cast< int >(val7);
24381 }
24382 if (obj7) {
24383 ecode8 = SWIG_AsVal_int(obj7, &val8);
24384 if (!SWIG_IsOK(ecode8)) {
24385 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24386 }
24387 arg8 = static_cast< int >(val8);
24388 }
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 {
24392 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24393 result = (wxDateTime *) &_result_ref;
24394 }
24395 wxPyEndAllowThreads(__tstate);
24396 if (PyErr_Occurred()) SWIG_fail;
24397 }
24398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24399 return resultobj;
24400 fail:
24401 return NULL;
24402 }
24403
24404
24405 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24406 PyObject *resultobj = 0;
24407 wxDateTime *arg1 = (wxDateTime *) 0 ;
24408 wxDateTime *result = 0 ;
24409 void *argp1 = 0 ;
24410 int res1 = 0 ;
24411 PyObject *swig_obj[1] ;
24412
24413 if (!args) SWIG_fail;
24414 swig_obj[0] = args;
24415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24416 if (!SWIG_IsOK(res1)) {
24417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24418 }
24419 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24420 {
24421 PyThreadState* __tstate = wxPyBeginAllowThreads();
24422 {
24423 wxDateTime &_result_ref = (arg1)->ResetTime();
24424 result = (wxDateTime *) &_result_ref;
24425 }
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24437 PyObject *resultobj = 0;
24438 wxDateTime *arg1 = (wxDateTime *) 0 ;
24439 int arg2 ;
24440 wxDateTime *result = 0 ;
24441 void *argp1 = 0 ;
24442 int res1 = 0 ;
24443 int val2 ;
24444 int ecode2 = 0 ;
24445 PyObject * obj0 = 0 ;
24446 PyObject * obj1 = 0 ;
24447 char * kwnames[] = {
24448 (char *) "self",(char *) "year", NULL
24449 };
24450
24451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24453 if (!SWIG_IsOK(res1)) {
24454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24455 }
24456 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24457 ecode2 = SWIG_AsVal_int(obj1, &val2);
24458 if (!SWIG_IsOK(ecode2)) {
24459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24460 }
24461 arg2 = static_cast< int >(val2);
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 {
24465 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24466 result = (wxDateTime *) &_result_ref;
24467 }
24468 wxPyEndAllowThreads(__tstate);
24469 if (PyErr_Occurred()) SWIG_fail;
24470 }
24471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24472 return resultobj;
24473 fail:
24474 return NULL;
24475 }
24476
24477
24478 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24479 PyObject *resultobj = 0;
24480 wxDateTime *arg1 = (wxDateTime *) 0 ;
24481 wxDateTime::Month arg2 ;
24482 wxDateTime *result = 0 ;
24483 void *argp1 = 0 ;
24484 int res1 = 0 ;
24485 int val2 ;
24486 int ecode2 = 0 ;
24487 PyObject * obj0 = 0 ;
24488 PyObject * obj1 = 0 ;
24489 char * kwnames[] = {
24490 (char *) "self",(char *) "month", NULL
24491 };
24492
24493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24495 if (!SWIG_IsOK(res1)) {
24496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24497 }
24498 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24499 ecode2 = SWIG_AsVal_int(obj1, &val2);
24500 if (!SWIG_IsOK(ecode2)) {
24501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24502 }
24503 arg2 = static_cast< wxDateTime::Month >(val2);
24504 {
24505 PyThreadState* __tstate = wxPyBeginAllowThreads();
24506 {
24507 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24508 result = (wxDateTime *) &_result_ref;
24509 }
24510 wxPyEndAllowThreads(__tstate);
24511 if (PyErr_Occurred()) SWIG_fail;
24512 }
24513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24514 return resultobj;
24515 fail:
24516 return NULL;
24517 }
24518
24519
24520 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24521 PyObject *resultobj = 0;
24522 wxDateTime *arg1 = (wxDateTime *) 0 ;
24523 int arg2 ;
24524 wxDateTime *result = 0 ;
24525 void *argp1 = 0 ;
24526 int res1 = 0 ;
24527 int val2 ;
24528 int ecode2 = 0 ;
24529 PyObject * obj0 = 0 ;
24530 PyObject * obj1 = 0 ;
24531 char * kwnames[] = {
24532 (char *) "self",(char *) "day", NULL
24533 };
24534
24535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24537 if (!SWIG_IsOK(res1)) {
24538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24539 }
24540 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24541 ecode2 = SWIG_AsVal_int(obj1, &val2);
24542 if (!SWIG_IsOK(ecode2)) {
24543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24544 }
24545 arg2 = static_cast< int >(val2);
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 {
24549 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24550 result = (wxDateTime *) &_result_ref;
24551 }
24552 wxPyEndAllowThreads(__tstate);
24553 if (PyErr_Occurred()) SWIG_fail;
24554 }
24555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24556 return resultobj;
24557 fail:
24558 return NULL;
24559 }
24560
24561
24562 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24563 PyObject *resultobj = 0;
24564 wxDateTime *arg1 = (wxDateTime *) 0 ;
24565 int arg2 ;
24566 wxDateTime *result = 0 ;
24567 void *argp1 = 0 ;
24568 int res1 = 0 ;
24569 int val2 ;
24570 int ecode2 = 0 ;
24571 PyObject * obj0 = 0 ;
24572 PyObject * obj1 = 0 ;
24573 char * kwnames[] = {
24574 (char *) "self",(char *) "hour", NULL
24575 };
24576
24577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24579 if (!SWIG_IsOK(res1)) {
24580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24581 }
24582 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24583 ecode2 = SWIG_AsVal_int(obj1, &val2);
24584 if (!SWIG_IsOK(ecode2)) {
24585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24586 }
24587 arg2 = static_cast< int >(val2);
24588 {
24589 PyThreadState* __tstate = wxPyBeginAllowThreads();
24590 {
24591 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24592 result = (wxDateTime *) &_result_ref;
24593 }
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24605 PyObject *resultobj = 0;
24606 wxDateTime *arg1 = (wxDateTime *) 0 ;
24607 int arg2 ;
24608 wxDateTime *result = 0 ;
24609 void *argp1 = 0 ;
24610 int res1 = 0 ;
24611 int val2 ;
24612 int ecode2 = 0 ;
24613 PyObject * obj0 = 0 ;
24614 PyObject * obj1 = 0 ;
24615 char * kwnames[] = {
24616 (char *) "self",(char *) "minute", NULL
24617 };
24618
24619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24621 if (!SWIG_IsOK(res1)) {
24622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24623 }
24624 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24625 ecode2 = SWIG_AsVal_int(obj1, &val2);
24626 if (!SWIG_IsOK(ecode2)) {
24627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24628 }
24629 arg2 = static_cast< int >(val2);
24630 {
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 {
24633 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24634 result = (wxDateTime *) &_result_ref;
24635 }
24636 wxPyEndAllowThreads(__tstate);
24637 if (PyErr_Occurred()) SWIG_fail;
24638 }
24639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24640 return resultobj;
24641 fail:
24642 return NULL;
24643 }
24644
24645
24646 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24647 PyObject *resultobj = 0;
24648 wxDateTime *arg1 = (wxDateTime *) 0 ;
24649 int arg2 ;
24650 wxDateTime *result = 0 ;
24651 void *argp1 = 0 ;
24652 int res1 = 0 ;
24653 int val2 ;
24654 int ecode2 = 0 ;
24655 PyObject * obj0 = 0 ;
24656 PyObject * obj1 = 0 ;
24657 char * kwnames[] = {
24658 (char *) "self",(char *) "second", NULL
24659 };
24660
24661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24663 if (!SWIG_IsOK(res1)) {
24664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24665 }
24666 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24667 ecode2 = SWIG_AsVal_int(obj1, &val2);
24668 if (!SWIG_IsOK(ecode2)) {
24669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24670 }
24671 arg2 = static_cast< int >(val2);
24672 {
24673 PyThreadState* __tstate = wxPyBeginAllowThreads();
24674 {
24675 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24676 result = (wxDateTime *) &_result_ref;
24677 }
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24689 PyObject *resultobj = 0;
24690 wxDateTime *arg1 = (wxDateTime *) 0 ;
24691 int arg2 ;
24692 wxDateTime *result = 0 ;
24693 void *argp1 = 0 ;
24694 int res1 = 0 ;
24695 int val2 ;
24696 int ecode2 = 0 ;
24697 PyObject * obj0 = 0 ;
24698 PyObject * obj1 = 0 ;
24699 char * kwnames[] = {
24700 (char *) "self",(char *) "millisecond", NULL
24701 };
24702
24703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24705 if (!SWIG_IsOK(res1)) {
24706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24707 }
24708 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24709 ecode2 = SWIG_AsVal_int(obj1, &val2);
24710 if (!SWIG_IsOK(ecode2)) {
24711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24712 }
24713 arg2 = static_cast< int >(val2);
24714 {
24715 PyThreadState* __tstate = wxPyBeginAllowThreads();
24716 {
24717 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24718 result = (wxDateTime *) &_result_ref;
24719 }
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24724 return resultobj;
24725 fail:
24726 return NULL;
24727 }
24728
24729
24730 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24731 PyObject *resultobj = 0;
24732 wxDateTime *arg1 = (wxDateTime *) 0 ;
24733 wxDateTime::WeekDay arg2 ;
24734 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24735 wxDateTime *result = 0 ;
24736 void *argp1 = 0 ;
24737 int res1 = 0 ;
24738 int val2 ;
24739 int ecode2 = 0 ;
24740 int val3 ;
24741 int ecode3 = 0 ;
24742 PyObject * obj0 = 0 ;
24743 PyObject * obj1 = 0 ;
24744 PyObject * obj2 = 0 ;
24745 char * kwnames[] = {
24746 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24747 };
24748
24749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24751 if (!SWIG_IsOK(res1)) {
24752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24753 }
24754 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24755 ecode2 = SWIG_AsVal_int(obj1, &val2);
24756 if (!SWIG_IsOK(ecode2)) {
24757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24758 }
24759 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24760 if (obj2) {
24761 ecode3 = SWIG_AsVal_int(obj2, &val3);
24762 if (!SWIG_IsOK(ecode3)) {
24763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24764 }
24765 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24766 }
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 {
24770 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24771 result = (wxDateTime *) &_result_ref;
24772 }
24773 wxPyEndAllowThreads(__tstate);
24774 if (PyErr_Occurred()) SWIG_fail;
24775 }
24776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24777 return resultobj;
24778 fail:
24779 return NULL;
24780 }
24781
24782
24783 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj = 0;
24785 wxDateTime *arg1 = (wxDateTime *) 0 ;
24786 wxDateTime::WeekDay arg2 ;
24787 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24788 wxDateTime result;
24789 void *argp1 = 0 ;
24790 int res1 = 0 ;
24791 int val2 ;
24792 int ecode2 = 0 ;
24793 int val3 ;
24794 int ecode3 = 0 ;
24795 PyObject * obj0 = 0 ;
24796 PyObject * obj1 = 0 ;
24797 PyObject * obj2 = 0 ;
24798 char * kwnames[] = {
24799 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24800 };
24801
24802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24804 if (!SWIG_IsOK(res1)) {
24805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24806 }
24807 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24808 ecode2 = SWIG_AsVal_int(obj1, &val2);
24809 if (!SWIG_IsOK(ecode2)) {
24810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24811 }
24812 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24813 if (obj2) {
24814 ecode3 = SWIG_AsVal_int(obj2, &val3);
24815 if (!SWIG_IsOK(ecode3)) {
24816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24817 }
24818 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24819 }
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24827 return resultobj;
24828 fail:
24829 return NULL;
24830 }
24831
24832
24833 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24834 PyObject *resultobj = 0;
24835 wxDateTime *arg1 = (wxDateTime *) 0 ;
24836 wxDateTime::WeekDay arg2 ;
24837 wxDateTime *result = 0 ;
24838 void *argp1 = 0 ;
24839 int res1 = 0 ;
24840 int val2 ;
24841 int ecode2 = 0 ;
24842 PyObject * obj0 = 0 ;
24843 PyObject * obj1 = 0 ;
24844 char * kwnames[] = {
24845 (char *) "self",(char *) "weekday", NULL
24846 };
24847
24848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24850 if (!SWIG_IsOK(res1)) {
24851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24852 }
24853 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24854 ecode2 = SWIG_AsVal_int(obj1, &val2);
24855 if (!SWIG_IsOK(ecode2)) {
24856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24857 }
24858 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24859 {
24860 PyThreadState* __tstate = wxPyBeginAllowThreads();
24861 {
24862 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24863 result = (wxDateTime *) &_result_ref;
24864 }
24865 wxPyEndAllowThreads(__tstate);
24866 if (PyErr_Occurred()) SWIG_fail;
24867 }
24868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24876 PyObject *resultobj = 0;
24877 wxDateTime *arg1 = (wxDateTime *) 0 ;
24878 wxDateTime::WeekDay arg2 ;
24879 wxDateTime result;
24880 void *argp1 = 0 ;
24881 int res1 = 0 ;
24882 int val2 ;
24883 int ecode2 = 0 ;
24884 PyObject * obj0 = 0 ;
24885 PyObject * obj1 = 0 ;
24886 char * kwnames[] = {
24887 (char *) "self",(char *) "weekday", NULL
24888 };
24889
24890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24892 if (!SWIG_IsOK(res1)) {
24893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24894 }
24895 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24896 ecode2 = SWIG_AsVal_int(obj1, &val2);
24897 if (!SWIG_IsOK(ecode2)) {
24898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24899 }
24900 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24901 {
24902 PyThreadState* __tstate = wxPyBeginAllowThreads();
24903 result = (arg1)->GetNextWeekDay(arg2);
24904 wxPyEndAllowThreads(__tstate);
24905 if (PyErr_Occurred()) SWIG_fail;
24906 }
24907 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24908 return resultobj;
24909 fail:
24910 return NULL;
24911 }
24912
24913
24914 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24915 PyObject *resultobj = 0;
24916 wxDateTime *arg1 = (wxDateTime *) 0 ;
24917 wxDateTime::WeekDay arg2 ;
24918 wxDateTime *result = 0 ;
24919 void *argp1 = 0 ;
24920 int res1 = 0 ;
24921 int val2 ;
24922 int ecode2 = 0 ;
24923 PyObject * obj0 = 0 ;
24924 PyObject * obj1 = 0 ;
24925 char * kwnames[] = {
24926 (char *) "self",(char *) "weekday", NULL
24927 };
24928
24929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24931 if (!SWIG_IsOK(res1)) {
24932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24933 }
24934 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24935 ecode2 = SWIG_AsVal_int(obj1, &val2);
24936 if (!SWIG_IsOK(ecode2)) {
24937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24938 }
24939 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24940 {
24941 PyThreadState* __tstate = wxPyBeginAllowThreads();
24942 {
24943 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24944 result = (wxDateTime *) &_result_ref;
24945 }
24946 wxPyEndAllowThreads(__tstate);
24947 if (PyErr_Occurred()) SWIG_fail;
24948 }
24949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24950 return resultobj;
24951 fail:
24952 return NULL;
24953 }
24954
24955
24956 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24957 PyObject *resultobj = 0;
24958 wxDateTime *arg1 = (wxDateTime *) 0 ;
24959 wxDateTime::WeekDay arg2 ;
24960 wxDateTime result;
24961 void *argp1 = 0 ;
24962 int res1 = 0 ;
24963 int val2 ;
24964 int ecode2 = 0 ;
24965 PyObject * obj0 = 0 ;
24966 PyObject * obj1 = 0 ;
24967 char * kwnames[] = {
24968 (char *) "self",(char *) "weekday", NULL
24969 };
24970
24971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24973 if (!SWIG_IsOK(res1)) {
24974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24975 }
24976 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24977 ecode2 = SWIG_AsVal_int(obj1, &val2);
24978 if (!SWIG_IsOK(ecode2)) {
24979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24980 }
24981 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24982 {
24983 PyThreadState* __tstate = wxPyBeginAllowThreads();
24984 result = (arg1)->GetPrevWeekDay(arg2);
24985 wxPyEndAllowThreads(__tstate);
24986 if (PyErr_Occurred()) SWIG_fail;
24987 }
24988 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24989 return resultobj;
24990 fail:
24991 return NULL;
24992 }
24993
24994
24995 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24996 PyObject *resultobj = 0;
24997 wxDateTime *arg1 = (wxDateTime *) 0 ;
24998 wxDateTime::WeekDay arg2 ;
24999 int arg3 = (int) 1 ;
25000 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25001 int arg5 = (int) wxDateTime::Inv_Year ;
25002 bool result;
25003 void *argp1 = 0 ;
25004 int res1 = 0 ;
25005 int val2 ;
25006 int ecode2 = 0 ;
25007 int val3 ;
25008 int ecode3 = 0 ;
25009 int val4 ;
25010 int ecode4 = 0 ;
25011 int val5 ;
25012 int ecode5 = 0 ;
25013 PyObject * obj0 = 0 ;
25014 PyObject * obj1 = 0 ;
25015 PyObject * obj2 = 0 ;
25016 PyObject * obj3 = 0 ;
25017 PyObject * obj4 = 0 ;
25018 char * kwnames[] = {
25019 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25020 };
25021
25022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25024 if (!SWIG_IsOK(res1)) {
25025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25026 }
25027 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25028 ecode2 = SWIG_AsVal_int(obj1, &val2);
25029 if (!SWIG_IsOK(ecode2)) {
25030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25031 }
25032 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25033 if (obj2) {
25034 ecode3 = SWIG_AsVal_int(obj2, &val3);
25035 if (!SWIG_IsOK(ecode3)) {
25036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25037 }
25038 arg3 = static_cast< int >(val3);
25039 }
25040 if (obj3) {
25041 ecode4 = SWIG_AsVal_int(obj3, &val4);
25042 if (!SWIG_IsOK(ecode4)) {
25043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25044 }
25045 arg4 = static_cast< wxDateTime::Month >(val4);
25046 }
25047 if (obj4) {
25048 ecode5 = SWIG_AsVal_int(obj4, &val5);
25049 if (!SWIG_IsOK(ecode5)) {
25050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25051 }
25052 arg5 = static_cast< int >(val5);
25053 }
25054 {
25055 PyThreadState* __tstate = wxPyBeginAllowThreads();
25056 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25057 wxPyEndAllowThreads(__tstate);
25058 if (PyErr_Occurred()) SWIG_fail;
25059 }
25060 {
25061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25062 }
25063 return resultobj;
25064 fail:
25065 return NULL;
25066 }
25067
25068
25069 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25070 PyObject *resultobj = 0;
25071 wxDateTime *arg1 = (wxDateTime *) 0 ;
25072 wxDateTime::WeekDay arg2 ;
25073 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25074 int arg4 = (int) wxDateTime::Inv_Year ;
25075 bool result;
25076 void *argp1 = 0 ;
25077 int res1 = 0 ;
25078 int val2 ;
25079 int ecode2 = 0 ;
25080 int val3 ;
25081 int ecode3 = 0 ;
25082 int val4 ;
25083 int ecode4 = 0 ;
25084 PyObject * obj0 = 0 ;
25085 PyObject * obj1 = 0 ;
25086 PyObject * obj2 = 0 ;
25087 PyObject * obj3 = 0 ;
25088 char * kwnames[] = {
25089 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25090 };
25091
25092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25094 if (!SWIG_IsOK(res1)) {
25095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25096 }
25097 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25098 ecode2 = SWIG_AsVal_int(obj1, &val2);
25099 if (!SWIG_IsOK(ecode2)) {
25100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25101 }
25102 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25103 if (obj2) {
25104 ecode3 = SWIG_AsVal_int(obj2, &val3);
25105 if (!SWIG_IsOK(ecode3)) {
25106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25107 }
25108 arg3 = static_cast< wxDateTime::Month >(val3);
25109 }
25110 if (obj3) {
25111 ecode4 = SWIG_AsVal_int(obj3, &val4);
25112 if (!SWIG_IsOK(ecode4)) {
25113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25114 }
25115 arg4 = static_cast< int >(val4);
25116 }
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25125 }
25126 return resultobj;
25127 fail:
25128 return NULL;
25129 }
25130
25131
25132 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25133 PyObject *resultobj = 0;
25134 wxDateTime *arg1 = (wxDateTime *) 0 ;
25135 wxDateTime::WeekDay arg2 ;
25136 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25137 int arg4 = (int) wxDateTime::Inv_Year ;
25138 wxDateTime result;
25139 void *argp1 = 0 ;
25140 int res1 = 0 ;
25141 int val2 ;
25142 int ecode2 = 0 ;
25143 int val3 ;
25144 int ecode3 = 0 ;
25145 int val4 ;
25146 int ecode4 = 0 ;
25147 PyObject * obj0 = 0 ;
25148 PyObject * obj1 = 0 ;
25149 PyObject * obj2 = 0 ;
25150 PyObject * obj3 = 0 ;
25151 char * kwnames[] = {
25152 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25153 };
25154
25155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25157 if (!SWIG_IsOK(res1)) {
25158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25159 }
25160 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25161 ecode2 = SWIG_AsVal_int(obj1, &val2);
25162 if (!SWIG_IsOK(ecode2)) {
25163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25164 }
25165 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25166 if (obj2) {
25167 ecode3 = SWIG_AsVal_int(obj2, &val3);
25168 if (!SWIG_IsOK(ecode3)) {
25169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25170 }
25171 arg3 = static_cast< wxDateTime::Month >(val3);
25172 }
25173 if (obj3) {
25174 ecode4 = SWIG_AsVal_int(obj3, &val4);
25175 if (!SWIG_IsOK(ecode4)) {
25176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25177 }
25178 arg4 = static_cast< int >(val4);
25179 }
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25194 PyObject *resultobj = 0;
25195 wxDateTime *arg1 = (wxDateTime *) 0 ;
25196 int arg2 ;
25197 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25198 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25199 bool result;
25200 void *argp1 = 0 ;
25201 int res1 = 0 ;
25202 int val2 ;
25203 int ecode2 = 0 ;
25204 int val3 ;
25205 int ecode3 = 0 ;
25206 int val4 ;
25207 int ecode4 = 0 ;
25208 PyObject * obj0 = 0 ;
25209 PyObject * obj1 = 0 ;
25210 PyObject * obj2 = 0 ;
25211 PyObject * obj3 = 0 ;
25212 char * kwnames[] = {
25213 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25214 };
25215
25216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25218 if (!SWIG_IsOK(res1)) {
25219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25220 }
25221 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25222 ecode2 = SWIG_AsVal_int(obj1, &val2);
25223 if (!SWIG_IsOK(ecode2)) {
25224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25225 }
25226 arg2 = static_cast< int >(val2);
25227 if (obj2) {
25228 ecode3 = SWIG_AsVal_int(obj2, &val3);
25229 if (!SWIG_IsOK(ecode3)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25231 }
25232 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25233 }
25234 if (obj3) {
25235 ecode4 = SWIG_AsVal_int(obj3, &val4);
25236 if (!SWIG_IsOK(ecode4)) {
25237 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25238 }
25239 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25240 }
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 {
25248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25249 }
25250 return resultobj;
25251 fail:
25252 return NULL;
25253 }
25254
25255
25256 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj = 0;
25258 wxDateTime *arg1 = (wxDateTime *) 0 ;
25259 int arg2 ;
25260 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25261 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25262 wxDateTime result;
25263 void *argp1 = 0 ;
25264 int res1 = 0 ;
25265 int val2 ;
25266 int ecode2 = 0 ;
25267 int val3 ;
25268 int ecode3 = 0 ;
25269 int val4 ;
25270 int ecode4 = 0 ;
25271 PyObject * obj0 = 0 ;
25272 PyObject * obj1 = 0 ;
25273 PyObject * obj2 = 0 ;
25274 PyObject * obj3 = 0 ;
25275 char * kwnames[] = {
25276 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25277 };
25278
25279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25281 if (!SWIG_IsOK(res1)) {
25282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25283 }
25284 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25285 ecode2 = SWIG_AsVal_int(obj1, &val2);
25286 if (!SWIG_IsOK(ecode2)) {
25287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25288 }
25289 arg2 = static_cast< int >(val2);
25290 if (obj2) {
25291 ecode3 = SWIG_AsVal_int(obj2, &val3);
25292 if (!SWIG_IsOK(ecode3)) {
25293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25294 }
25295 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25296 }
25297 if (obj3) {
25298 ecode4 = SWIG_AsVal_int(obj3, &val4);
25299 if (!SWIG_IsOK(ecode4)) {
25300 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25301 }
25302 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25303 }
25304 {
25305 PyThreadState* __tstate = wxPyBeginAllowThreads();
25306 result = (arg1)->GetWeek(arg2,arg3,arg4);
25307 wxPyEndAllowThreads(__tstate);
25308 if (PyErr_Occurred()) SWIG_fail;
25309 }
25310 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25311 return resultobj;
25312 fail:
25313 return NULL;
25314 }
25315
25316
25317 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25318 PyObject *resultobj = 0;
25319 int arg1 ;
25320 int arg2 ;
25321 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25322 wxDateTime result;
25323 int val1 ;
25324 int ecode1 = 0 ;
25325 int val2 ;
25326 int ecode2 = 0 ;
25327 int val3 ;
25328 int ecode3 = 0 ;
25329 PyObject * obj0 = 0 ;
25330 PyObject * obj1 = 0 ;
25331 PyObject * obj2 = 0 ;
25332 char * kwnames[] = {
25333 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25334 };
25335
25336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25337 ecode1 = SWIG_AsVal_int(obj0, &val1);
25338 if (!SWIG_IsOK(ecode1)) {
25339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25340 }
25341 arg1 = static_cast< int >(val1);
25342 ecode2 = SWIG_AsVal_int(obj1, &val2);
25343 if (!SWIG_IsOK(ecode2)) {
25344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25345 }
25346 arg2 = static_cast< int >(val2);
25347 if (obj2) {
25348 ecode3 = SWIG_AsVal_int(obj2, &val3);
25349 if (!SWIG_IsOK(ecode3)) {
25350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25351 }
25352 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25353 }
25354 {
25355 PyThreadState* __tstate = wxPyBeginAllowThreads();
25356 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25357 wxPyEndAllowThreads(__tstate);
25358 if (PyErr_Occurred()) SWIG_fail;
25359 }
25360 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25361 return resultobj;
25362 fail:
25363 return NULL;
25364 }
25365
25366
25367 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25368 PyObject *resultobj = 0;
25369 wxDateTime *arg1 = (wxDateTime *) 0 ;
25370 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25371 int arg3 = (int) wxDateTime::Inv_Year ;
25372 wxDateTime *result = 0 ;
25373 void *argp1 = 0 ;
25374 int res1 = 0 ;
25375 int val2 ;
25376 int ecode2 = 0 ;
25377 int val3 ;
25378 int ecode3 = 0 ;
25379 PyObject * obj0 = 0 ;
25380 PyObject * obj1 = 0 ;
25381 PyObject * obj2 = 0 ;
25382 char * kwnames[] = {
25383 (char *) "self",(char *) "month",(char *) "year", NULL
25384 };
25385
25386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25388 if (!SWIG_IsOK(res1)) {
25389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25390 }
25391 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25392 if (obj1) {
25393 ecode2 = SWIG_AsVal_int(obj1, &val2);
25394 if (!SWIG_IsOK(ecode2)) {
25395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25396 }
25397 arg2 = static_cast< wxDateTime::Month >(val2);
25398 }
25399 if (obj2) {
25400 ecode3 = SWIG_AsVal_int(obj2, &val3);
25401 if (!SWIG_IsOK(ecode3)) {
25402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25403 }
25404 arg3 = static_cast< int >(val3);
25405 }
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 {
25409 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25410 result = (wxDateTime *) &_result_ref;
25411 }
25412 wxPyEndAllowThreads(__tstate);
25413 if (PyErr_Occurred()) SWIG_fail;
25414 }
25415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj = 0;
25424 wxDateTime *arg1 = (wxDateTime *) 0 ;
25425 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25426 int arg3 = (int) wxDateTime::Inv_Year ;
25427 wxDateTime result;
25428 void *argp1 = 0 ;
25429 int res1 = 0 ;
25430 int val2 ;
25431 int ecode2 = 0 ;
25432 int val3 ;
25433 int ecode3 = 0 ;
25434 PyObject * obj0 = 0 ;
25435 PyObject * obj1 = 0 ;
25436 PyObject * obj2 = 0 ;
25437 char * kwnames[] = {
25438 (char *) "self",(char *) "month",(char *) "year", NULL
25439 };
25440
25441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25443 if (!SWIG_IsOK(res1)) {
25444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25445 }
25446 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25447 if (obj1) {
25448 ecode2 = SWIG_AsVal_int(obj1, &val2);
25449 if (!SWIG_IsOK(ecode2)) {
25450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25451 }
25452 arg2 = static_cast< wxDateTime::Month >(val2);
25453 }
25454 if (obj2) {
25455 ecode3 = SWIG_AsVal_int(obj2, &val3);
25456 if (!SWIG_IsOK(ecode3)) {
25457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25458 }
25459 arg3 = static_cast< int >(val3);
25460 }
25461 {
25462 PyThreadState* __tstate = wxPyBeginAllowThreads();
25463 result = (arg1)->GetLastMonthDay(arg2,arg3);
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25468 return resultobj;
25469 fail:
25470 return NULL;
25471 }
25472
25473
25474 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25475 PyObject *resultobj = 0;
25476 wxDateTime *arg1 = (wxDateTime *) 0 ;
25477 int arg2 ;
25478 wxDateTime *result = 0 ;
25479 void *argp1 = 0 ;
25480 int res1 = 0 ;
25481 int val2 ;
25482 int ecode2 = 0 ;
25483 PyObject * obj0 = 0 ;
25484 PyObject * obj1 = 0 ;
25485 char * kwnames[] = {
25486 (char *) "self",(char *) "yday", NULL
25487 };
25488
25489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25491 if (!SWIG_IsOK(res1)) {
25492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25493 }
25494 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25495 ecode2 = SWIG_AsVal_int(obj1, &val2);
25496 if (!SWIG_IsOK(ecode2)) {
25497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25498 }
25499 arg2 = static_cast< int >(val2);
25500 {
25501 PyThreadState* __tstate = wxPyBeginAllowThreads();
25502 {
25503 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25504 result = (wxDateTime *) &_result_ref;
25505 }
25506 wxPyEndAllowThreads(__tstate);
25507 if (PyErr_Occurred()) SWIG_fail;
25508 }
25509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25510 return resultobj;
25511 fail:
25512 return NULL;
25513 }
25514
25515
25516 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25517 PyObject *resultobj = 0;
25518 wxDateTime *arg1 = (wxDateTime *) 0 ;
25519 int arg2 ;
25520 wxDateTime result;
25521 void *argp1 = 0 ;
25522 int res1 = 0 ;
25523 int val2 ;
25524 int ecode2 = 0 ;
25525 PyObject * obj0 = 0 ;
25526 PyObject * obj1 = 0 ;
25527 char * kwnames[] = {
25528 (char *) "self",(char *) "yday", NULL
25529 };
25530
25531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25533 if (!SWIG_IsOK(res1)) {
25534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25535 }
25536 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25537 ecode2 = SWIG_AsVal_int(obj1, &val2);
25538 if (!SWIG_IsOK(ecode2)) {
25539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25540 }
25541 arg2 = static_cast< int >(val2);
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 result = (arg1)->GetYearDay(arg2);
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25549 return resultobj;
25550 fail:
25551 return NULL;
25552 }
25553
25554
25555 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25556 PyObject *resultobj = 0;
25557 wxDateTime *arg1 = (wxDateTime *) 0 ;
25558 double result;
25559 void *argp1 = 0 ;
25560 int res1 = 0 ;
25561 PyObject *swig_obj[1] ;
25562
25563 if (!args) SWIG_fail;
25564 swig_obj[0] = args;
25565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25566 if (!SWIG_IsOK(res1)) {
25567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25568 }
25569 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (double)(arg1)->GetJulianDayNumber();
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 resultobj = SWIG_From_double(static_cast< double >(result));
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 PyObject *resultobj = 0;
25585 wxDateTime *arg1 = (wxDateTime *) 0 ;
25586 double result;
25587 void *argp1 = 0 ;
25588 int res1 = 0 ;
25589 PyObject *swig_obj[1] ;
25590
25591 if (!args) SWIG_fail;
25592 swig_obj[0] = args;
25593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25594 if (!SWIG_IsOK(res1)) {
25595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25596 }
25597 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25598 {
25599 PyThreadState* __tstate = wxPyBeginAllowThreads();
25600 result = (double)(arg1)->GetJDN();
25601 wxPyEndAllowThreads(__tstate);
25602 if (PyErr_Occurred()) SWIG_fail;
25603 }
25604 resultobj = SWIG_From_double(static_cast< double >(result));
25605 return resultobj;
25606 fail:
25607 return NULL;
25608 }
25609
25610
25611 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25612 PyObject *resultobj = 0;
25613 wxDateTime *arg1 = (wxDateTime *) 0 ;
25614 double result;
25615 void *argp1 = 0 ;
25616 int res1 = 0 ;
25617 PyObject *swig_obj[1] ;
25618
25619 if (!args) SWIG_fail;
25620 swig_obj[0] = args;
25621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25622 if (!SWIG_IsOK(res1)) {
25623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25624 }
25625 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25626 {
25627 PyThreadState* __tstate = wxPyBeginAllowThreads();
25628 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 resultobj = SWIG_From_double(static_cast< double >(result));
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25640 PyObject *resultobj = 0;
25641 wxDateTime *arg1 = (wxDateTime *) 0 ;
25642 double result;
25643 void *argp1 = 0 ;
25644 int res1 = 0 ;
25645 PyObject *swig_obj[1] ;
25646
25647 if (!args) SWIG_fail;
25648 swig_obj[0] = args;
25649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25650 if (!SWIG_IsOK(res1)) {
25651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25652 }
25653 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 result = (double)(arg1)->GetMJD();
25657 wxPyEndAllowThreads(__tstate);
25658 if (PyErr_Occurred()) SWIG_fail;
25659 }
25660 resultobj = SWIG_From_double(static_cast< double >(result));
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25668 PyObject *resultobj = 0;
25669 wxDateTime *arg1 = (wxDateTime *) 0 ;
25670 double result;
25671 void *argp1 = 0 ;
25672 int res1 = 0 ;
25673 PyObject *swig_obj[1] ;
25674
25675 if (!args) SWIG_fail;
25676 swig_obj[0] = args;
25677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25678 if (!SWIG_IsOK(res1)) {
25679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25680 }
25681 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25682 {
25683 PyThreadState* __tstate = wxPyBeginAllowThreads();
25684 result = (double)(arg1)->GetRataDie();
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 resultobj = SWIG_From_double(static_cast< double >(result));
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25696 PyObject *resultobj = 0;
25697 wxDateTime *arg1 = (wxDateTime *) 0 ;
25698 wxDateTime::TimeZone *arg2 = 0 ;
25699 bool arg3 = (bool) false ;
25700 wxDateTime result;
25701 void *argp1 = 0 ;
25702 int res1 = 0 ;
25703 bool temp2 = false ;
25704 bool val3 ;
25705 int ecode3 = 0 ;
25706 PyObject * obj0 = 0 ;
25707 PyObject * obj1 = 0 ;
25708 PyObject * obj2 = 0 ;
25709 char * kwnames[] = {
25710 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25711 };
25712
25713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25715 if (!SWIG_IsOK(res1)) {
25716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25717 }
25718 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25719 {
25720 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25721 temp2 = true;
25722 }
25723 if (obj2) {
25724 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25725 if (!SWIG_IsOK(ecode3)) {
25726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25727 }
25728 arg3 = static_cast< bool >(val3);
25729 }
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25737 {
25738 if (temp2) delete arg2;
25739 }
25740 return resultobj;
25741 fail:
25742 {
25743 if (temp2) delete arg2;
25744 }
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25750 PyObject *resultobj = 0;
25751 wxDateTime *arg1 = (wxDateTime *) 0 ;
25752 wxDateTime::TimeZone *arg2 = 0 ;
25753 bool arg3 = (bool) false ;
25754 wxDateTime *result = 0 ;
25755 void *argp1 = 0 ;
25756 int res1 = 0 ;
25757 bool temp2 = false ;
25758 bool val3 ;
25759 int ecode3 = 0 ;
25760 PyObject * obj0 = 0 ;
25761 PyObject * obj1 = 0 ;
25762 PyObject * obj2 = 0 ;
25763 char * kwnames[] = {
25764 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25765 };
25766
25767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25769 if (!SWIG_IsOK(res1)) {
25770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25771 }
25772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25773 {
25774 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25775 temp2 = true;
25776 }
25777 if (obj2) {
25778 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25779 if (!SWIG_IsOK(ecode3)) {
25780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25781 }
25782 arg3 = static_cast< bool >(val3);
25783 }
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 {
25787 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25788 result = (wxDateTime *) &_result_ref;
25789 }
25790 wxPyEndAllowThreads(__tstate);
25791 if (PyErr_Occurred()) SWIG_fail;
25792 }
25793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25794 {
25795 if (temp2) delete arg2;
25796 }
25797 return resultobj;
25798 fail:
25799 {
25800 if (temp2) delete arg2;
25801 }
25802 return NULL;
25803 }
25804
25805
25806 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25807 PyObject *resultobj = 0;
25808 wxDateTime *arg1 = (wxDateTime *) 0 ;
25809 wxDateTime::TimeZone *arg2 = 0 ;
25810 bool arg3 = (bool) false ;
25811 wxDateTime result;
25812 void *argp1 = 0 ;
25813 int res1 = 0 ;
25814 bool temp2 = false ;
25815 bool val3 ;
25816 int ecode3 = 0 ;
25817 PyObject * obj0 = 0 ;
25818 PyObject * obj1 = 0 ;
25819 PyObject * obj2 = 0 ;
25820 char * kwnames[] = {
25821 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25822 };
25823
25824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25826 if (!SWIG_IsOK(res1)) {
25827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25828 }
25829 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25830 {
25831 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25832 temp2 = true;
25833 }
25834 if (obj2) {
25835 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25836 if (!SWIG_IsOK(ecode3)) {
25837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25838 }
25839 arg3 = static_cast< bool >(val3);
25840 }
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25844 wxPyEndAllowThreads(__tstate);
25845 if (PyErr_Occurred()) SWIG_fail;
25846 }
25847 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25848 {
25849 if (temp2) delete arg2;
25850 }
25851 return resultobj;
25852 fail:
25853 {
25854 if (temp2) delete arg2;
25855 }
25856 return NULL;
25857 }
25858
25859
25860 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25861 PyObject *resultobj = 0;
25862 wxDateTime *arg1 = (wxDateTime *) 0 ;
25863 wxDateTime::TimeZone *arg2 = 0 ;
25864 bool arg3 = (bool) false ;
25865 wxDateTime *result = 0 ;
25866 void *argp1 = 0 ;
25867 int res1 = 0 ;
25868 bool temp2 = false ;
25869 bool val3 ;
25870 int ecode3 = 0 ;
25871 PyObject * obj0 = 0 ;
25872 PyObject * obj1 = 0 ;
25873 PyObject * obj2 = 0 ;
25874 char * kwnames[] = {
25875 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25876 };
25877
25878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25880 if (!SWIG_IsOK(res1)) {
25881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25882 }
25883 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25884 {
25885 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25886 temp2 = true;
25887 }
25888 if (obj2) {
25889 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25890 if (!SWIG_IsOK(ecode3)) {
25891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25892 }
25893 arg3 = static_cast< bool >(val3);
25894 }
25895 {
25896 PyThreadState* __tstate = wxPyBeginAllowThreads();
25897 {
25898 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25899 result = (wxDateTime *) &_result_ref;
25900 }
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25905 {
25906 if (temp2) delete arg2;
25907 }
25908 return resultobj;
25909 fail:
25910 {
25911 if (temp2) delete arg2;
25912 }
25913 return NULL;
25914 }
25915
25916
25917 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25918 PyObject *resultobj = 0;
25919 wxDateTime *arg1 = (wxDateTime *) 0 ;
25920 bool arg2 = (bool) false ;
25921 wxDateTime result;
25922 void *argp1 = 0 ;
25923 int res1 = 0 ;
25924 bool val2 ;
25925 int ecode2 = 0 ;
25926 PyObject * obj0 = 0 ;
25927 PyObject * obj1 = 0 ;
25928 char * kwnames[] = {
25929 (char *) "self",(char *) "noDST", NULL
25930 };
25931
25932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25934 if (!SWIG_IsOK(res1)) {
25935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25936 }
25937 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25938 if (obj1) {
25939 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25940 if (!SWIG_IsOK(ecode2)) {
25941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25942 }
25943 arg2 = static_cast< bool >(val2);
25944 }
25945 {
25946 PyThreadState* __tstate = wxPyBeginAllowThreads();
25947 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25948 wxPyEndAllowThreads(__tstate);
25949 if (PyErr_Occurred()) SWIG_fail;
25950 }
25951 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25959 PyObject *resultobj = 0;
25960 wxDateTime *arg1 = (wxDateTime *) 0 ;
25961 bool arg2 = (bool) false ;
25962 wxDateTime *result = 0 ;
25963 void *argp1 = 0 ;
25964 int res1 = 0 ;
25965 bool val2 ;
25966 int ecode2 = 0 ;
25967 PyObject * obj0 = 0 ;
25968 PyObject * obj1 = 0 ;
25969 char * kwnames[] = {
25970 (char *) "self",(char *) "noDST", NULL
25971 };
25972
25973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25975 if (!SWIG_IsOK(res1)) {
25976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25977 }
25978 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25979 if (obj1) {
25980 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25981 if (!SWIG_IsOK(ecode2)) {
25982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25983 }
25984 arg2 = static_cast< bool >(val2);
25985 }
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 {
25989 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25990 result = (wxDateTime *) &_result_ref;
25991 }
25992 wxPyEndAllowThreads(__tstate);
25993 if (PyErr_Occurred()) SWIG_fail;
25994 }
25995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25996 return resultobj;
25997 fail:
25998 return NULL;
25999 }
26000
26001
26002 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj = 0;
26004 wxDateTime *arg1 = (wxDateTime *) 0 ;
26005 bool arg2 = (bool) false ;
26006 wxDateTime result;
26007 void *argp1 = 0 ;
26008 int res1 = 0 ;
26009 bool val2 ;
26010 int ecode2 = 0 ;
26011 PyObject * obj0 = 0 ;
26012 PyObject * obj1 = 0 ;
26013 char * kwnames[] = {
26014 (char *) "self",(char *) "noDST", NULL
26015 };
26016
26017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26019 if (!SWIG_IsOK(res1)) {
26020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26021 }
26022 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26023 if (obj1) {
26024 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26025 if (!SWIG_IsOK(ecode2)) {
26026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26027 }
26028 arg2 = static_cast< bool >(val2);
26029 }
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26033 wxPyEndAllowThreads(__tstate);
26034 if (PyErr_Occurred()) SWIG_fail;
26035 }
26036 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26044 PyObject *resultobj = 0;
26045 wxDateTime *arg1 = (wxDateTime *) 0 ;
26046 bool arg2 = (bool) false ;
26047 wxDateTime *result = 0 ;
26048 void *argp1 = 0 ;
26049 int res1 = 0 ;
26050 bool val2 ;
26051 int ecode2 = 0 ;
26052 PyObject * obj0 = 0 ;
26053 PyObject * obj1 = 0 ;
26054 char * kwnames[] = {
26055 (char *) "self",(char *) "noDST", NULL
26056 };
26057
26058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26060 if (!SWIG_IsOK(res1)) {
26061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26062 }
26063 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26064 if (obj1) {
26065 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26066 if (!SWIG_IsOK(ecode2)) {
26067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26068 }
26069 arg2 = static_cast< bool >(val2);
26070 }
26071 {
26072 PyThreadState* __tstate = wxPyBeginAllowThreads();
26073 {
26074 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26075 result = (wxDateTime *) &_result_ref;
26076 }
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26081 return resultobj;
26082 fail:
26083 return NULL;
26084 }
26085
26086
26087 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26088 PyObject *resultobj = 0;
26089 wxDateTime *arg1 = (wxDateTime *) 0 ;
26090 bool arg2 = (bool) false ;
26091 wxDateTime result;
26092 void *argp1 = 0 ;
26093 int res1 = 0 ;
26094 bool val2 ;
26095 int ecode2 = 0 ;
26096 PyObject * obj0 = 0 ;
26097 PyObject * obj1 = 0 ;
26098 char * kwnames[] = {
26099 (char *) "self",(char *) "noDST", NULL
26100 };
26101
26102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26104 if (!SWIG_IsOK(res1)) {
26105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26106 }
26107 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26108 if (obj1) {
26109 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26110 if (!SWIG_IsOK(ecode2)) {
26111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26112 }
26113 arg2 = static_cast< bool >(val2);
26114 }
26115 {
26116 PyThreadState* __tstate = wxPyBeginAllowThreads();
26117 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26129 PyObject *resultobj = 0;
26130 wxDateTime *arg1 = (wxDateTime *) 0 ;
26131 bool arg2 = (bool) false ;
26132 wxDateTime *result = 0 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 bool val2 ;
26136 int ecode2 = 0 ;
26137 PyObject * obj0 = 0 ;
26138 PyObject * obj1 = 0 ;
26139 char * kwnames[] = {
26140 (char *) "self",(char *) "noDST", NULL
26141 };
26142
26143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26145 if (!SWIG_IsOK(res1)) {
26146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26147 }
26148 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26149 if (obj1) {
26150 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26151 if (!SWIG_IsOK(ecode2)) {
26152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26153 }
26154 arg2 = static_cast< bool >(val2);
26155 }
26156 {
26157 PyThreadState* __tstate = wxPyBeginAllowThreads();
26158 {
26159 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26160 result = (wxDateTime *) &_result_ref;
26161 }
26162 wxPyEndAllowThreads(__tstate);
26163 if (PyErr_Occurred()) SWIG_fail;
26164 }
26165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26166 return resultobj;
26167 fail:
26168 return NULL;
26169 }
26170
26171
26172 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26173 PyObject *resultobj = 0;
26174 wxDateTime *arg1 = (wxDateTime *) 0 ;
26175 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26176 int result;
26177 void *argp1 = 0 ;
26178 int res1 = 0 ;
26179 int val2 ;
26180 int ecode2 = 0 ;
26181 PyObject * obj0 = 0 ;
26182 PyObject * obj1 = 0 ;
26183 char * kwnames[] = {
26184 (char *) "self",(char *) "country", NULL
26185 };
26186
26187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26189 if (!SWIG_IsOK(res1)) {
26190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26191 }
26192 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26193 if (obj1) {
26194 ecode2 = SWIG_AsVal_int(obj1, &val2);
26195 if (!SWIG_IsOK(ecode2)) {
26196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26197 }
26198 arg2 = static_cast< wxDateTime::Country >(val2);
26199 }
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 result = (int)(arg1)->IsDST(arg2);
26203 wxPyEndAllowThreads(__tstate);
26204 if (PyErr_Occurred()) SWIG_fail;
26205 }
26206 resultobj = SWIG_From_int(static_cast< int >(result));
26207 return resultobj;
26208 fail:
26209 return NULL;
26210 }
26211
26212
26213 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26214 PyObject *resultobj = 0;
26215 wxDateTime *arg1 = (wxDateTime *) 0 ;
26216 bool result;
26217 void *argp1 = 0 ;
26218 int res1 = 0 ;
26219 PyObject *swig_obj[1] ;
26220
26221 if (!args) SWIG_fail;
26222 swig_obj[0] = args;
26223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26224 if (!SWIG_IsOK(res1)) {
26225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26226 }
26227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26228 {
26229 PyThreadState* __tstate = wxPyBeginAllowThreads();
26230 result = (bool)((wxDateTime const *)arg1)->IsValid();
26231 wxPyEndAllowThreads(__tstate);
26232 if (PyErr_Occurred()) SWIG_fail;
26233 }
26234 {
26235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26236 }
26237 return resultobj;
26238 fail:
26239 return NULL;
26240 }
26241
26242
26243 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26244 PyObject *resultobj = 0;
26245 wxDateTime *arg1 = (wxDateTime *) 0 ;
26246 time_t result;
26247 void *argp1 = 0 ;
26248 int res1 = 0 ;
26249 PyObject *swig_obj[1] ;
26250
26251 if (!args) SWIG_fail;
26252 swig_obj[0] = args;
26253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26254 if (!SWIG_IsOK(res1)) {
26255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26256 }
26257 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26258 {
26259 PyThreadState* __tstate = wxPyBeginAllowThreads();
26260 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26261 wxPyEndAllowThreads(__tstate);
26262 if (PyErr_Occurred()) SWIG_fail;
26263 }
26264 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26265 return resultobj;
26266 fail:
26267 return NULL;
26268 }
26269
26270
26271 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26272 PyObject *resultobj = 0;
26273 wxDateTime *arg1 = (wxDateTime *) 0 ;
26274 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26275 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26276 int result;
26277 void *argp1 = 0 ;
26278 int res1 = 0 ;
26279 bool temp2 = false ;
26280 PyObject * obj0 = 0 ;
26281 PyObject * obj1 = 0 ;
26282 char * kwnames[] = {
26283 (char *) "self",(char *) "tz", NULL
26284 };
26285
26286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26288 if (!SWIG_IsOK(res1)) {
26289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26290 }
26291 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26292 if (obj1) {
26293 {
26294 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26295 temp2 = true;
26296 }
26297 }
26298 {
26299 PyThreadState* __tstate = wxPyBeginAllowThreads();
26300 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26301 wxPyEndAllowThreads(__tstate);
26302 if (PyErr_Occurred()) SWIG_fail;
26303 }
26304 resultobj = SWIG_From_int(static_cast< int >(result));
26305 {
26306 if (temp2) delete arg2;
26307 }
26308 return resultobj;
26309 fail:
26310 {
26311 if (temp2) delete arg2;
26312 }
26313 return NULL;
26314 }
26315
26316
26317 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26318 PyObject *resultobj = 0;
26319 wxDateTime *arg1 = (wxDateTime *) 0 ;
26320 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26321 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26322 wxDateTime::Month result;
26323 void *argp1 = 0 ;
26324 int res1 = 0 ;
26325 bool temp2 = false ;
26326 PyObject * obj0 = 0 ;
26327 PyObject * obj1 = 0 ;
26328 char * kwnames[] = {
26329 (char *) "self",(char *) "tz", NULL
26330 };
26331
26332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26334 if (!SWIG_IsOK(res1)) {
26335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26336 }
26337 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26338 if (obj1) {
26339 {
26340 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26341 temp2 = true;
26342 }
26343 }
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 resultobj = SWIG_From_int(static_cast< int >(result));
26351 {
26352 if (temp2) delete arg2;
26353 }
26354 return resultobj;
26355 fail:
26356 {
26357 if (temp2) delete arg2;
26358 }
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26364 PyObject *resultobj = 0;
26365 wxDateTime *arg1 = (wxDateTime *) 0 ;
26366 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26367 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26368 int result;
26369 void *argp1 = 0 ;
26370 int res1 = 0 ;
26371 bool temp2 = false ;
26372 PyObject * obj0 = 0 ;
26373 PyObject * obj1 = 0 ;
26374 char * kwnames[] = {
26375 (char *) "self",(char *) "tz", NULL
26376 };
26377
26378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26380 if (!SWIG_IsOK(res1)) {
26381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26382 }
26383 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26384 if (obj1) {
26385 {
26386 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26387 temp2 = true;
26388 }
26389 }
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26393 wxPyEndAllowThreads(__tstate);
26394 if (PyErr_Occurred()) SWIG_fail;
26395 }
26396 resultobj = SWIG_From_int(static_cast< int >(result));
26397 {
26398 if (temp2) delete arg2;
26399 }
26400 return resultobj;
26401 fail:
26402 {
26403 if (temp2) delete arg2;
26404 }
26405 return NULL;
26406 }
26407
26408
26409 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26410 PyObject *resultobj = 0;
26411 wxDateTime *arg1 = (wxDateTime *) 0 ;
26412 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26413 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26414 wxDateTime::WeekDay result;
26415 void *argp1 = 0 ;
26416 int res1 = 0 ;
26417 bool temp2 = false ;
26418 PyObject * obj0 = 0 ;
26419 PyObject * obj1 = 0 ;
26420 char * kwnames[] = {
26421 (char *) "self",(char *) "tz", NULL
26422 };
26423
26424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26426 if (!SWIG_IsOK(res1)) {
26427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26428 }
26429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26430 if (obj1) {
26431 {
26432 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26433 temp2 = true;
26434 }
26435 }
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26439 wxPyEndAllowThreads(__tstate);
26440 if (PyErr_Occurred()) SWIG_fail;
26441 }
26442 resultobj = SWIG_From_int(static_cast< int >(result));
26443 {
26444 if (temp2) delete arg2;
26445 }
26446 return resultobj;
26447 fail:
26448 {
26449 if (temp2) delete arg2;
26450 }
26451 return NULL;
26452 }
26453
26454
26455 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj = 0;
26457 wxDateTime *arg1 = (wxDateTime *) 0 ;
26458 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26459 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26460 int result;
26461 void *argp1 = 0 ;
26462 int res1 = 0 ;
26463 bool temp2 = false ;
26464 PyObject * obj0 = 0 ;
26465 PyObject * obj1 = 0 ;
26466 char * kwnames[] = {
26467 (char *) "self",(char *) "tz", NULL
26468 };
26469
26470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26472 if (!SWIG_IsOK(res1)) {
26473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26474 }
26475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26476 if (obj1) {
26477 {
26478 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26479 temp2 = true;
26480 }
26481 }
26482 {
26483 PyThreadState* __tstate = wxPyBeginAllowThreads();
26484 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26485 wxPyEndAllowThreads(__tstate);
26486 if (PyErr_Occurred()) SWIG_fail;
26487 }
26488 resultobj = SWIG_From_int(static_cast< int >(result));
26489 {
26490 if (temp2) delete arg2;
26491 }
26492 return resultobj;
26493 fail:
26494 {
26495 if (temp2) delete arg2;
26496 }
26497 return NULL;
26498 }
26499
26500
26501 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26502 PyObject *resultobj = 0;
26503 wxDateTime *arg1 = (wxDateTime *) 0 ;
26504 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26505 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26506 int result;
26507 void *argp1 = 0 ;
26508 int res1 = 0 ;
26509 bool temp2 = false ;
26510 PyObject * obj0 = 0 ;
26511 PyObject * obj1 = 0 ;
26512 char * kwnames[] = {
26513 (char *) "self",(char *) "tz", NULL
26514 };
26515
26516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26518 if (!SWIG_IsOK(res1)) {
26519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26520 }
26521 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26522 if (obj1) {
26523 {
26524 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26525 temp2 = true;
26526 }
26527 }
26528 {
26529 PyThreadState* __tstate = wxPyBeginAllowThreads();
26530 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26531 wxPyEndAllowThreads(__tstate);
26532 if (PyErr_Occurred()) SWIG_fail;
26533 }
26534 resultobj = SWIG_From_int(static_cast< int >(result));
26535 {
26536 if (temp2) delete arg2;
26537 }
26538 return resultobj;
26539 fail:
26540 {
26541 if (temp2) delete arg2;
26542 }
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj = 0;
26549 wxDateTime *arg1 = (wxDateTime *) 0 ;
26550 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26551 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26552 int result;
26553 void *argp1 = 0 ;
26554 int res1 = 0 ;
26555 bool temp2 = false ;
26556 PyObject * obj0 = 0 ;
26557 PyObject * obj1 = 0 ;
26558 char * kwnames[] = {
26559 (char *) "self",(char *) "tz", NULL
26560 };
26561
26562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26564 if (!SWIG_IsOK(res1)) {
26565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26566 }
26567 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26568 if (obj1) {
26569 {
26570 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26571 temp2 = true;
26572 }
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 resultobj = SWIG_From_int(static_cast< int >(result));
26581 {
26582 if (temp2) delete arg2;
26583 }
26584 return resultobj;
26585 fail:
26586 {
26587 if (temp2) delete arg2;
26588 }
26589 return NULL;
26590 }
26591
26592
26593 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26594 PyObject *resultobj = 0;
26595 wxDateTime *arg1 = (wxDateTime *) 0 ;
26596 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26597 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26598 int result;
26599 void *argp1 = 0 ;
26600 int res1 = 0 ;
26601 bool temp2 = false ;
26602 PyObject * obj0 = 0 ;
26603 PyObject * obj1 = 0 ;
26604 char * kwnames[] = {
26605 (char *) "self",(char *) "tz", NULL
26606 };
26607
26608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26610 if (!SWIG_IsOK(res1)) {
26611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26612 }
26613 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26614 if (obj1) {
26615 {
26616 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26617 temp2 = true;
26618 }
26619 }
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26623 wxPyEndAllowThreads(__tstate);
26624 if (PyErr_Occurred()) SWIG_fail;
26625 }
26626 resultobj = SWIG_From_int(static_cast< int >(result));
26627 {
26628 if (temp2) delete arg2;
26629 }
26630 return resultobj;
26631 fail:
26632 {
26633 if (temp2) delete arg2;
26634 }
26635 return NULL;
26636 }
26637
26638
26639 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj = 0;
26641 wxDateTime *arg1 = (wxDateTime *) 0 ;
26642 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26643 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26644 int result;
26645 void *argp1 = 0 ;
26646 int res1 = 0 ;
26647 bool temp2 = false ;
26648 PyObject * obj0 = 0 ;
26649 PyObject * obj1 = 0 ;
26650 char * kwnames[] = {
26651 (char *) "self",(char *) "tz", NULL
26652 };
26653
26654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26656 if (!SWIG_IsOK(res1)) {
26657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26658 }
26659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26660 if (obj1) {
26661 {
26662 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26663 temp2 = true;
26664 }
26665 }
26666 {
26667 PyThreadState* __tstate = wxPyBeginAllowThreads();
26668 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26669 wxPyEndAllowThreads(__tstate);
26670 if (PyErr_Occurred()) SWIG_fail;
26671 }
26672 resultobj = SWIG_From_int(static_cast< int >(result));
26673 {
26674 if (temp2) delete arg2;
26675 }
26676 return resultobj;
26677 fail:
26678 {
26679 if (temp2) delete arg2;
26680 }
26681 return NULL;
26682 }
26683
26684
26685 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26686 PyObject *resultobj = 0;
26687 wxDateTime *arg1 = (wxDateTime *) 0 ;
26688 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26689 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26690 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26691 int result;
26692 void *argp1 = 0 ;
26693 int res1 = 0 ;
26694 int val2 ;
26695 int ecode2 = 0 ;
26696 bool temp3 = false ;
26697 PyObject * obj0 = 0 ;
26698 PyObject * obj1 = 0 ;
26699 PyObject * obj2 = 0 ;
26700 char * kwnames[] = {
26701 (char *) "self",(char *) "flags",(char *) "tz", NULL
26702 };
26703
26704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26706 if (!SWIG_IsOK(res1)) {
26707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26708 }
26709 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26710 if (obj1) {
26711 ecode2 = SWIG_AsVal_int(obj1, &val2);
26712 if (!SWIG_IsOK(ecode2)) {
26713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26714 }
26715 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26716 }
26717 if (obj2) {
26718 {
26719 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26720 temp3 = true;
26721 }
26722 }
26723 {
26724 PyThreadState* __tstate = wxPyBeginAllowThreads();
26725 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26726 wxPyEndAllowThreads(__tstate);
26727 if (PyErr_Occurred()) SWIG_fail;
26728 }
26729 resultobj = SWIG_From_int(static_cast< int >(result));
26730 {
26731 if (temp3) delete arg3;
26732 }
26733 return resultobj;
26734 fail:
26735 {
26736 if (temp3) delete arg3;
26737 }
26738 return NULL;
26739 }
26740
26741
26742 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26743 PyObject *resultobj = 0;
26744 wxDateTime *arg1 = (wxDateTime *) 0 ;
26745 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26746 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26747 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26748 int result;
26749 void *argp1 = 0 ;
26750 int res1 = 0 ;
26751 int val2 ;
26752 int ecode2 = 0 ;
26753 bool temp3 = false ;
26754 PyObject * obj0 = 0 ;
26755 PyObject * obj1 = 0 ;
26756 PyObject * obj2 = 0 ;
26757 char * kwnames[] = {
26758 (char *) "self",(char *) "flags",(char *) "tz", NULL
26759 };
26760
26761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26763 if (!SWIG_IsOK(res1)) {
26764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26765 }
26766 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26767 if (obj1) {
26768 ecode2 = SWIG_AsVal_int(obj1, &val2);
26769 if (!SWIG_IsOK(ecode2)) {
26770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26771 }
26772 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26773 }
26774 if (obj2) {
26775 {
26776 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26777 temp3 = true;
26778 }
26779 }
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 resultobj = SWIG_From_int(static_cast< int >(result));
26787 {
26788 if (temp3) delete arg3;
26789 }
26790 return resultobj;
26791 fail:
26792 {
26793 if (temp3) delete arg3;
26794 }
26795 return NULL;
26796 }
26797
26798
26799 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26800 PyObject *resultobj = 0;
26801 wxDateTime *arg1 = (wxDateTime *) 0 ;
26802 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26803 bool result;
26804 void *argp1 = 0 ;
26805 int res1 = 0 ;
26806 int val2 ;
26807 int ecode2 = 0 ;
26808 PyObject * obj0 = 0 ;
26809 PyObject * obj1 = 0 ;
26810 char * kwnames[] = {
26811 (char *) "self",(char *) "country", NULL
26812 };
26813
26814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26816 if (!SWIG_IsOK(res1)) {
26817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26818 }
26819 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26820 if (obj1) {
26821 ecode2 = SWIG_AsVal_int(obj1, &val2);
26822 if (!SWIG_IsOK(ecode2)) {
26823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26824 }
26825 arg2 = static_cast< wxDateTime::Country >(val2);
26826 }
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26830 wxPyEndAllowThreads(__tstate);
26831 if (PyErr_Occurred()) SWIG_fail;
26832 }
26833 {
26834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26835 }
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26843 PyObject *resultobj = 0;
26844 wxDateTime *arg1 = (wxDateTime *) 0 ;
26845 wxDateTime *arg2 = 0 ;
26846 bool result;
26847 void *argp1 = 0 ;
26848 int res1 = 0 ;
26849 void *argp2 = 0 ;
26850 int res2 = 0 ;
26851 PyObject * obj0 = 0 ;
26852 PyObject * obj1 = 0 ;
26853 char * kwnames[] = {
26854 (char *) "self",(char *) "datetime", NULL
26855 };
26856
26857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26859 if (!SWIG_IsOK(res1)) {
26860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26861 }
26862 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26864 if (!SWIG_IsOK(res2)) {
26865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26866 }
26867 if (!argp2) {
26868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26869 }
26870 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26874 wxPyEndAllowThreads(__tstate);
26875 if (PyErr_Occurred()) SWIG_fail;
26876 }
26877 {
26878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26879 }
26880 return resultobj;
26881 fail:
26882 return NULL;
26883 }
26884
26885
26886 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26887 PyObject *resultobj = 0;
26888 wxDateTime *arg1 = (wxDateTime *) 0 ;
26889 wxDateTime *arg2 = 0 ;
26890 bool result;
26891 void *argp1 = 0 ;
26892 int res1 = 0 ;
26893 void *argp2 = 0 ;
26894 int res2 = 0 ;
26895 PyObject * obj0 = 0 ;
26896 PyObject * obj1 = 0 ;
26897 char * kwnames[] = {
26898 (char *) "self",(char *) "datetime", NULL
26899 };
26900
26901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26903 if (!SWIG_IsOK(res1)) {
26904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26905 }
26906 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26907 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26908 if (!SWIG_IsOK(res2)) {
26909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26910 }
26911 if (!argp2) {
26912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26913 }
26914 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 {
26922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26923 }
26924 return resultobj;
26925 fail:
26926 return NULL;
26927 }
26928
26929
26930 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26931 PyObject *resultobj = 0;
26932 wxDateTime *arg1 = (wxDateTime *) 0 ;
26933 wxDateTime *arg2 = 0 ;
26934 bool result;
26935 void *argp1 = 0 ;
26936 int res1 = 0 ;
26937 void *argp2 = 0 ;
26938 int res2 = 0 ;
26939 PyObject * obj0 = 0 ;
26940 PyObject * obj1 = 0 ;
26941 char * kwnames[] = {
26942 (char *) "self",(char *) "datetime", NULL
26943 };
26944
26945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26947 if (!SWIG_IsOK(res1)) {
26948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26949 }
26950 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26951 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26952 if (!SWIG_IsOK(res2)) {
26953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26954 }
26955 if (!argp2) {
26956 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26957 }
26958 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 {
26966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26967 }
26968 return resultobj;
26969 fail:
26970 return NULL;
26971 }
26972
26973
26974 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26975 PyObject *resultobj = 0;
26976 wxDateTime *arg1 = (wxDateTime *) 0 ;
26977 wxDateTime *arg2 = 0 ;
26978 wxDateTime *arg3 = 0 ;
26979 bool result;
26980 void *argp1 = 0 ;
26981 int res1 = 0 ;
26982 void *argp2 = 0 ;
26983 int res2 = 0 ;
26984 void *argp3 = 0 ;
26985 int res3 = 0 ;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 PyObject * obj2 = 0 ;
26989 char * kwnames[] = {
26990 (char *) "self",(char *) "t1",(char *) "t2", NULL
26991 };
26992
26993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26995 if (!SWIG_IsOK(res1)) {
26996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26997 }
26998 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26999 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27000 if (!SWIG_IsOK(res2)) {
27001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27002 }
27003 if (!argp2) {
27004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27005 }
27006 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27007 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27008 if (!SWIG_IsOK(res3)) {
27009 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27010 }
27011 if (!argp3) {
27012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27013 }
27014 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27015 {
27016 PyThreadState* __tstate = wxPyBeginAllowThreads();
27017 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27018 wxPyEndAllowThreads(__tstate);
27019 if (PyErr_Occurred()) SWIG_fail;
27020 }
27021 {
27022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27023 }
27024 return resultobj;
27025 fail:
27026 return NULL;
27027 }
27028
27029
27030 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27031 PyObject *resultobj = 0;
27032 wxDateTime *arg1 = (wxDateTime *) 0 ;
27033 wxDateTime *arg2 = 0 ;
27034 wxDateTime *arg3 = 0 ;
27035 bool result;
27036 void *argp1 = 0 ;
27037 int res1 = 0 ;
27038 void *argp2 = 0 ;
27039 int res2 = 0 ;
27040 void *argp3 = 0 ;
27041 int res3 = 0 ;
27042 PyObject * obj0 = 0 ;
27043 PyObject * obj1 = 0 ;
27044 PyObject * obj2 = 0 ;
27045 char * kwnames[] = {
27046 (char *) "self",(char *) "t1",(char *) "t2", NULL
27047 };
27048
27049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27051 if (!SWIG_IsOK(res1)) {
27052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27053 }
27054 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27056 if (!SWIG_IsOK(res2)) {
27057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27058 }
27059 if (!argp2) {
27060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27061 }
27062 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27063 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27064 if (!SWIG_IsOK(res3)) {
27065 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27066 }
27067 if (!argp3) {
27068 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27069 }
27070 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27071 {
27072 PyThreadState* __tstate = wxPyBeginAllowThreads();
27073 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27074 wxPyEndAllowThreads(__tstate);
27075 if (PyErr_Occurred()) SWIG_fail;
27076 }
27077 {
27078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27079 }
27080 return resultobj;
27081 fail:
27082 return NULL;
27083 }
27084
27085
27086 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27087 PyObject *resultobj = 0;
27088 wxDateTime *arg1 = (wxDateTime *) 0 ;
27089 wxDateTime *arg2 = 0 ;
27090 bool result;
27091 void *argp1 = 0 ;
27092 int res1 = 0 ;
27093 void *argp2 = 0 ;
27094 int res2 = 0 ;
27095 PyObject * obj0 = 0 ;
27096 PyObject * obj1 = 0 ;
27097 char * kwnames[] = {
27098 (char *) "self",(char *) "dt", NULL
27099 };
27100
27101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27103 if (!SWIG_IsOK(res1)) {
27104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27105 }
27106 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27107 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27108 if (!SWIG_IsOK(res2)) {
27109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27110 }
27111 if (!argp2) {
27112 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27113 }
27114 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27115 {
27116 PyThreadState* __tstate = wxPyBeginAllowThreads();
27117 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 {
27122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27123 }
27124 return resultobj;
27125 fail:
27126 return NULL;
27127 }
27128
27129
27130 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27131 PyObject *resultobj = 0;
27132 wxDateTime *arg1 = (wxDateTime *) 0 ;
27133 wxDateTime *arg2 = 0 ;
27134 bool result;
27135 void *argp1 = 0 ;
27136 int res1 = 0 ;
27137 void *argp2 = 0 ;
27138 int res2 = 0 ;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 char * kwnames[] = {
27142 (char *) "self",(char *) "dt", NULL
27143 };
27144
27145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27147 if (!SWIG_IsOK(res1)) {
27148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27149 }
27150 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27152 if (!SWIG_IsOK(res2)) {
27153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27154 }
27155 if (!argp2) {
27156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27157 }
27158 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27159 {
27160 PyThreadState* __tstate = wxPyBeginAllowThreads();
27161 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27162 wxPyEndAllowThreads(__tstate);
27163 if (PyErr_Occurred()) SWIG_fail;
27164 }
27165 {
27166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27167 }
27168 return resultobj;
27169 fail:
27170 return NULL;
27171 }
27172
27173
27174 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27175 PyObject *resultobj = 0;
27176 wxDateTime *arg1 = (wxDateTime *) 0 ;
27177 wxDateTime *arg2 = 0 ;
27178 wxTimeSpan *arg3 = 0 ;
27179 bool result;
27180 void *argp1 = 0 ;
27181 int res1 = 0 ;
27182 void *argp2 = 0 ;
27183 int res2 = 0 ;
27184 void *argp3 = 0 ;
27185 int res3 = 0 ;
27186 PyObject * obj0 = 0 ;
27187 PyObject * obj1 = 0 ;
27188 PyObject * obj2 = 0 ;
27189 char * kwnames[] = {
27190 (char *) "self",(char *) "dt",(char *) "ts", NULL
27191 };
27192
27193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27195 if (!SWIG_IsOK(res1)) {
27196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27197 }
27198 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27199 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27200 if (!SWIG_IsOK(res2)) {
27201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27202 }
27203 if (!argp2) {
27204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27205 }
27206 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27207 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27208 if (!SWIG_IsOK(res3)) {
27209 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27210 }
27211 if (!argp3) {
27212 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27213 }
27214 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27215 {
27216 PyThreadState* __tstate = wxPyBeginAllowThreads();
27217 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27218 wxPyEndAllowThreads(__tstate);
27219 if (PyErr_Occurred()) SWIG_fail;
27220 }
27221 {
27222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27223 }
27224 return resultobj;
27225 fail:
27226 return NULL;
27227 }
27228
27229
27230 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27231 PyObject *resultobj = 0;
27232 wxDateTime *arg1 = (wxDateTime *) 0 ;
27233 wxTimeSpan *arg2 = 0 ;
27234 wxDateTime *result = 0 ;
27235 void *argp1 = 0 ;
27236 int res1 = 0 ;
27237 void *argp2 = 0 ;
27238 int res2 = 0 ;
27239 PyObject * obj0 = 0 ;
27240 PyObject * obj1 = 0 ;
27241 char * kwnames[] = {
27242 (char *) "self",(char *) "diff", NULL
27243 };
27244
27245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27247 if (!SWIG_IsOK(res1)) {
27248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27249 }
27250 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27251 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27252 if (!SWIG_IsOK(res2)) {
27253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27254 }
27255 if (!argp2) {
27256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27257 }
27258 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 {
27262 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27263 result = (wxDateTime *) &_result_ref;
27264 }
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27276 PyObject *resultobj = 0;
27277 wxDateTime *arg1 = (wxDateTime *) 0 ;
27278 wxDateSpan *arg2 = 0 ;
27279 wxDateTime *result = 0 ;
27280 void *argp1 = 0 ;
27281 int res1 = 0 ;
27282 void *argp2 = 0 ;
27283 int res2 = 0 ;
27284 PyObject * obj0 = 0 ;
27285 PyObject * obj1 = 0 ;
27286 char * kwnames[] = {
27287 (char *) "self",(char *) "diff", NULL
27288 };
27289
27290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27292 if (!SWIG_IsOK(res1)) {
27293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27294 }
27295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27297 if (!SWIG_IsOK(res2)) {
27298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27299 }
27300 if (!argp2) {
27301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27302 }
27303 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 {
27307 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27308 result = (wxDateTime *) &_result_ref;
27309 }
27310 wxPyEndAllowThreads(__tstate);
27311 if (PyErr_Occurred()) SWIG_fail;
27312 }
27313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27321 PyObject *resultobj = 0;
27322 wxDateTime *arg1 = (wxDateTime *) 0 ;
27323 wxTimeSpan *arg2 = 0 ;
27324 wxDateTime *result = 0 ;
27325 void *argp1 = 0 ;
27326 int res1 = 0 ;
27327 void *argp2 = 0 ;
27328 int res2 = 0 ;
27329 PyObject * obj0 = 0 ;
27330 PyObject * obj1 = 0 ;
27331 char * kwnames[] = {
27332 (char *) "self",(char *) "diff", NULL
27333 };
27334
27335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27337 if (!SWIG_IsOK(res1)) {
27338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27339 }
27340 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27341 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27342 if (!SWIG_IsOK(res2)) {
27343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27344 }
27345 if (!argp2) {
27346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27347 }
27348 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27349 {
27350 PyThreadState* __tstate = wxPyBeginAllowThreads();
27351 {
27352 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27353 result = (wxDateTime *) &_result_ref;
27354 }
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27359 return resultobj;
27360 fail:
27361 return NULL;
27362 }
27363
27364
27365 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27366 PyObject *resultobj = 0;
27367 wxDateTime *arg1 = (wxDateTime *) 0 ;
27368 wxDateSpan *arg2 = 0 ;
27369 wxDateTime *result = 0 ;
27370 void *argp1 = 0 ;
27371 int res1 = 0 ;
27372 void *argp2 = 0 ;
27373 int res2 = 0 ;
27374 PyObject * obj0 = 0 ;
27375 PyObject * obj1 = 0 ;
27376 char * kwnames[] = {
27377 (char *) "self",(char *) "diff", NULL
27378 };
27379
27380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27384 }
27385 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27386 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27387 if (!SWIG_IsOK(res2)) {
27388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27389 }
27390 if (!argp2) {
27391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27392 }
27393 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 {
27397 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27398 result = (wxDateTime *) &_result_ref;
27399 }
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj = 0;
27412 wxDateTime *arg1 = (wxDateTime *) 0 ;
27413 wxDateTime *arg2 = 0 ;
27414 wxTimeSpan result;
27415 void *argp1 = 0 ;
27416 int res1 = 0 ;
27417 void *argp2 = 0 ;
27418 int res2 = 0 ;
27419 PyObject * obj0 = 0 ;
27420 PyObject * obj1 = 0 ;
27421 char * kwnames[] = {
27422 (char *) "self",(char *) "dt", NULL
27423 };
27424
27425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27427 if (!SWIG_IsOK(res1)) {
27428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27429 }
27430 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27431 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27432 if (!SWIG_IsOK(res2)) {
27433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27434 }
27435 if (!argp2) {
27436 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27437 }
27438 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27442 wxPyEndAllowThreads(__tstate);
27443 if (PyErr_Occurred()) SWIG_fail;
27444 }
27445 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27453 PyObject *resultobj = 0;
27454 wxDateTime *arg1 = (wxDateTime *) 0 ;
27455 wxTimeSpan *arg2 = 0 ;
27456 wxDateTime *result = 0 ;
27457 void *argp1 = 0 ;
27458 int res1 = 0 ;
27459 void *argp2 = 0 ;
27460 int res2 = 0 ;
27461
27462 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27466 }
27467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27468 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27469 if (!SWIG_IsOK(res2)) {
27470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27471 }
27472 if (!argp2) {
27473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27474 }
27475 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 {
27479 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27480 result = (wxDateTime *) &_result_ref;
27481 }
27482 wxPyEndAllowThreads(__tstate);
27483 if (PyErr_Occurred()) SWIG_fail;
27484 }
27485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27486 return resultobj;
27487 fail:
27488 return NULL;
27489 }
27490
27491
27492 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27493 PyObject *resultobj = 0;
27494 wxDateTime *arg1 = (wxDateTime *) 0 ;
27495 wxDateSpan *arg2 = 0 ;
27496 wxDateTime *result = 0 ;
27497 void *argp1 = 0 ;
27498 int res1 = 0 ;
27499 void *argp2 = 0 ;
27500 int res2 = 0 ;
27501
27502 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27504 if (!SWIG_IsOK(res1)) {
27505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27506 }
27507 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27508 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27509 if (!SWIG_IsOK(res2)) {
27510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27511 }
27512 if (!argp2) {
27513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27514 }
27515 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27516 {
27517 PyThreadState* __tstate = wxPyBeginAllowThreads();
27518 {
27519 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27520 result = (wxDateTime *) &_result_ref;
27521 }
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27533 int argc;
27534 PyObject *argv[3];
27535
27536 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27537 --argc;
27538 if (argc == 2) {
27539 int _v = 0;
27540 {
27541 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27542 _v = SWIG_CheckState(res);
27543 }
27544 if (!_v) goto check_1;
27545 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27546 }
27547 check_1:
27548
27549 if (argc == 2) {
27550 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27551 }
27552
27553 fail:
27554 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27555 return NULL;
27556 }
27557
27558
27559 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27560 PyObject *resultobj = 0;
27561 wxDateTime *arg1 = (wxDateTime *) 0 ;
27562 wxTimeSpan *arg2 = 0 ;
27563 wxDateTime *result = 0 ;
27564 void *argp1 = 0 ;
27565 int res1 = 0 ;
27566 void *argp2 = 0 ;
27567 int res2 = 0 ;
27568
27569 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27571 if (!SWIG_IsOK(res1)) {
27572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27573 }
27574 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27575 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27576 if (!SWIG_IsOK(res2)) {
27577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27578 }
27579 if (!argp2) {
27580 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27581 }
27582 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27583 {
27584 PyThreadState* __tstate = wxPyBeginAllowThreads();
27585 {
27586 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27587 result = (wxDateTime *) &_result_ref;
27588 }
27589 wxPyEndAllowThreads(__tstate);
27590 if (PyErr_Occurred()) SWIG_fail;
27591 }
27592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27593 return resultobj;
27594 fail:
27595 return NULL;
27596 }
27597
27598
27599 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27600 PyObject *resultobj = 0;
27601 wxDateTime *arg1 = (wxDateTime *) 0 ;
27602 wxDateSpan *arg2 = 0 ;
27603 wxDateTime *result = 0 ;
27604 void *argp1 = 0 ;
27605 int res1 = 0 ;
27606 void *argp2 = 0 ;
27607 int res2 = 0 ;
27608
27609 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27611 if (!SWIG_IsOK(res1)) {
27612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27613 }
27614 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27615 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27616 if (!SWIG_IsOK(res2)) {
27617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27618 }
27619 if (!argp2) {
27620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27621 }
27622 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27623 {
27624 PyThreadState* __tstate = wxPyBeginAllowThreads();
27625 {
27626 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27627 result = (wxDateTime *) &_result_ref;
27628 }
27629 wxPyEndAllowThreads(__tstate);
27630 if (PyErr_Occurred()) SWIG_fail;
27631 }
27632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27640 int argc;
27641 PyObject *argv[3];
27642
27643 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27644 --argc;
27645 if (argc == 2) {
27646 int _v = 0;
27647 {
27648 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27649 _v = SWIG_CheckState(res);
27650 }
27651 if (!_v) goto check_1;
27652 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27653 }
27654 check_1:
27655
27656 if (argc == 2) {
27657 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27658 }
27659
27660 fail:
27661 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27662 return NULL;
27663 }
27664
27665
27666 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27667 PyObject *resultobj = 0;
27668 wxDateTime *arg1 = (wxDateTime *) 0 ;
27669 wxTimeSpan *arg2 = 0 ;
27670 wxDateTime result;
27671 void *argp1 = 0 ;
27672 int res1 = 0 ;
27673 void *argp2 = 0 ;
27674 int res2 = 0 ;
27675
27676 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27678 if (!SWIG_IsOK(res1)) {
27679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27680 }
27681 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27682 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27683 if (!SWIG_IsOK(res2)) {
27684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27685 }
27686 if (!argp2) {
27687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27688 }
27689 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27704 PyObject *resultobj = 0;
27705 wxDateTime *arg1 = (wxDateTime *) 0 ;
27706 wxDateSpan *arg2 = 0 ;
27707 wxDateTime result;
27708 void *argp1 = 0 ;
27709 int res1 = 0 ;
27710 void *argp2 = 0 ;
27711 int res2 = 0 ;
27712
27713 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27715 if (!SWIG_IsOK(res1)) {
27716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27717 }
27718 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27719 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27720 if (!SWIG_IsOK(res2)) {
27721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27722 }
27723 if (!argp2) {
27724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27725 }
27726 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27727 {
27728 PyThreadState* __tstate = wxPyBeginAllowThreads();
27729 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27730 wxPyEndAllowThreads(__tstate);
27731 if (PyErr_Occurred()) SWIG_fail;
27732 }
27733 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27734 return resultobj;
27735 fail:
27736 return NULL;
27737 }
27738
27739
27740 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27741 int argc;
27742 PyObject *argv[3];
27743
27744 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27745 --argc;
27746 if (argc == 2) {
27747 int _v = 0;
27748 {
27749 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27750 _v = SWIG_CheckState(res);
27751 }
27752 if (!_v) goto check_1;
27753 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27754 }
27755 check_1:
27756
27757 if (argc == 2) {
27758 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27759 }
27760
27761 fail:
27762 Py_INCREF(Py_NotImplemented);
27763 return Py_NotImplemented;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27768 PyObject *resultobj = 0;
27769 wxDateTime *arg1 = (wxDateTime *) 0 ;
27770 wxDateTime *arg2 = 0 ;
27771 wxTimeSpan result;
27772 void *argp1 = 0 ;
27773 int res1 = 0 ;
27774 void *argp2 = 0 ;
27775 int res2 = 0 ;
27776
27777 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27779 if (!SWIG_IsOK(res1)) {
27780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27781 }
27782 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27783 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27784 if (!SWIG_IsOK(res2)) {
27785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27786 }
27787 if (!argp2) {
27788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27789 }
27790 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27791 {
27792 PyThreadState* __tstate = wxPyBeginAllowThreads();
27793 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27794 wxPyEndAllowThreads(__tstate);
27795 if (PyErr_Occurred()) SWIG_fail;
27796 }
27797 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27798 return resultobj;
27799 fail:
27800 return NULL;
27801 }
27802
27803
27804 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27805 PyObject *resultobj = 0;
27806 wxDateTime *arg1 = (wxDateTime *) 0 ;
27807 wxTimeSpan *arg2 = 0 ;
27808 wxDateTime result;
27809 void *argp1 = 0 ;
27810 int res1 = 0 ;
27811 void *argp2 = 0 ;
27812 int res2 = 0 ;
27813
27814 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27816 if (!SWIG_IsOK(res1)) {
27817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27818 }
27819 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27820 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27821 if (!SWIG_IsOK(res2)) {
27822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27823 }
27824 if (!argp2) {
27825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27826 }
27827 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27831 wxPyEndAllowThreads(__tstate);
27832 if (PyErr_Occurred()) SWIG_fail;
27833 }
27834 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27835 return resultobj;
27836 fail:
27837 return NULL;
27838 }
27839
27840
27841 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27842 PyObject *resultobj = 0;
27843 wxDateTime *arg1 = (wxDateTime *) 0 ;
27844 wxDateSpan *arg2 = 0 ;
27845 wxDateTime result;
27846 void *argp1 = 0 ;
27847 int res1 = 0 ;
27848 void *argp2 = 0 ;
27849 int res2 = 0 ;
27850
27851 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27853 if (!SWIG_IsOK(res1)) {
27854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27855 }
27856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27857 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27858 if (!SWIG_IsOK(res2)) {
27859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27860 }
27861 if (!argp2) {
27862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27863 }
27864 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27865 {
27866 PyThreadState* __tstate = wxPyBeginAllowThreads();
27867 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27872 return resultobj;
27873 fail:
27874 return NULL;
27875 }
27876
27877
27878 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27879 int argc;
27880 PyObject *argv[3];
27881
27882 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27883 --argc;
27884 if (argc == 2) {
27885 int _v = 0;
27886 {
27887 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27888 _v = SWIG_CheckState(res);
27889 }
27890 if (!_v) goto check_1;
27891 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27892 }
27893 check_1:
27894
27895 if (argc == 2) {
27896 int _v = 0;
27897 {
27898 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27899 _v = SWIG_CheckState(res);
27900 }
27901 if (!_v) goto check_2;
27902 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27903 }
27904 check_2:
27905
27906 if (argc == 2) {
27907 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27908 }
27909
27910 fail:
27911 Py_INCREF(Py_NotImplemented);
27912 return Py_NotImplemented;
27913 }
27914
27915
27916 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj = 0;
27918 wxDateTime *arg1 = (wxDateTime *) 0 ;
27919 wxDateTime *arg2 = (wxDateTime *) 0 ;
27920 bool result;
27921 void *argp1 = 0 ;
27922 int res1 = 0 ;
27923 void *argp2 = 0 ;
27924 int res2 = 0 ;
27925 PyObject * obj0 = 0 ;
27926 PyObject * obj1 = 0 ;
27927 char * kwnames[] = {
27928 (char *) "self",(char *) "other", NULL
27929 };
27930
27931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27933 if (!SWIG_IsOK(res1)) {
27934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27935 }
27936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27938 if (!SWIG_IsOK(res2)) {
27939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27940 }
27941 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27950 }
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27958 PyObject *resultobj = 0;
27959 wxDateTime *arg1 = (wxDateTime *) 0 ;
27960 wxDateTime *arg2 = (wxDateTime *) 0 ;
27961 bool result;
27962 void *argp1 = 0 ;
27963 int res1 = 0 ;
27964 void *argp2 = 0 ;
27965 int res2 = 0 ;
27966 PyObject * obj0 = 0 ;
27967 PyObject * obj1 = 0 ;
27968 char * kwnames[] = {
27969 (char *) "self",(char *) "other", NULL
27970 };
27971
27972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27974 if (!SWIG_IsOK(res1)) {
27975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27976 }
27977 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27979 if (!SWIG_IsOK(res2)) {
27980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27981 }
27982 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27983 {
27984 PyThreadState* __tstate = wxPyBeginAllowThreads();
27985 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 {
27990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27991 }
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj = 0;
28000 wxDateTime *arg1 = (wxDateTime *) 0 ;
28001 wxDateTime *arg2 = (wxDateTime *) 0 ;
28002 bool result;
28003 void *argp1 = 0 ;
28004 int res1 = 0 ;
28005 void *argp2 = 0 ;
28006 int res2 = 0 ;
28007 PyObject * obj0 = 0 ;
28008 PyObject * obj1 = 0 ;
28009 char * kwnames[] = {
28010 (char *) "self",(char *) "other", NULL
28011 };
28012
28013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28015 if (!SWIG_IsOK(res1)) {
28016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28017 }
28018 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28020 if (!SWIG_IsOK(res2)) {
28021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28022 }
28023 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28027 wxPyEndAllowThreads(__tstate);
28028 if (PyErr_Occurred()) SWIG_fail;
28029 }
28030 {
28031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28032 }
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28040 PyObject *resultobj = 0;
28041 wxDateTime *arg1 = (wxDateTime *) 0 ;
28042 wxDateTime *arg2 = (wxDateTime *) 0 ;
28043 bool result;
28044 void *argp1 = 0 ;
28045 int res1 = 0 ;
28046 void *argp2 = 0 ;
28047 int res2 = 0 ;
28048 PyObject * obj0 = 0 ;
28049 PyObject * obj1 = 0 ;
28050 char * kwnames[] = {
28051 (char *) "self",(char *) "other", NULL
28052 };
28053
28054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28056 if (!SWIG_IsOK(res1)) {
28057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28058 }
28059 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28061 if (!SWIG_IsOK(res2)) {
28062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28063 }
28064 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28065 {
28066 PyThreadState* __tstate = wxPyBeginAllowThreads();
28067 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 {
28072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28073 }
28074 return resultobj;
28075 fail:
28076 return NULL;
28077 }
28078
28079
28080 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj = 0;
28082 wxDateTime *arg1 = (wxDateTime *) 0 ;
28083 wxDateTime *arg2 = (wxDateTime *) 0 ;
28084 bool result;
28085 void *argp1 = 0 ;
28086 int res1 = 0 ;
28087 void *argp2 = 0 ;
28088 int res2 = 0 ;
28089 PyObject * obj0 = 0 ;
28090 PyObject * obj1 = 0 ;
28091 char * kwnames[] = {
28092 (char *) "self",(char *) "other", NULL
28093 };
28094
28095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28097 if (!SWIG_IsOK(res1)) {
28098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28099 }
28100 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28102 if (!SWIG_IsOK(res2)) {
28103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28104 }
28105 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 {
28113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28122 PyObject *resultobj = 0;
28123 wxDateTime *arg1 = (wxDateTime *) 0 ;
28124 wxDateTime *arg2 = (wxDateTime *) 0 ;
28125 bool result;
28126 void *argp1 = 0 ;
28127 int res1 = 0 ;
28128 void *argp2 = 0 ;
28129 int res2 = 0 ;
28130 PyObject * obj0 = 0 ;
28131 PyObject * obj1 = 0 ;
28132 char * kwnames[] = {
28133 (char *) "self",(char *) "other", NULL
28134 };
28135
28136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28138 if (!SWIG_IsOK(res1)) {
28139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28140 }
28141 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28143 if (!SWIG_IsOK(res2)) {
28144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28145 }
28146 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 {
28154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28155 }
28156 return resultobj;
28157 fail:
28158 return NULL;
28159 }
28160
28161
28162 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28163 PyObject *resultobj = 0;
28164 wxDateTime *arg1 = (wxDateTime *) 0 ;
28165 wxString *arg2 = 0 ;
28166 int result;
28167 void *argp1 = 0 ;
28168 int res1 = 0 ;
28169 bool temp2 = false ;
28170 PyObject * obj0 = 0 ;
28171 PyObject * obj1 = 0 ;
28172 char * kwnames[] = {
28173 (char *) "self",(char *) "date", NULL
28174 };
28175
28176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28178 if (!SWIG_IsOK(res1)) {
28179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28180 }
28181 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28182 {
28183 arg2 = wxString_in_helper(obj1);
28184 if (arg2 == NULL) SWIG_fail;
28185 temp2 = true;
28186 }
28187 {
28188 PyThreadState* __tstate = wxPyBeginAllowThreads();
28189 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 resultobj = SWIG_From_int(static_cast< int >(result));
28194 {
28195 if (temp2)
28196 delete arg2;
28197 }
28198 return resultobj;
28199 fail:
28200 {
28201 if (temp2)
28202 delete arg2;
28203 }
28204 return NULL;
28205 }
28206
28207
28208 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28209 PyObject *resultobj = 0;
28210 wxDateTime *arg1 = (wxDateTime *) 0 ;
28211 wxString *arg2 = 0 ;
28212 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28213 wxString *arg3 = (wxString *) &arg3_defvalue ;
28214 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28215 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28216 int result;
28217 void *argp1 = 0 ;
28218 int res1 = 0 ;
28219 bool temp2 = false ;
28220 bool temp3 = false ;
28221 void *argp4 = 0 ;
28222 int res4 = 0 ;
28223 PyObject * obj0 = 0 ;
28224 PyObject * obj1 = 0 ;
28225 PyObject * obj2 = 0 ;
28226 PyObject * obj3 = 0 ;
28227 char * kwnames[] = {
28228 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28229 };
28230
28231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28233 if (!SWIG_IsOK(res1)) {
28234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28235 }
28236 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28237 {
28238 arg2 = wxString_in_helper(obj1);
28239 if (arg2 == NULL) SWIG_fail;
28240 temp2 = true;
28241 }
28242 if (obj2) {
28243 {
28244 arg3 = wxString_in_helper(obj2);
28245 if (arg3 == NULL) SWIG_fail;
28246 temp3 = true;
28247 }
28248 }
28249 if (obj3) {
28250 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28251 if (!SWIG_IsOK(res4)) {
28252 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28253 }
28254 if (!argp4) {
28255 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28256 }
28257 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28258 }
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 resultobj = SWIG_From_int(static_cast< int >(result));
28266 {
28267 if (temp2)
28268 delete arg2;
28269 }
28270 {
28271 if (temp3)
28272 delete arg3;
28273 }
28274 return resultobj;
28275 fail:
28276 {
28277 if (temp2)
28278 delete arg2;
28279 }
28280 {
28281 if (temp3)
28282 delete arg3;
28283 }
28284 return NULL;
28285 }
28286
28287
28288 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28289 PyObject *resultobj = 0;
28290 wxDateTime *arg1 = (wxDateTime *) 0 ;
28291 wxString *arg2 = 0 ;
28292 int result;
28293 void *argp1 = 0 ;
28294 int res1 = 0 ;
28295 bool temp2 = false ;
28296 PyObject * obj0 = 0 ;
28297 PyObject * obj1 = 0 ;
28298 char * kwnames[] = {
28299 (char *) "self",(char *) "datetime", NULL
28300 };
28301
28302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28304 if (!SWIG_IsOK(res1)) {
28305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28306 }
28307 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28308 {
28309 arg2 = wxString_in_helper(obj1);
28310 if (arg2 == NULL) SWIG_fail;
28311 temp2 = true;
28312 }
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 resultobj = SWIG_From_int(static_cast< int >(result));
28320 {
28321 if (temp2)
28322 delete arg2;
28323 }
28324 return resultobj;
28325 fail:
28326 {
28327 if (temp2)
28328 delete arg2;
28329 }
28330 return NULL;
28331 }
28332
28333
28334 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28335 PyObject *resultobj = 0;
28336 wxDateTime *arg1 = (wxDateTime *) 0 ;
28337 wxString *arg2 = 0 ;
28338 int result;
28339 void *argp1 = 0 ;
28340 int res1 = 0 ;
28341 bool temp2 = false ;
28342 PyObject * obj0 = 0 ;
28343 PyObject * obj1 = 0 ;
28344 char * kwnames[] = {
28345 (char *) "self",(char *) "date", NULL
28346 };
28347
28348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28350 if (!SWIG_IsOK(res1)) {
28351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28352 }
28353 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28354 {
28355 arg2 = wxString_in_helper(obj1);
28356 if (arg2 == NULL) SWIG_fail;
28357 temp2 = true;
28358 }
28359 {
28360 PyThreadState* __tstate = wxPyBeginAllowThreads();
28361 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 resultobj = SWIG_From_int(static_cast< int >(result));
28366 {
28367 if (temp2)
28368 delete arg2;
28369 }
28370 return resultobj;
28371 fail:
28372 {
28373 if (temp2)
28374 delete arg2;
28375 }
28376 return NULL;
28377 }
28378
28379
28380 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28381 PyObject *resultobj = 0;
28382 wxDateTime *arg1 = (wxDateTime *) 0 ;
28383 wxString *arg2 = 0 ;
28384 int result;
28385 void *argp1 = 0 ;
28386 int res1 = 0 ;
28387 bool temp2 = false ;
28388 PyObject * obj0 = 0 ;
28389 PyObject * obj1 = 0 ;
28390 char * kwnames[] = {
28391 (char *) "self",(char *) "time", NULL
28392 };
28393
28394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28396 if (!SWIG_IsOK(res1)) {
28397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28398 }
28399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28400 {
28401 arg2 = wxString_in_helper(obj1);
28402 if (arg2 == NULL) SWIG_fail;
28403 temp2 = true;
28404 }
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 resultobj = SWIG_From_int(static_cast< int >(result));
28412 {
28413 if (temp2)
28414 delete arg2;
28415 }
28416 return resultobj;
28417 fail:
28418 {
28419 if (temp2)
28420 delete arg2;
28421 }
28422 return NULL;
28423 }
28424
28425
28426 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28427 PyObject *resultobj = 0;
28428 wxDateTime *arg1 = (wxDateTime *) 0 ;
28429 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28430 wxString *arg2 = (wxString *) &arg2_defvalue ;
28431 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28432 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28433 wxString result;
28434 void *argp1 = 0 ;
28435 int res1 = 0 ;
28436 bool temp2 = false ;
28437 bool temp3 = false ;
28438 PyObject * obj0 = 0 ;
28439 PyObject * obj1 = 0 ;
28440 PyObject * obj2 = 0 ;
28441 char * kwnames[] = {
28442 (char *) "self",(char *) "format",(char *) "tz", NULL
28443 };
28444
28445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28447 if (!SWIG_IsOK(res1)) {
28448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28449 }
28450 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28451 if (obj1) {
28452 {
28453 arg2 = wxString_in_helper(obj1);
28454 if (arg2 == NULL) SWIG_fail;
28455 temp2 = true;
28456 }
28457 }
28458 if (obj2) {
28459 {
28460 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28461 temp3 = true;
28462 }
28463 }
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28467 wxPyEndAllowThreads(__tstate);
28468 if (PyErr_Occurred()) SWIG_fail;
28469 }
28470 {
28471 #if wxUSE_UNICODE
28472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28473 #else
28474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28475 #endif
28476 }
28477 {
28478 if (temp2)
28479 delete arg2;
28480 }
28481 {
28482 if (temp3) delete arg3;
28483 }
28484 return resultobj;
28485 fail:
28486 {
28487 if (temp2)
28488 delete arg2;
28489 }
28490 {
28491 if (temp3) delete arg3;
28492 }
28493 return NULL;
28494 }
28495
28496
28497 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28498 PyObject *resultobj = 0;
28499 wxDateTime *arg1 = (wxDateTime *) 0 ;
28500 wxString result;
28501 void *argp1 = 0 ;
28502 int res1 = 0 ;
28503 PyObject *swig_obj[1] ;
28504
28505 if (!args) SWIG_fail;
28506 swig_obj[0] = args;
28507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28508 if (!SWIG_IsOK(res1)) {
28509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28510 }
28511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28512 {
28513 PyThreadState* __tstate = wxPyBeginAllowThreads();
28514 result = ((wxDateTime const *)arg1)->FormatDate();
28515 wxPyEndAllowThreads(__tstate);
28516 if (PyErr_Occurred()) SWIG_fail;
28517 }
28518 {
28519 #if wxUSE_UNICODE
28520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28521 #else
28522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28523 #endif
28524 }
28525 return resultobj;
28526 fail:
28527 return NULL;
28528 }
28529
28530
28531 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28532 PyObject *resultobj = 0;
28533 wxDateTime *arg1 = (wxDateTime *) 0 ;
28534 wxString result;
28535 void *argp1 = 0 ;
28536 int res1 = 0 ;
28537 PyObject *swig_obj[1] ;
28538
28539 if (!args) SWIG_fail;
28540 swig_obj[0] = args;
28541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28542 if (!SWIG_IsOK(res1)) {
28543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28544 }
28545 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28546 {
28547 PyThreadState* __tstate = wxPyBeginAllowThreads();
28548 result = ((wxDateTime const *)arg1)->FormatTime();
28549 wxPyEndAllowThreads(__tstate);
28550 if (PyErr_Occurred()) SWIG_fail;
28551 }
28552 {
28553 #if wxUSE_UNICODE
28554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28555 #else
28556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28557 #endif
28558 }
28559 return resultobj;
28560 fail:
28561 return NULL;
28562 }
28563
28564
28565 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28566 PyObject *resultobj = 0;
28567 wxDateTime *arg1 = (wxDateTime *) 0 ;
28568 wxString result;
28569 void *argp1 = 0 ;
28570 int res1 = 0 ;
28571 PyObject *swig_obj[1] ;
28572
28573 if (!args) SWIG_fail;
28574 swig_obj[0] = args;
28575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28576 if (!SWIG_IsOK(res1)) {
28577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28578 }
28579 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28580 {
28581 PyThreadState* __tstate = wxPyBeginAllowThreads();
28582 result = ((wxDateTime const *)arg1)->FormatISODate();
28583 wxPyEndAllowThreads(__tstate);
28584 if (PyErr_Occurred()) SWIG_fail;
28585 }
28586 {
28587 #if wxUSE_UNICODE
28588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28589 #else
28590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28591 #endif
28592 }
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28600 PyObject *resultobj = 0;
28601 wxDateTime *arg1 = (wxDateTime *) 0 ;
28602 wxString result;
28603 void *argp1 = 0 ;
28604 int res1 = 0 ;
28605 PyObject *swig_obj[1] ;
28606
28607 if (!args) SWIG_fail;
28608 swig_obj[0] = args;
28609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28610 if (!SWIG_IsOK(res1)) {
28611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28612 }
28613 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 result = ((wxDateTime const *)arg1)->FormatISOTime();
28617 wxPyEndAllowThreads(__tstate);
28618 if (PyErr_Occurred()) SWIG_fail;
28619 }
28620 {
28621 #if wxUSE_UNICODE
28622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28623 #else
28624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28625 #endif
28626 }
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28634 PyObject *obj;
28635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28636 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28637 return SWIG_Py_Void();
28638 }
28639
28640 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28641 return SWIG_Python_InitShadowInstance(args);
28642 }
28643
28644 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28645 PyObject *resultobj = 0;
28646 long arg1 ;
28647 wxTimeSpan result;
28648 long val1 ;
28649 int ecode1 = 0 ;
28650 PyObject * obj0 = 0 ;
28651 char * kwnames[] = {
28652 (char *) "ms", NULL
28653 };
28654
28655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28656 ecode1 = SWIG_AsVal_long(obj0, &val1);
28657 if (!SWIG_IsOK(ecode1)) {
28658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28659 }
28660 arg1 = static_cast< long >(val1);
28661 {
28662 PyThreadState* __tstate = wxPyBeginAllowThreads();
28663 result = wxTimeSpan::Milliseconds(arg1);
28664 wxPyEndAllowThreads(__tstate);
28665 if (PyErr_Occurred()) SWIG_fail;
28666 }
28667 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28675 PyObject *resultobj = 0;
28676 wxTimeSpan result;
28677
28678 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = wxTimeSpan::Millisecond();
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28693 PyObject *resultobj = 0;
28694 long arg1 ;
28695 wxTimeSpan result;
28696 long val1 ;
28697 int ecode1 = 0 ;
28698 PyObject * obj0 = 0 ;
28699 char * kwnames[] = {
28700 (char *) "sec", NULL
28701 };
28702
28703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28704 ecode1 = SWIG_AsVal_long(obj0, &val1);
28705 if (!SWIG_IsOK(ecode1)) {
28706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28707 }
28708 arg1 = static_cast< long >(val1);
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 result = wxTimeSpan::Seconds(arg1);
28712 wxPyEndAllowThreads(__tstate);
28713 if (PyErr_Occurred()) SWIG_fail;
28714 }
28715 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28716 return resultobj;
28717 fail:
28718 return NULL;
28719 }
28720
28721
28722 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28723 PyObject *resultobj = 0;
28724 wxTimeSpan result;
28725
28726 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = wxTimeSpan::Second();
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28741 PyObject *resultobj = 0;
28742 long arg1 ;
28743 wxTimeSpan result;
28744 long val1 ;
28745 int ecode1 = 0 ;
28746 PyObject * obj0 = 0 ;
28747 char * kwnames[] = {
28748 (char *) "min", NULL
28749 };
28750
28751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28752 ecode1 = SWIG_AsVal_long(obj0, &val1);
28753 if (!SWIG_IsOK(ecode1)) {
28754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28755 }
28756 arg1 = static_cast< long >(val1);
28757 {
28758 PyThreadState* __tstate = wxPyBeginAllowThreads();
28759 result = wxTimeSpan::Minutes(arg1);
28760 wxPyEndAllowThreads(__tstate);
28761 if (PyErr_Occurred()) SWIG_fail;
28762 }
28763 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28764 return resultobj;
28765 fail:
28766 return NULL;
28767 }
28768
28769
28770 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28771 PyObject *resultobj = 0;
28772 wxTimeSpan result;
28773
28774 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = wxTimeSpan::Minute();
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28782 return resultobj;
28783 fail:
28784 return NULL;
28785 }
28786
28787
28788 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28789 PyObject *resultobj = 0;
28790 long arg1 ;
28791 wxTimeSpan result;
28792 long val1 ;
28793 int ecode1 = 0 ;
28794 PyObject * obj0 = 0 ;
28795 char * kwnames[] = {
28796 (char *) "hours", NULL
28797 };
28798
28799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28800 ecode1 = SWIG_AsVal_long(obj0, &val1);
28801 if (!SWIG_IsOK(ecode1)) {
28802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28803 }
28804 arg1 = static_cast< long >(val1);
28805 {
28806 PyThreadState* __tstate = wxPyBeginAllowThreads();
28807 result = wxTimeSpan::Hours(arg1);
28808 wxPyEndAllowThreads(__tstate);
28809 if (PyErr_Occurred()) SWIG_fail;
28810 }
28811 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28812 return resultobj;
28813 fail:
28814 return NULL;
28815 }
28816
28817
28818 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28819 PyObject *resultobj = 0;
28820 wxTimeSpan result;
28821
28822 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = wxTimeSpan::Hour();
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28837 PyObject *resultobj = 0;
28838 long arg1 ;
28839 wxTimeSpan result;
28840 long val1 ;
28841 int ecode1 = 0 ;
28842 PyObject * obj0 = 0 ;
28843 char * kwnames[] = {
28844 (char *) "days", NULL
28845 };
28846
28847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28848 ecode1 = SWIG_AsVal_long(obj0, &val1);
28849 if (!SWIG_IsOK(ecode1)) {
28850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28851 }
28852 arg1 = static_cast< long >(val1);
28853 {
28854 PyThreadState* __tstate = wxPyBeginAllowThreads();
28855 result = wxTimeSpan::Days(arg1);
28856 wxPyEndAllowThreads(__tstate);
28857 if (PyErr_Occurred()) SWIG_fail;
28858 }
28859 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28860 return resultobj;
28861 fail:
28862 return NULL;
28863 }
28864
28865
28866 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28867 PyObject *resultobj = 0;
28868 wxTimeSpan result;
28869
28870 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = wxTimeSpan::Day();
28874 wxPyEndAllowThreads(__tstate);
28875 if (PyErr_Occurred()) SWIG_fail;
28876 }
28877 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28878 return resultobj;
28879 fail:
28880 return NULL;
28881 }
28882
28883
28884 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28885 PyObject *resultobj = 0;
28886 long arg1 ;
28887 wxTimeSpan result;
28888 long val1 ;
28889 int ecode1 = 0 ;
28890 PyObject * obj0 = 0 ;
28891 char * kwnames[] = {
28892 (char *) "days", NULL
28893 };
28894
28895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28896 ecode1 = SWIG_AsVal_long(obj0, &val1);
28897 if (!SWIG_IsOK(ecode1)) {
28898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28899 }
28900 arg1 = static_cast< long >(val1);
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 result = wxTimeSpan::Weeks(arg1);
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28908 return resultobj;
28909 fail:
28910 return NULL;
28911 }
28912
28913
28914 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28915 PyObject *resultobj = 0;
28916 wxTimeSpan result;
28917
28918 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28919 {
28920 PyThreadState* __tstate = wxPyBeginAllowThreads();
28921 result = wxTimeSpan::Week();
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28933 PyObject *resultobj = 0;
28934 long arg1 = (long) 0 ;
28935 long arg2 = (long) 0 ;
28936 long arg3 = (long) 0 ;
28937 long arg4 = (long) 0 ;
28938 wxTimeSpan *result = 0 ;
28939 long val1 ;
28940 int ecode1 = 0 ;
28941 long val2 ;
28942 int ecode2 = 0 ;
28943 long val3 ;
28944 int ecode3 = 0 ;
28945 long val4 ;
28946 int ecode4 = 0 ;
28947 PyObject * obj0 = 0 ;
28948 PyObject * obj1 = 0 ;
28949 PyObject * obj2 = 0 ;
28950 PyObject * obj3 = 0 ;
28951 char * kwnames[] = {
28952 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28953 };
28954
28955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28956 if (obj0) {
28957 ecode1 = SWIG_AsVal_long(obj0, &val1);
28958 if (!SWIG_IsOK(ecode1)) {
28959 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28960 }
28961 arg1 = static_cast< long >(val1);
28962 }
28963 if (obj1) {
28964 ecode2 = SWIG_AsVal_long(obj1, &val2);
28965 if (!SWIG_IsOK(ecode2)) {
28966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28967 }
28968 arg2 = static_cast< long >(val2);
28969 }
28970 if (obj2) {
28971 ecode3 = SWIG_AsVal_long(obj2, &val3);
28972 if (!SWIG_IsOK(ecode3)) {
28973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28974 }
28975 arg3 = static_cast< long >(val3);
28976 }
28977 if (obj3) {
28978 ecode4 = SWIG_AsVal_long(obj3, &val4);
28979 if (!SWIG_IsOK(ecode4)) {
28980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28981 }
28982 arg4 = static_cast< long >(val4);
28983 }
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29000 void *argp1 = 0 ;
29001 int res1 = 0 ;
29002 PyObject *swig_obj[1] ;
29003
29004 if (!args) SWIG_fail;
29005 swig_obj[0] = args;
29006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29007 if (!SWIG_IsOK(res1)) {
29008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29009 }
29010 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29011 {
29012 PyThreadState* __tstate = wxPyBeginAllowThreads();
29013 delete arg1;
29014
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 resultobj = SWIG_Py_Void();
29019 return resultobj;
29020 fail:
29021 return NULL;
29022 }
29023
29024
29025 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29026 PyObject *resultobj = 0;
29027 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29028 wxTimeSpan *arg2 = 0 ;
29029 wxTimeSpan *result = 0 ;
29030 void *argp1 = 0 ;
29031 int res1 = 0 ;
29032 void *argp2 = 0 ;
29033 int res2 = 0 ;
29034 PyObject * obj0 = 0 ;
29035 PyObject * obj1 = 0 ;
29036 char * kwnames[] = {
29037 (char *) "self",(char *) "diff", NULL
29038 };
29039
29040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29042 if (!SWIG_IsOK(res1)) {
29043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29044 }
29045 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29046 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29047 if (!SWIG_IsOK(res2)) {
29048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29049 }
29050 if (!argp2) {
29051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29052 }
29053 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 {
29057 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29058 result = (wxTimeSpan *) &_result_ref;
29059 }
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29071 PyObject *resultobj = 0;
29072 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29073 wxTimeSpan *arg2 = 0 ;
29074 wxTimeSpan *result = 0 ;
29075 void *argp1 = 0 ;
29076 int res1 = 0 ;
29077 void *argp2 = 0 ;
29078 int res2 = 0 ;
29079 PyObject * obj0 = 0 ;
29080 PyObject * obj1 = 0 ;
29081 char * kwnames[] = {
29082 (char *) "self",(char *) "diff", NULL
29083 };
29084
29085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29087 if (!SWIG_IsOK(res1)) {
29088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29089 }
29090 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29091 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29092 if (!SWIG_IsOK(res2)) {
29093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29094 }
29095 if (!argp2) {
29096 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29097 }
29098 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 {
29102 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29103 result = (wxTimeSpan *) &_result_ref;
29104 }
29105 wxPyEndAllowThreads(__tstate);
29106 if (PyErr_Occurred()) SWIG_fail;
29107 }
29108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29109 return resultobj;
29110 fail:
29111 return NULL;
29112 }
29113
29114
29115 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29116 PyObject *resultobj = 0;
29117 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29118 int arg2 ;
29119 wxTimeSpan *result = 0 ;
29120 void *argp1 = 0 ;
29121 int res1 = 0 ;
29122 int val2 ;
29123 int ecode2 = 0 ;
29124 PyObject * obj0 = 0 ;
29125 PyObject * obj1 = 0 ;
29126 char * kwnames[] = {
29127 (char *) "self",(char *) "n", NULL
29128 };
29129
29130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29132 if (!SWIG_IsOK(res1)) {
29133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29134 }
29135 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29136 ecode2 = SWIG_AsVal_int(obj1, &val2);
29137 if (!SWIG_IsOK(ecode2)) {
29138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29139 }
29140 arg2 = static_cast< int >(val2);
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 {
29144 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29145 result = (wxTimeSpan *) &_result_ref;
29146 }
29147 wxPyEndAllowThreads(__tstate);
29148 if (PyErr_Occurred()) SWIG_fail;
29149 }
29150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29151 return resultobj;
29152 fail:
29153 return NULL;
29154 }
29155
29156
29157 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29158 PyObject *resultobj = 0;
29159 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29160 wxTimeSpan *result = 0 ;
29161 void *argp1 = 0 ;
29162 int res1 = 0 ;
29163 PyObject *swig_obj[1] ;
29164
29165 if (!args) SWIG_fail;
29166 swig_obj[0] = args;
29167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29168 if (!SWIG_IsOK(res1)) {
29169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29170 }
29171 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 {
29175 wxTimeSpan &_result_ref = (arg1)->Neg();
29176 result = (wxTimeSpan *) &_result_ref;
29177 }
29178 wxPyEndAllowThreads(__tstate);
29179 if (PyErr_Occurred()) SWIG_fail;
29180 }
29181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29182 return resultobj;
29183 fail:
29184 return NULL;
29185 }
29186
29187
29188 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29189 PyObject *resultobj = 0;
29190 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29191 wxTimeSpan result;
29192 void *argp1 = 0 ;
29193 int res1 = 0 ;
29194 PyObject *swig_obj[1] ;
29195
29196 if (!args) SWIG_fail;
29197 swig_obj[0] = args;
29198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29199 if (!SWIG_IsOK(res1)) {
29200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29201 }
29202 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29203 {
29204 PyThreadState* __tstate = wxPyBeginAllowThreads();
29205 result = ((wxTimeSpan const *)arg1)->Abs();
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj = 0;
29218 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29219 wxTimeSpan *arg2 = 0 ;
29220 wxTimeSpan *result = 0 ;
29221 void *argp1 = 0 ;
29222 int res1 = 0 ;
29223 void *argp2 = 0 ;
29224 int res2 = 0 ;
29225 PyObject * obj0 = 0 ;
29226 PyObject * obj1 = 0 ;
29227 char * kwnames[] = {
29228 (char *) "self",(char *) "diff", NULL
29229 };
29230
29231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29233 if (!SWIG_IsOK(res1)) {
29234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29235 }
29236 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29237 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29238 if (!SWIG_IsOK(res2)) {
29239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29240 }
29241 if (!argp2) {
29242 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29243 }
29244 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 {
29248 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29249 result = (wxTimeSpan *) &_result_ref;
29250 }
29251 wxPyEndAllowThreads(__tstate);
29252 if (PyErr_Occurred()) SWIG_fail;
29253 }
29254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29262 PyObject *resultobj = 0;
29263 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29264 wxTimeSpan *arg2 = 0 ;
29265 wxTimeSpan *result = 0 ;
29266 void *argp1 = 0 ;
29267 int res1 = 0 ;
29268 void *argp2 = 0 ;
29269 int res2 = 0 ;
29270 PyObject * obj0 = 0 ;
29271 PyObject * obj1 = 0 ;
29272 char * kwnames[] = {
29273 (char *) "self",(char *) "diff", NULL
29274 };
29275
29276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29278 if (!SWIG_IsOK(res1)) {
29279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29280 }
29281 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29282 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29283 if (!SWIG_IsOK(res2)) {
29284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29285 }
29286 if (!argp2) {
29287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29288 }
29289 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29290 {
29291 PyThreadState* __tstate = wxPyBeginAllowThreads();
29292 {
29293 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29294 result = (wxTimeSpan *) &_result_ref;
29295 }
29296 wxPyEndAllowThreads(__tstate);
29297 if (PyErr_Occurred()) SWIG_fail;
29298 }
29299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29300 return resultobj;
29301 fail:
29302 return NULL;
29303 }
29304
29305
29306 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29307 PyObject *resultobj = 0;
29308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29309 int arg2 ;
29310 wxTimeSpan *result = 0 ;
29311 void *argp1 = 0 ;
29312 int res1 = 0 ;
29313 int val2 ;
29314 int ecode2 = 0 ;
29315 PyObject * obj0 = 0 ;
29316 PyObject * obj1 = 0 ;
29317 char * kwnames[] = {
29318 (char *) "self",(char *) "n", NULL
29319 };
29320
29321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29323 if (!SWIG_IsOK(res1)) {
29324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29325 }
29326 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29327 ecode2 = SWIG_AsVal_int(obj1, &val2);
29328 if (!SWIG_IsOK(ecode2)) {
29329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29330 }
29331 arg2 = static_cast< int >(val2);
29332 {
29333 PyThreadState* __tstate = wxPyBeginAllowThreads();
29334 {
29335 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29336 result = (wxTimeSpan *) &_result_ref;
29337 }
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29342 return resultobj;
29343 fail:
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 PyObject *resultobj = 0;
29350 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29351 wxTimeSpan *result = 0 ;
29352 void *argp1 = 0 ;
29353 int res1 = 0 ;
29354 PyObject *swig_obj[1] ;
29355
29356 if (!args) SWIG_fail;
29357 swig_obj[0] = args;
29358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29359 if (!SWIG_IsOK(res1)) {
29360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29361 }
29362 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29363 {
29364 PyThreadState* __tstate = wxPyBeginAllowThreads();
29365 {
29366 wxTimeSpan &_result_ref = (arg1)->operator -();
29367 result = (wxTimeSpan *) &_result_ref;
29368 }
29369 wxPyEndAllowThreads(__tstate);
29370 if (PyErr_Occurred()) SWIG_fail;
29371 }
29372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29373 return resultobj;
29374 fail:
29375 return NULL;
29376 }
29377
29378
29379 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29380 PyObject *resultobj = 0;
29381 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29382 wxTimeSpan *arg2 = 0 ;
29383 wxTimeSpan result;
29384 void *argp1 = 0 ;
29385 int res1 = 0 ;
29386 void *argp2 = 0 ;
29387 int res2 = 0 ;
29388 PyObject * obj0 = 0 ;
29389 PyObject * obj1 = 0 ;
29390 char * kwnames[] = {
29391 (char *) "self",(char *) "other", NULL
29392 };
29393
29394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29396 if (!SWIG_IsOK(res1)) {
29397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29398 }
29399 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29400 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29401 if (!SWIG_IsOK(res2)) {
29402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29403 }
29404 if (!argp2) {
29405 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29406 }
29407 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29408 {
29409 PyThreadState* __tstate = wxPyBeginAllowThreads();
29410 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29411 wxPyEndAllowThreads(__tstate);
29412 if (PyErr_Occurred()) SWIG_fail;
29413 }
29414 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29415 return resultobj;
29416 fail:
29417 return NULL;
29418 }
29419
29420
29421 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29422 PyObject *resultobj = 0;
29423 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29424 wxTimeSpan *arg2 = 0 ;
29425 wxTimeSpan result;
29426 void *argp1 = 0 ;
29427 int res1 = 0 ;
29428 void *argp2 = 0 ;
29429 int res2 = 0 ;
29430 PyObject * obj0 = 0 ;
29431 PyObject * obj1 = 0 ;
29432 char * kwnames[] = {
29433 (char *) "self",(char *) "other", NULL
29434 };
29435
29436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29438 if (!SWIG_IsOK(res1)) {
29439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29440 }
29441 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29442 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29443 if (!SWIG_IsOK(res2)) {
29444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29445 }
29446 if (!argp2) {
29447 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29448 }
29449 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29450 {
29451 PyThreadState* __tstate = wxPyBeginAllowThreads();
29452 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29453 wxPyEndAllowThreads(__tstate);
29454 if (PyErr_Occurred()) SWIG_fail;
29455 }
29456 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29457 return resultobj;
29458 fail:
29459 return NULL;
29460 }
29461
29462
29463 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29464 PyObject *resultobj = 0;
29465 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29466 int arg2 ;
29467 wxTimeSpan result;
29468 void *argp1 = 0 ;
29469 int res1 = 0 ;
29470 int val2 ;
29471 int ecode2 = 0 ;
29472 PyObject * obj0 = 0 ;
29473 PyObject * obj1 = 0 ;
29474 char * kwnames[] = {
29475 (char *) "self",(char *) "n", NULL
29476 };
29477
29478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29480 if (!SWIG_IsOK(res1)) {
29481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29482 }
29483 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29484 ecode2 = SWIG_AsVal_int(obj1, &val2);
29485 if (!SWIG_IsOK(ecode2)) {
29486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29487 }
29488 arg2 = static_cast< int >(val2);
29489 {
29490 PyThreadState* __tstate = wxPyBeginAllowThreads();
29491 result = wxTimeSpan___mul__(arg1,arg2);
29492 wxPyEndAllowThreads(__tstate);
29493 if (PyErr_Occurred()) SWIG_fail;
29494 }
29495 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29496 return resultobj;
29497 fail:
29498 return NULL;
29499 }
29500
29501
29502 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29503 PyObject *resultobj = 0;
29504 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29505 int arg2 ;
29506 wxTimeSpan result;
29507 void *argp1 = 0 ;
29508 int res1 = 0 ;
29509 int val2 ;
29510 int ecode2 = 0 ;
29511 PyObject * obj0 = 0 ;
29512 PyObject * obj1 = 0 ;
29513 char * kwnames[] = {
29514 (char *) "self",(char *) "n", NULL
29515 };
29516
29517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29519 if (!SWIG_IsOK(res1)) {
29520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29521 }
29522 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29523 ecode2 = SWIG_AsVal_int(obj1, &val2);
29524 if (!SWIG_IsOK(ecode2)) {
29525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29526 }
29527 arg2 = static_cast< int >(val2);
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 result = wxTimeSpan___rmul__(arg1,arg2);
29531 wxPyEndAllowThreads(__tstate);
29532 if (PyErr_Occurred()) SWIG_fail;
29533 }
29534 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29535 return resultobj;
29536 fail:
29537 return NULL;
29538 }
29539
29540
29541 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29542 PyObject *resultobj = 0;
29543 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29544 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29545 bool result;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 void *argp2 = 0 ;
29549 int res2 = 0 ;
29550 PyObject * obj0 = 0 ;
29551 PyObject * obj1 = 0 ;
29552 char * kwnames[] = {
29553 (char *) "self",(char *) "other", NULL
29554 };
29555
29556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29558 if (!SWIG_IsOK(res1)) {
29559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29560 }
29561 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29562 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29563 if (!SWIG_IsOK(res2)) {
29564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29565 }
29566 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29567 {
29568 PyThreadState* __tstate = wxPyBeginAllowThreads();
29569 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29570 wxPyEndAllowThreads(__tstate);
29571 if (PyErr_Occurred()) SWIG_fail;
29572 }
29573 {
29574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29575 }
29576 return resultobj;
29577 fail:
29578 return NULL;
29579 }
29580
29581
29582 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29583 PyObject *resultobj = 0;
29584 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29585 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29586 bool result;
29587 void *argp1 = 0 ;
29588 int res1 = 0 ;
29589 void *argp2 = 0 ;
29590 int res2 = 0 ;
29591 PyObject * obj0 = 0 ;
29592 PyObject * obj1 = 0 ;
29593 char * kwnames[] = {
29594 (char *) "self",(char *) "other", NULL
29595 };
29596
29597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29599 if (!SWIG_IsOK(res1)) {
29600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29601 }
29602 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29604 if (!SWIG_IsOK(res2)) {
29605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29606 }
29607 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29608 {
29609 PyThreadState* __tstate = wxPyBeginAllowThreads();
29610 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 {
29615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29616 }
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj = 0;
29625 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29626 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29627 bool result;
29628 void *argp1 = 0 ;
29629 int res1 = 0 ;
29630 void *argp2 = 0 ;
29631 int res2 = 0 ;
29632 PyObject * obj0 = 0 ;
29633 PyObject * obj1 = 0 ;
29634 char * kwnames[] = {
29635 (char *) "self",(char *) "other", NULL
29636 };
29637
29638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29640 if (!SWIG_IsOK(res1)) {
29641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29642 }
29643 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29645 if (!SWIG_IsOK(res2)) {
29646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29647 }
29648 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 {
29656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj = 0;
29666 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29667 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29668 bool result;
29669 void *argp1 = 0 ;
29670 int res1 = 0 ;
29671 void *argp2 = 0 ;
29672 int res2 = 0 ;
29673 PyObject * obj0 = 0 ;
29674 PyObject * obj1 = 0 ;
29675 char * kwnames[] = {
29676 (char *) "self",(char *) "other", NULL
29677 };
29678
29679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29681 if (!SWIG_IsOK(res1)) {
29682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29683 }
29684 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29686 if (!SWIG_IsOK(res2)) {
29687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29688 }
29689 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29690 {
29691 PyThreadState* __tstate = wxPyBeginAllowThreads();
29692 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 {
29697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29698 }
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29706 PyObject *resultobj = 0;
29707 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29708 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29709 bool result;
29710 void *argp1 = 0 ;
29711 int res1 = 0 ;
29712 void *argp2 = 0 ;
29713 int res2 = 0 ;
29714 PyObject * obj0 = 0 ;
29715 PyObject * obj1 = 0 ;
29716 char * kwnames[] = {
29717 (char *) "self",(char *) "other", NULL
29718 };
29719
29720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29722 if (!SWIG_IsOK(res1)) {
29723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29724 }
29725 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29727 if (!SWIG_IsOK(res2)) {
29728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29729 }
29730 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29731 {
29732 PyThreadState* __tstate = wxPyBeginAllowThreads();
29733 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29734 wxPyEndAllowThreads(__tstate);
29735 if (PyErr_Occurred()) SWIG_fail;
29736 }
29737 {
29738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29739 }
29740 return resultobj;
29741 fail:
29742 return NULL;
29743 }
29744
29745
29746 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29747 PyObject *resultobj = 0;
29748 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29749 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29750 bool result;
29751 void *argp1 = 0 ;
29752 int res1 = 0 ;
29753 void *argp2 = 0 ;
29754 int res2 = 0 ;
29755 PyObject * obj0 = 0 ;
29756 PyObject * obj1 = 0 ;
29757 char * kwnames[] = {
29758 (char *) "self",(char *) "other", NULL
29759 };
29760
29761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29763 if (!SWIG_IsOK(res1)) {
29764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29765 }
29766 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29768 if (!SWIG_IsOK(res2)) {
29769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29770 }
29771 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 {
29779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29780 }
29781 return resultobj;
29782 fail:
29783 return NULL;
29784 }
29785
29786
29787 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29788 PyObject *resultobj = 0;
29789 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29790 bool result;
29791 void *argp1 = 0 ;
29792 int res1 = 0 ;
29793 PyObject *swig_obj[1] ;
29794
29795 if (!args) SWIG_fail;
29796 swig_obj[0] = args;
29797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29798 if (!SWIG_IsOK(res1)) {
29799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29800 }
29801 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 {
29809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29810 }
29811 return resultobj;
29812 fail:
29813 return NULL;
29814 }
29815
29816
29817 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29818 PyObject *resultobj = 0;
29819 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29820 bool result;
29821 void *argp1 = 0 ;
29822 int res1 = 0 ;
29823 PyObject *swig_obj[1] ;
29824
29825 if (!args) SWIG_fail;
29826 swig_obj[0] = args;
29827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29828 if (!SWIG_IsOK(res1)) {
29829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29830 }
29831 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29832 {
29833 PyThreadState* __tstate = wxPyBeginAllowThreads();
29834 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29835 wxPyEndAllowThreads(__tstate);
29836 if (PyErr_Occurred()) SWIG_fail;
29837 }
29838 {
29839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29840 }
29841 return resultobj;
29842 fail:
29843 return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29848 PyObject *resultobj = 0;
29849 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29850 bool result;
29851 void *argp1 = 0 ;
29852 int res1 = 0 ;
29853 PyObject *swig_obj[1] ;
29854
29855 if (!args) SWIG_fail;
29856 swig_obj[0] = args;
29857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29858 if (!SWIG_IsOK(res1)) {
29859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29860 }
29861 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29862 {
29863 PyThreadState* __tstate = wxPyBeginAllowThreads();
29864 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 {
29869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29870 }
29871 return resultobj;
29872 fail:
29873 return NULL;
29874 }
29875
29876
29877 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29878 PyObject *resultobj = 0;
29879 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29880 wxTimeSpan *arg2 = 0 ;
29881 bool result;
29882 void *argp1 = 0 ;
29883 int res1 = 0 ;
29884 void *argp2 = 0 ;
29885 int res2 = 0 ;
29886 PyObject * obj0 = 0 ;
29887 PyObject * obj1 = 0 ;
29888 char * kwnames[] = {
29889 (char *) "self",(char *) "ts", NULL
29890 };
29891
29892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29894 if (!SWIG_IsOK(res1)) {
29895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29896 }
29897 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29899 if (!SWIG_IsOK(res2)) {
29900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29901 }
29902 if (!argp2) {
29903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29904 }
29905 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 {
29913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29914 }
29915 return resultobj;
29916 fail:
29917 return NULL;
29918 }
29919
29920
29921 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29922 PyObject *resultobj = 0;
29923 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29924 wxTimeSpan *arg2 = 0 ;
29925 bool result;
29926 void *argp1 = 0 ;
29927 int res1 = 0 ;
29928 void *argp2 = 0 ;
29929 int res2 = 0 ;
29930 PyObject * obj0 = 0 ;
29931 PyObject * obj1 = 0 ;
29932 char * kwnames[] = {
29933 (char *) "self",(char *) "ts", NULL
29934 };
29935
29936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29938 if (!SWIG_IsOK(res1)) {
29939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29940 }
29941 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29943 if (!SWIG_IsOK(res2)) {
29944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29945 }
29946 if (!argp2) {
29947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29948 }
29949 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29950 {
29951 PyThreadState* __tstate = wxPyBeginAllowThreads();
29952 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29953 wxPyEndAllowThreads(__tstate);
29954 if (PyErr_Occurred()) SWIG_fail;
29955 }
29956 {
29957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29958 }
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29966 PyObject *resultobj = 0;
29967 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29968 wxTimeSpan *arg2 = 0 ;
29969 bool result;
29970 void *argp1 = 0 ;
29971 int res1 = 0 ;
29972 void *argp2 = 0 ;
29973 int res2 = 0 ;
29974 PyObject * obj0 = 0 ;
29975 PyObject * obj1 = 0 ;
29976 char * kwnames[] = {
29977 (char *) "self",(char *) "t", NULL
29978 };
29979
29980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29982 if (!SWIG_IsOK(res1)) {
29983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29984 }
29985 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29987 if (!SWIG_IsOK(res2)) {
29988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29989 }
29990 if (!argp2) {
29991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29992 }
29993 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29994 {
29995 PyThreadState* __tstate = wxPyBeginAllowThreads();
29996 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29997 wxPyEndAllowThreads(__tstate);
29998 if (PyErr_Occurred()) SWIG_fail;
29999 }
30000 {
30001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30002 }
30003 return resultobj;
30004 fail:
30005 return NULL;
30006 }
30007
30008
30009 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30010 PyObject *resultobj = 0;
30011 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30012 int result;
30013 void *argp1 = 0 ;
30014 int res1 = 0 ;
30015 PyObject *swig_obj[1] ;
30016
30017 if (!args) SWIG_fail;
30018 swig_obj[0] = args;
30019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30020 if (!SWIG_IsOK(res1)) {
30021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30022 }
30023 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30024 {
30025 PyThreadState* __tstate = wxPyBeginAllowThreads();
30026 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30027 wxPyEndAllowThreads(__tstate);
30028 if (PyErr_Occurred()) SWIG_fail;
30029 }
30030 resultobj = SWIG_From_int(static_cast< int >(result));
30031 return resultobj;
30032 fail:
30033 return NULL;
30034 }
30035
30036
30037 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30038 PyObject *resultobj = 0;
30039 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30040 int result;
30041 void *argp1 = 0 ;
30042 int res1 = 0 ;
30043 PyObject *swig_obj[1] ;
30044
30045 if (!args) SWIG_fail;
30046 swig_obj[0] = args;
30047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30048 if (!SWIG_IsOK(res1)) {
30049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30050 }
30051 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30052 {
30053 PyThreadState* __tstate = wxPyBeginAllowThreads();
30054 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30055 wxPyEndAllowThreads(__tstate);
30056 if (PyErr_Occurred()) SWIG_fail;
30057 }
30058 resultobj = SWIG_From_int(static_cast< int >(result));
30059 return resultobj;
30060 fail:
30061 return NULL;
30062 }
30063
30064
30065 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30066 PyObject *resultobj = 0;
30067 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30068 int result;
30069 void *argp1 = 0 ;
30070 int res1 = 0 ;
30071 PyObject *swig_obj[1] ;
30072
30073 if (!args) SWIG_fail;
30074 swig_obj[0] = args;
30075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30076 if (!SWIG_IsOK(res1)) {
30077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30078 }
30079 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30080 {
30081 PyThreadState* __tstate = wxPyBeginAllowThreads();
30082 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30083 wxPyEndAllowThreads(__tstate);
30084 if (PyErr_Occurred()) SWIG_fail;
30085 }
30086 resultobj = SWIG_From_int(static_cast< int >(result));
30087 return resultobj;
30088 fail:
30089 return NULL;
30090 }
30091
30092
30093 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30094 PyObject *resultobj = 0;
30095 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30096 int result;
30097 void *argp1 = 0 ;
30098 int res1 = 0 ;
30099 PyObject *swig_obj[1] ;
30100
30101 if (!args) SWIG_fail;
30102 swig_obj[0] = args;
30103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30104 if (!SWIG_IsOK(res1)) {
30105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30106 }
30107 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30108 {
30109 PyThreadState* __tstate = wxPyBeginAllowThreads();
30110 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 resultobj = SWIG_From_int(static_cast< int >(result));
30115 return resultobj;
30116 fail:
30117 return NULL;
30118 }
30119
30120
30121 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30122 PyObject *resultobj = 0;
30123 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30124 wxLongLong result;
30125 void *argp1 = 0 ;
30126 int res1 = 0 ;
30127 PyObject *swig_obj[1] ;
30128
30129 if (!args) SWIG_fail;
30130 swig_obj[0] = args;
30131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30132 if (!SWIG_IsOK(res1)) {
30133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30134 }
30135 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30139 wxPyEndAllowThreads(__tstate);
30140 if (PyErr_Occurred()) SWIG_fail;
30141 }
30142 {
30143 PyObject *hi, *lo, *shifter, *shifted;
30144 hi = PyLong_FromLong( (&result)->GetHi() );
30145 lo = PyLong_FromLong( (&result)->GetLo() );
30146 shifter = PyLong_FromLong(32);
30147 shifted = PyNumber_Lshift(hi, shifter);
30148 resultobj = PyNumber_Or(shifted, lo);
30149 Py_DECREF(hi);
30150 Py_DECREF(lo);
30151 Py_DECREF(shifter);
30152 Py_DECREF(shifted);
30153 }
30154 return resultobj;
30155 fail:
30156 return NULL;
30157 }
30158
30159
30160 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30161 PyObject *resultobj = 0;
30162 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30163 wxLongLong result;
30164 void *argp1 = 0 ;
30165 int res1 = 0 ;
30166 PyObject *swig_obj[1] ;
30167
30168 if (!args) SWIG_fail;
30169 swig_obj[0] = args;
30170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30171 if (!SWIG_IsOK(res1)) {
30172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30173 }
30174 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30178 wxPyEndAllowThreads(__tstate);
30179 if (PyErr_Occurred()) SWIG_fail;
30180 }
30181 {
30182 PyObject *hi, *lo, *shifter, *shifted;
30183 hi = PyLong_FromLong( (&result)->GetHi() );
30184 lo = PyLong_FromLong( (&result)->GetLo() );
30185 shifter = PyLong_FromLong(32);
30186 shifted = PyNumber_Lshift(hi, shifter);
30187 resultobj = PyNumber_Or(shifted, lo);
30188 Py_DECREF(hi);
30189 Py_DECREF(lo);
30190 Py_DECREF(shifter);
30191 Py_DECREF(shifted);
30192 }
30193 return resultobj;
30194 fail:
30195 return NULL;
30196 }
30197
30198
30199 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30200 PyObject *resultobj = 0;
30201 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30202 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30203 wxString *arg2 = (wxString *) &arg2_defvalue ;
30204 wxString result;
30205 void *argp1 = 0 ;
30206 int res1 = 0 ;
30207 bool temp2 = false ;
30208 PyObject * obj0 = 0 ;
30209 PyObject * obj1 = 0 ;
30210 char * kwnames[] = {
30211 (char *) "self",(char *) "format", NULL
30212 };
30213
30214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30216 if (!SWIG_IsOK(res1)) {
30217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30218 }
30219 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30220 if (obj1) {
30221 {
30222 arg2 = wxString_in_helper(obj1);
30223 if (arg2 == NULL) SWIG_fail;
30224 temp2 = true;
30225 }
30226 }
30227 {
30228 PyThreadState* __tstate = wxPyBeginAllowThreads();
30229 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 {
30234 #if wxUSE_UNICODE
30235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30236 #else
30237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30238 #endif
30239 }
30240 {
30241 if (temp2)
30242 delete arg2;
30243 }
30244 return resultobj;
30245 fail:
30246 {
30247 if (temp2)
30248 delete arg2;
30249 }
30250 return NULL;
30251 }
30252
30253
30254 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30255 PyObject *obj;
30256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30257 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30258 return SWIG_Py_Void();
30259 }
30260
30261 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30262 return SWIG_Python_InitShadowInstance(args);
30263 }
30264
30265 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30266 PyObject *resultobj = 0;
30267 int arg1 = (int) 0 ;
30268 int arg2 = (int) 0 ;
30269 int arg3 = (int) 0 ;
30270 int arg4 = (int) 0 ;
30271 wxDateSpan *result = 0 ;
30272 int val1 ;
30273 int ecode1 = 0 ;
30274 int val2 ;
30275 int ecode2 = 0 ;
30276 int val3 ;
30277 int ecode3 = 0 ;
30278 int val4 ;
30279 int ecode4 = 0 ;
30280 PyObject * obj0 = 0 ;
30281 PyObject * obj1 = 0 ;
30282 PyObject * obj2 = 0 ;
30283 PyObject * obj3 = 0 ;
30284 char * kwnames[] = {
30285 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30286 };
30287
30288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30289 if (obj0) {
30290 ecode1 = SWIG_AsVal_int(obj0, &val1);
30291 if (!SWIG_IsOK(ecode1)) {
30292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30293 }
30294 arg1 = static_cast< int >(val1);
30295 }
30296 if (obj1) {
30297 ecode2 = SWIG_AsVal_int(obj1, &val2);
30298 if (!SWIG_IsOK(ecode2)) {
30299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30300 }
30301 arg2 = static_cast< int >(val2);
30302 }
30303 if (obj2) {
30304 ecode3 = SWIG_AsVal_int(obj2, &val3);
30305 if (!SWIG_IsOK(ecode3)) {
30306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30307 }
30308 arg3 = static_cast< int >(val3);
30309 }
30310 if (obj3) {
30311 ecode4 = SWIG_AsVal_int(obj3, &val4);
30312 if (!SWIG_IsOK(ecode4)) {
30313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30314 }
30315 arg4 = static_cast< int >(val4);
30316 }
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30331 PyObject *resultobj = 0;
30332 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30333 void *argp1 = 0 ;
30334 int res1 = 0 ;
30335 PyObject *swig_obj[1] ;
30336
30337 if (!args) SWIG_fail;
30338 swig_obj[0] = args;
30339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30340 if (!SWIG_IsOK(res1)) {
30341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30342 }
30343 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30344 {
30345 PyThreadState* __tstate = wxPyBeginAllowThreads();
30346 delete arg1;
30347
30348 wxPyEndAllowThreads(__tstate);
30349 if (PyErr_Occurred()) SWIG_fail;
30350 }
30351 resultobj = SWIG_Py_Void();
30352 return resultobj;
30353 fail:
30354 return NULL;
30355 }
30356
30357
30358 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30359 PyObject *resultobj = 0;
30360 int arg1 ;
30361 wxDateSpan result;
30362 int val1 ;
30363 int ecode1 = 0 ;
30364 PyObject * obj0 = 0 ;
30365 char * kwnames[] = {
30366 (char *) "days", NULL
30367 };
30368
30369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30370 ecode1 = SWIG_AsVal_int(obj0, &val1);
30371 if (!SWIG_IsOK(ecode1)) {
30372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30373 }
30374 arg1 = static_cast< int >(val1);
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 result = wxDateSpan::Days(arg1);
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30382 return resultobj;
30383 fail:
30384 return NULL;
30385 }
30386
30387
30388 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30389 PyObject *resultobj = 0;
30390 wxDateSpan result;
30391
30392 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30393 {
30394 PyThreadState* __tstate = wxPyBeginAllowThreads();
30395 result = wxDateSpan::Day();
30396 wxPyEndAllowThreads(__tstate);
30397 if (PyErr_Occurred()) SWIG_fail;
30398 }
30399 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30400 return resultobj;
30401 fail:
30402 return NULL;
30403 }
30404
30405
30406 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30407 PyObject *resultobj = 0;
30408 int arg1 ;
30409 wxDateSpan result;
30410 int val1 ;
30411 int ecode1 = 0 ;
30412 PyObject * obj0 = 0 ;
30413 char * kwnames[] = {
30414 (char *) "weeks", NULL
30415 };
30416
30417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30418 ecode1 = SWIG_AsVal_int(obj0, &val1);
30419 if (!SWIG_IsOK(ecode1)) {
30420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30421 }
30422 arg1 = static_cast< int >(val1);
30423 {
30424 PyThreadState* __tstate = wxPyBeginAllowThreads();
30425 result = wxDateSpan::Weeks(arg1);
30426 wxPyEndAllowThreads(__tstate);
30427 if (PyErr_Occurred()) SWIG_fail;
30428 }
30429 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30430 return resultobj;
30431 fail:
30432 return NULL;
30433 }
30434
30435
30436 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30437 PyObject *resultobj = 0;
30438 wxDateSpan result;
30439
30440 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 result = wxDateSpan::Week();
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30455 PyObject *resultobj = 0;
30456 int arg1 ;
30457 wxDateSpan result;
30458 int val1 ;
30459 int ecode1 = 0 ;
30460 PyObject * obj0 = 0 ;
30461 char * kwnames[] = {
30462 (char *) "mon", NULL
30463 };
30464
30465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30466 ecode1 = SWIG_AsVal_int(obj0, &val1);
30467 if (!SWIG_IsOK(ecode1)) {
30468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30469 }
30470 arg1 = static_cast< int >(val1);
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = wxDateSpan::Months(arg1);
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30485 PyObject *resultobj = 0;
30486 wxDateSpan result;
30487
30488 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30489 {
30490 PyThreadState* __tstate = wxPyBeginAllowThreads();
30491 result = wxDateSpan::Month();
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30503 PyObject *resultobj = 0;
30504 int arg1 ;
30505 wxDateSpan result;
30506 int val1 ;
30507 int ecode1 = 0 ;
30508 PyObject * obj0 = 0 ;
30509 char * kwnames[] = {
30510 (char *) "years", NULL
30511 };
30512
30513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30514 ecode1 = SWIG_AsVal_int(obj0, &val1);
30515 if (!SWIG_IsOK(ecode1)) {
30516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30517 }
30518 arg1 = static_cast< int >(val1);
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 result = wxDateSpan::Years(arg1);
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30526 return resultobj;
30527 fail:
30528 return NULL;
30529 }
30530
30531
30532 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30533 PyObject *resultobj = 0;
30534 wxDateSpan result;
30535
30536 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30537 {
30538 PyThreadState* __tstate = wxPyBeginAllowThreads();
30539 result = wxDateSpan::Year();
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30551 PyObject *resultobj = 0;
30552 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30553 int arg2 ;
30554 wxDateSpan *result = 0 ;
30555 void *argp1 = 0 ;
30556 int res1 = 0 ;
30557 int val2 ;
30558 int ecode2 = 0 ;
30559 PyObject * obj0 = 0 ;
30560 PyObject * obj1 = 0 ;
30561 char * kwnames[] = {
30562 (char *) "self",(char *) "n", NULL
30563 };
30564
30565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30567 if (!SWIG_IsOK(res1)) {
30568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30569 }
30570 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30571 ecode2 = SWIG_AsVal_int(obj1, &val2);
30572 if (!SWIG_IsOK(ecode2)) {
30573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30574 }
30575 arg2 = static_cast< int >(val2);
30576 {
30577 PyThreadState* __tstate = wxPyBeginAllowThreads();
30578 {
30579 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30580 result = (wxDateSpan *) &_result_ref;
30581 }
30582 wxPyEndAllowThreads(__tstate);
30583 if (PyErr_Occurred()) SWIG_fail;
30584 }
30585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30586 return resultobj;
30587 fail:
30588 return NULL;
30589 }
30590
30591
30592 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30593 PyObject *resultobj = 0;
30594 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30595 int arg2 ;
30596 wxDateSpan *result = 0 ;
30597 void *argp1 = 0 ;
30598 int res1 = 0 ;
30599 int val2 ;
30600 int ecode2 = 0 ;
30601 PyObject * obj0 = 0 ;
30602 PyObject * obj1 = 0 ;
30603 char * kwnames[] = {
30604 (char *) "self",(char *) "n", NULL
30605 };
30606
30607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30609 if (!SWIG_IsOK(res1)) {
30610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30611 }
30612 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30613 ecode2 = SWIG_AsVal_int(obj1, &val2);
30614 if (!SWIG_IsOK(ecode2)) {
30615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30616 }
30617 arg2 = static_cast< int >(val2);
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 {
30621 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30622 result = (wxDateSpan *) &_result_ref;
30623 }
30624 wxPyEndAllowThreads(__tstate);
30625 if (PyErr_Occurred()) SWIG_fail;
30626 }
30627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30635 PyObject *resultobj = 0;
30636 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30637 int arg2 ;
30638 wxDateSpan *result = 0 ;
30639 void *argp1 = 0 ;
30640 int res1 = 0 ;
30641 int val2 ;
30642 int ecode2 = 0 ;
30643 PyObject * obj0 = 0 ;
30644 PyObject * obj1 = 0 ;
30645 char * kwnames[] = {
30646 (char *) "self",(char *) "n", NULL
30647 };
30648
30649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30651 if (!SWIG_IsOK(res1)) {
30652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30653 }
30654 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30655 ecode2 = SWIG_AsVal_int(obj1, &val2);
30656 if (!SWIG_IsOK(ecode2)) {
30657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30658 }
30659 arg2 = static_cast< int >(val2);
30660 {
30661 PyThreadState* __tstate = wxPyBeginAllowThreads();
30662 {
30663 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30664 result = (wxDateSpan *) &_result_ref;
30665 }
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj = 0;
30678 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30679 int arg2 ;
30680 wxDateSpan *result = 0 ;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 int val2 ;
30684 int ecode2 = 0 ;
30685 PyObject * obj0 = 0 ;
30686 PyObject * obj1 = 0 ;
30687 char * kwnames[] = {
30688 (char *) "self",(char *) "n", NULL
30689 };
30690
30691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30693 if (!SWIG_IsOK(res1)) {
30694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30695 }
30696 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30697 ecode2 = SWIG_AsVal_int(obj1, &val2);
30698 if (!SWIG_IsOK(ecode2)) {
30699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30700 }
30701 arg2 = static_cast< int >(val2);
30702 {
30703 PyThreadState* __tstate = wxPyBeginAllowThreads();
30704 {
30705 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30706 result = (wxDateSpan *) &_result_ref;
30707 }
30708 wxPyEndAllowThreads(__tstate);
30709 if (PyErr_Occurred()) SWIG_fail;
30710 }
30711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30712 return resultobj;
30713 fail:
30714 return NULL;
30715 }
30716
30717
30718 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30719 PyObject *resultobj = 0;
30720 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30721 int result;
30722 void *argp1 = 0 ;
30723 int res1 = 0 ;
30724 PyObject *swig_obj[1] ;
30725
30726 if (!args) SWIG_fail;
30727 swig_obj[0] = args;
30728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30729 if (!SWIG_IsOK(res1)) {
30730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30731 }
30732 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30733 {
30734 PyThreadState* __tstate = wxPyBeginAllowThreads();
30735 result = (int)((wxDateSpan const *)arg1)->GetYears();
30736 wxPyEndAllowThreads(__tstate);
30737 if (PyErr_Occurred()) SWIG_fail;
30738 }
30739 resultobj = SWIG_From_int(static_cast< int >(result));
30740 return resultobj;
30741 fail:
30742 return NULL;
30743 }
30744
30745
30746 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30747 PyObject *resultobj = 0;
30748 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30749 int result;
30750 void *argp1 = 0 ;
30751 int res1 = 0 ;
30752 PyObject *swig_obj[1] ;
30753
30754 if (!args) SWIG_fail;
30755 swig_obj[0] = args;
30756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30757 if (!SWIG_IsOK(res1)) {
30758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30759 }
30760 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_From_int(static_cast< int >(result));
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30775 PyObject *resultobj = 0;
30776 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30777 int result;
30778 void *argp1 = 0 ;
30779 int res1 = 0 ;
30780 PyObject *swig_obj[1] ;
30781
30782 if (!args) SWIG_fail;
30783 swig_obj[0] = args;
30784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30787 }
30788 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 resultobj = SWIG_From_int(static_cast< int >(result));
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30803 PyObject *resultobj = 0;
30804 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30805 int result;
30806 void *argp1 = 0 ;
30807 int res1 = 0 ;
30808 PyObject *swig_obj[1] ;
30809
30810 if (!args) SWIG_fail;
30811 swig_obj[0] = args;
30812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30813 if (!SWIG_IsOK(res1)) {
30814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30815 }
30816 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 result = (int)((wxDateSpan const *)arg1)->GetDays();
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 resultobj = SWIG_From_int(static_cast< int >(result));
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30831 PyObject *resultobj = 0;
30832 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30833 int result;
30834 void *argp1 = 0 ;
30835 int res1 = 0 ;
30836 PyObject *swig_obj[1] ;
30837
30838 if (!args) SWIG_fail;
30839 swig_obj[0] = args;
30840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30841 if (!SWIG_IsOK(res1)) {
30842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30843 }
30844 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30845 {
30846 PyThreadState* __tstate = wxPyBeginAllowThreads();
30847 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 resultobj = SWIG_From_int(static_cast< int >(result));
30852 return resultobj;
30853 fail:
30854 return NULL;
30855 }
30856
30857
30858 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30859 PyObject *resultobj = 0;
30860 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30861 wxDateSpan *arg2 = 0 ;
30862 wxDateSpan *result = 0 ;
30863 void *argp1 = 0 ;
30864 int res1 = 0 ;
30865 void *argp2 = 0 ;
30866 int res2 = 0 ;
30867 PyObject * obj0 = 0 ;
30868 PyObject * obj1 = 0 ;
30869 char * kwnames[] = {
30870 (char *) "self",(char *) "other", NULL
30871 };
30872
30873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30875 if (!SWIG_IsOK(res1)) {
30876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30877 }
30878 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30879 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30880 if (!SWIG_IsOK(res2)) {
30881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30882 }
30883 if (!argp2) {
30884 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30885 }
30886 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30887 {
30888 PyThreadState* __tstate = wxPyBeginAllowThreads();
30889 {
30890 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30891 result = (wxDateSpan *) &_result_ref;
30892 }
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30897 return resultobj;
30898 fail:
30899 return NULL;
30900 }
30901
30902
30903 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30904 PyObject *resultobj = 0;
30905 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30906 wxDateSpan *arg2 = 0 ;
30907 wxDateSpan *result = 0 ;
30908 void *argp1 = 0 ;
30909 int res1 = 0 ;
30910 void *argp2 = 0 ;
30911 int res2 = 0 ;
30912 PyObject * obj0 = 0 ;
30913 PyObject * obj1 = 0 ;
30914 char * kwnames[] = {
30915 (char *) "self",(char *) "other", NULL
30916 };
30917
30918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30920 if (!SWIG_IsOK(res1)) {
30921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30922 }
30923 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30924 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30925 if (!SWIG_IsOK(res2)) {
30926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30927 }
30928 if (!argp2) {
30929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30930 }
30931 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30932 {
30933 PyThreadState* __tstate = wxPyBeginAllowThreads();
30934 {
30935 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30936 result = (wxDateSpan *) &_result_ref;
30937 }
30938 wxPyEndAllowThreads(__tstate);
30939 if (PyErr_Occurred()) SWIG_fail;
30940 }
30941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30949 PyObject *resultobj = 0;
30950 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30951 wxDateSpan *result = 0 ;
30952 void *argp1 = 0 ;
30953 int res1 = 0 ;
30954 PyObject *swig_obj[1] ;
30955
30956 if (!args) SWIG_fail;
30957 swig_obj[0] = args;
30958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30959 if (!SWIG_IsOK(res1)) {
30960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30961 }
30962 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 {
30966 wxDateSpan &_result_ref = (arg1)->Neg();
30967 result = (wxDateSpan *) &_result_ref;
30968 }
30969 wxPyEndAllowThreads(__tstate);
30970 if (PyErr_Occurred()) SWIG_fail;
30971 }
30972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30973 return resultobj;
30974 fail:
30975 return NULL;
30976 }
30977
30978
30979 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30980 PyObject *resultobj = 0;
30981 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30982 int arg2 ;
30983 wxDateSpan *result = 0 ;
30984 void *argp1 = 0 ;
30985 int res1 = 0 ;
30986 int val2 ;
30987 int ecode2 = 0 ;
30988 PyObject * obj0 = 0 ;
30989 PyObject * obj1 = 0 ;
30990 char * kwnames[] = {
30991 (char *) "self",(char *) "factor", NULL
30992 };
30993
30994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30996 if (!SWIG_IsOK(res1)) {
30997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30998 }
30999 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31000 ecode2 = SWIG_AsVal_int(obj1, &val2);
31001 if (!SWIG_IsOK(ecode2)) {
31002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31003 }
31004 arg2 = static_cast< int >(val2);
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 {
31008 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31009 result = (wxDateSpan *) &_result_ref;
31010 }
31011 wxPyEndAllowThreads(__tstate);
31012 if (PyErr_Occurred()) SWIG_fail;
31013 }
31014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31022 PyObject *resultobj = 0;
31023 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31024 wxDateSpan *arg2 = 0 ;
31025 wxDateSpan *result = 0 ;
31026 void *argp1 = 0 ;
31027 int res1 = 0 ;
31028 void *argp2 = 0 ;
31029 int res2 = 0 ;
31030 PyObject * obj0 = 0 ;
31031 PyObject * obj1 = 0 ;
31032 char * kwnames[] = {
31033 (char *) "self",(char *) "other", NULL
31034 };
31035
31036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31038 if (!SWIG_IsOK(res1)) {
31039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31040 }
31041 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31043 if (!SWIG_IsOK(res2)) {
31044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31045 }
31046 if (!argp2) {
31047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31048 }
31049 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31050 {
31051 PyThreadState* __tstate = wxPyBeginAllowThreads();
31052 {
31053 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31054 result = (wxDateSpan *) &_result_ref;
31055 }
31056 wxPyEndAllowThreads(__tstate);
31057 if (PyErr_Occurred()) SWIG_fail;
31058 }
31059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31060 return resultobj;
31061 fail:
31062 return NULL;
31063 }
31064
31065
31066 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31067 PyObject *resultobj = 0;
31068 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31069 wxDateSpan *arg2 = 0 ;
31070 wxDateSpan *result = 0 ;
31071 void *argp1 = 0 ;
31072 int res1 = 0 ;
31073 void *argp2 = 0 ;
31074 int res2 = 0 ;
31075 PyObject * obj0 = 0 ;
31076 PyObject * obj1 = 0 ;
31077 char * kwnames[] = {
31078 (char *) "self",(char *) "other", NULL
31079 };
31080
31081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31085 }
31086 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31088 if (!SWIG_IsOK(res2)) {
31089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31090 }
31091 if (!argp2) {
31092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31093 }
31094 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31095 {
31096 PyThreadState* __tstate = wxPyBeginAllowThreads();
31097 {
31098 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31099 result = (wxDateSpan *) &_result_ref;
31100 }
31101 wxPyEndAllowThreads(__tstate);
31102 if (PyErr_Occurred()) SWIG_fail;
31103 }
31104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31112 PyObject *resultobj = 0;
31113 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31114 wxDateSpan *result = 0 ;
31115 void *argp1 = 0 ;
31116 int res1 = 0 ;
31117 PyObject *swig_obj[1] ;
31118
31119 if (!args) SWIG_fail;
31120 swig_obj[0] = args;
31121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31122 if (!SWIG_IsOK(res1)) {
31123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31124 }
31125 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 {
31129 wxDateSpan &_result_ref = (arg1)->operator -();
31130 result = (wxDateSpan *) &_result_ref;
31131 }
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31143 PyObject *resultobj = 0;
31144 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31145 int arg2 ;
31146 wxDateSpan *result = 0 ;
31147 void *argp1 = 0 ;
31148 int res1 = 0 ;
31149 int val2 ;
31150 int ecode2 = 0 ;
31151 PyObject * obj0 = 0 ;
31152 PyObject * obj1 = 0 ;
31153 char * kwnames[] = {
31154 (char *) "self",(char *) "factor", NULL
31155 };
31156
31157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31159 if (!SWIG_IsOK(res1)) {
31160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31161 }
31162 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31163 ecode2 = SWIG_AsVal_int(obj1, &val2);
31164 if (!SWIG_IsOK(ecode2)) {
31165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31166 }
31167 arg2 = static_cast< int >(val2);
31168 {
31169 PyThreadState* __tstate = wxPyBeginAllowThreads();
31170 {
31171 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31172 result = (wxDateSpan *) &_result_ref;
31173 }
31174 wxPyEndAllowThreads(__tstate);
31175 if (PyErr_Occurred()) SWIG_fail;
31176 }
31177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31185 PyObject *resultobj = 0;
31186 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31187 wxDateSpan *arg2 = 0 ;
31188 wxDateSpan result;
31189 void *argp1 = 0 ;
31190 int res1 = 0 ;
31191 void *argp2 = 0 ;
31192 int res2 = 0 ;
31193 PyObject * obj0 = 0 ;
31194 PyObject * obj1 = 0 ;
31195 char * kwnames[] = {
31196 (char *) "self",(char *) "other", NULL
31197 };
31198
31199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31201 if (!SWIG_IsOK(res1)) {
31202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31203 }
31204 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31206 if (!SWIG_IsOK(res2)) {
31207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31208 }
31209 if (!argp2) {
31210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31211 }
31212 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31213 {
31214 PyThreadState* __tstate = wxPyBeginAllowThreads();
31215 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31216 wxPyEndAllowThreads(__tstate);
31217 if (PyErr_Occurred()) SWIG_fail;
31218 }
31219 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31220 return resultobj;
31221 fail:
31222 return NULL;
31223 }
31224
31225
31226 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31227 PyObject *resultobj = 0;
31228 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31229 wxDateSpan *arg2 = 0 ;
31230 wxDateSpan result;
31231 void *argp1 = 0 ;
31232 int res1 = 0 ;
31233 void *argp2 = 0 ;
31234 int res2 = 0 ;
31235 PyObject * obj0 = 0 ;
31236 PyObject * obj1 = 0 ;
31237 char * kwnames[] = {
31238 (char *) "self",(char *) "other", NULL
31239 };
31240
31241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31243 if (!SWIG_IsOK(res1)) {
31244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31245 }
31246 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31248 if (!SWIG_IsOK(res2)) {
31249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31250 }
31251 if (!argp2) {
31252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31253 }
31254 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31258 wxPyEndAllowThreads(__tstate);
31259 if (PyErr_Occurred()) SWIG_fail;
31260 }
31261 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj = 0;
31270 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31271 int arg2 ;
31272 wxDateSpan result;
31273 void *argp1 = 0 ;
31274 int res1 = 0 ;
31275 int val2 ;
31276 int ecode2 = 0 ;
31277 PyObject * obj0 = 0 ;
31278 PyObject * obj1 = 0 ;
31279 char * kwnames[] = {
31280 (char *) "self",(char *) "n", NULL
31281 };
31282
31283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31285 if (!SWIG_IsOK(res1)) {
31286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31287 }
31288 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31289 ecode2 = SWIG_AsVal_int(obj1, &val2);
31290 if (!SWIG_IsOK(ecode2)) {
31291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31292 }
31293 arg2 = static_cast< int >(val2);
31294 {
31295 PyThreadState* __tstate = wxPyBeginAllowThreads();
31296 result = wxDateSpan___mul__(arg1,arg2);
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31301 return resultobj;
31302 fail:
31303 return NULL;
31304 }
31305
31306
31307 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31308 PyObject *resultobj = 0;
31309 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31310 int arg2 ;
31311 wxDateSpan result;
31312 void *argp1 = 0 ;
31313 int res1 = 0 ;
31314 int val2 ;
31315 int ecode2 = 0 ;
31316 PyObject * obj0 = 0 ;
31317 PyObject * obj1 = 0 ;
31318 char * kwnames[] = {
31319 (char *) "self",(char *) "n", NULL
31320 };
31321
31322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31324 if (!SWIG_IsOK(res1)) {
31325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31326 }
31327 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31328 ecode2 = SWIG_AsVal_int(obj1, &val2);
31329 if (!SWIG_IsOK(ecode2)) {
31330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31331 }
31332 arg2 = static_cast< int >(val2);
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 result = wxDateSpan___rmul__(arg1,arg2);
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj = 0;
31348 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31349 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31350 bool result;
31351 void *argp1 = 0 ;
31352 int res1 = 0 ;
31353 void *argp2 = 0 ;
31354 int res2 = 0 ;
31355 PyObject * obj0 = 0 ;
31356 PyObject * obj1 = 0 ;
31357 char * kwnames[] = {
31358 (char *) "self",(char *) "other", NULL
31359 };
31360
31361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31363 if (!SWIG_IsOK(res1)) {
31364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31365 }
31366 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31367 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31368 if (!SWIG_IsOK(res2)) {
31369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31370 }
31371 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 {
31379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31380 }
31381 return resultobj;
31382 fail:
31383 return NULL;
31384 }
31385
31386
31387 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31388 PyObject *resultobj = 0;
31389 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31390 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31391 bool result;
31392 void *argp1 = 0 ;
31393 int res1 = 0 ;
31394 void *argp2 = 0 ;
31395 int res2 = 0 ;
31396 PyObject * obj0 = 0 ;
31397 PyObject * obj1 = 0 ;
31398 char * kwnames[] = {
31399 (char *) "self",(char *) "other", NULL
31400 };
31401
31402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31404 if (!SWIG_IsOK(res1)) {
31405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31406 }
31407 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31409 if (!SWIG_IsOK(res2)) {
31410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31411 }
31412 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31413 {
31414 PyThreadState* __tstate = wxPyBeginAllowThreads();
31415 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31416 wxPyEndAllowThreads(__tstate);
31417 if (PyErr_Occurred()) SWIG_fail;
31418 }
31419 {
31420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31421 }
31422 return resultobj;
31423 fail:
31424 return NULL;
31425 }
31426
31427
31428 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31429 PyObject *obj;
31430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31431 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31432 return SWIG_Py_Void();
31433 }
31434
31435 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 return SWIG_Python_InitShadowInstance(args);
31437 }
31438
31439 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31440 PyObject *resultobj = 0;
31441 long result;
31442
31443 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 result = (long)wxGetLocalTime();
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 resultobj = SWIG_From_long(static_cast< long >(result));
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31458 PyObject *resultobj = 0;
31459 long result;
31460
31461 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31462 {
31463 PyThreadState* __tstate = wxPyBeginAllowThreads();
31464 result = (long)wxGetUTCTime();
31465 wxPyEndAllowThreads(__tstate);
31466 if (PyErr_Occurred()) SWIG_fail;
31467 }
31468 resultobj = SWIG_From_long(static_cast< long >(result));
31469 return resultobj;
31470 fail:
31471 return NULL;
31472 }
31473
31474
31475 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31476 PyObject *resultobj = 0;
31477 long result;
31478
31479 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31480 {
31481 PyThreadState* __tstate = wxPyBeginAllowThreads();
31482 result = (long)wxGetCurrentTime();
31483 wxPyEndAllowThreads(__tstate);
31484 if (PyErr_Occurred()) SWIG_fail;
31485 }
31486 resultobj = SWIG_From_long(static_cast< long >(result));
31487 return resultobj;
31488 fail:
31489 return NULL;
31490 }
31491
31492
31493 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31494 PyObject *resultobj = 0;
31495 wxLongLong result;
31496
31497 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = wxGetLocalTimeMillis();
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 {
31505 PyObject *hi, *lo, *shifter, *shifted;
31506 hi = PyLong_FromLong( (&result)->GetHi() );
31507 lo = PyLong_FromLong( (&result)->GetLo() );
31508 shifter = PyLong_FromLong(32);
31509 shifted = PyNumber_Lshift(hi, shifter);
31510 resultobj = PyNumber_Or(shifted, lo);
31511 Py_DECREF(hi);
31512 Py_DECREF(lo);
31513 Py_DECREF(shifter);
31514 Py_DECREF(shifted);
31515 }
31516 return resultobj;
31517 fail:
31518 return NULL;
31519 }
31520
31521
31522 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31523 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31524 return 1;
31525 }
31526
31527
31528 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31529 PyObject *pyobj = 0;
31530
31531 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31532 return pyobj;
31533 }
31534
31535
31536 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31537 PyObject *resultobj = 0;
31538 wxDataFormatId arg1 ;
31539 wxDataFormat *result = 0 ;
31540 int val1 ;
31541 int ecode1 = 0 ;
31542 PyObject * obj0 = 0 ;
31543 char * kwnames[] = {
31544 (char *) "type", NULL
31545 };
31546
31547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31548 ecode1 = SWIG_AsVal_int(obj0, &val1);
31549 if (!SWIG_IsOK(ecode1)) {
31550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31551 }
31552 arg1 = static_cast< wxDataFormatId >(val1);
31553 {
31554 PyThreadState* __tstate = wxPyBeginAllowThreads();
31555 result = (wxDataFormat *)new wxDataFormat(arg1);
31556 wxPyEndAllowThreads(__tstate);
31557 if (PyErr_Occurred()) SWIG_fail;
31558 }
31559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31560 return resultobj;
31561 fail:
31562 return NULL;
31563 }
31564
31565
31566 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31567 PyObject *resultobj = 0;
31568 wxString *arg1 = 0 ;
31569 wxDataFormat *result = 0 ;
31570 bool temp1 = false ;
31571 PyObject * obj0 = 0 ;
31572 char * kwnames[] = {
31573 (char *) "format", NULL
31574 };
31575
31576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31577 {
31578 arg1 = wxString_in_helper(obj0);
31579 if (arg1 == NULL) SWIG_fail;
31580 temp1 = true;
31581 }
31582 {
31583 PyThreadState* __tstate = wxPyBeginAllowThreads();
31584 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31585 wxPyEndAllowThreads(__tstate);
31586 if (PyErr_Occurred()) SWIG_fail;
31587 }
31588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31589 {
31590 if (temp1)
31591 delete arg1;
31592 }
31593 return resultobj;
31594 fail:
31595 {
31596 if (temp1)
31597 delete arg1;
31598 }
31599 return NULL;
31600 }
31601
31602
31603 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31604 PyObject *resultobj = 0;
31605 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31606 void *argp1 = 0 ;
31607 int res1 = 0 ;
31608 PyObject *swig_obj[1] ;
31609
31610 if (!args) SWIG_fail;
31611 swig_obj[0] = args;
31612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31613 if (!SWIG_IsOK(res1)) {
31614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31615 }
31616 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31617 {
31618 PyThreadState* __tstate = wxPyBeginAllowThreads();
31619 delete arg1;
31620
31621 wxPyEndAllowThreads(__tstate);
31622 if (PyErr_Occurred()) SWIG_fail;
31623 }
31624 resultobj = SWIG_Py_Void();
31625 return resultobj;
31626 fail:
31627 return NULL;
31628 }
31629
31630
31631 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31632 PyObject *resultobj = 0;
31633 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31634 wxDataFormatId arg2 ;
31635 bool result;
31636 void *argp1 = 0 ;
31637 int res1 = 0 ;
31638 int val2 ;
31639 int ecode2 = 0 ;
31640
31641 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31643 if (!SWIG_IsOK(res1)) {
31644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31645 }
31646 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31647 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31648 if (!SWIG_IsOK(ecode2)) {
31649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31650 }
31651 arg2 = static_cast< wxDataFormatId >(val2);
31652 {
31653 PyThreadState* __tstate = wxPyBeginAllowThreads();
31654 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31655 wxPyEndAllowThreads(__tstate);
31656 if (PyErr_Occurred()) SWIG_fail;
31657 }
31658 {
31659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31660 }
31661 return resultobj;
31662 fail:
31663 return NULL;
31664 }
31665
31666
31667 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31668 PyObject *resultobj = 0;
31669 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31670 wxDataFormatId arg2 ;
31671 bool result;
31672 void *argp1 = 0 ;
31673 int res1 = 0 ;
31674 int val2 ;
31675 int ecode2 = 0 ;
31676
31677 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31679 if (!SWIG_IsOK(res1)) {
31680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31681 }
31682 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31683 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31684 if (!SWIG_IsOK(ecode2)) {
31685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31686 }
31687 arg2 = static_cast< wxDataFormatId >(val2);
31688 {
31689 PyThreadState* __tstate = wxPyBeginAllowThreads();
31690 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31691 wxPyEndAllowThreads(__tstate);
31692 if (PyErr_Occurred()) SWIG_fail;
31693 }
31694 {
31695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31696 }
31697 return resultobj;
31698 fail:
31699 return NULL;
31700 }
31701
31702
31703 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31704 PyObject *resultobj = 0;
31705 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31706 wxDataFormat *arg2 = 0 ;
31707 bool result;
31708 void *argp1 = 0 ;
31709 int res1 = 0 ;
31710 void *argp2 = 0 ;
31711 int res2 = 0 ;
31712
31713 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31715 if (!SWIG_IsOK(res1)) {
31716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31717 }
31718 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31719 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31720 if (!SWIG_IsOK(res2)) {
31721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31722 }
31723 if (!argp2) {
31724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31725 }
31726 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31727 {
31728 PyThreadState* __tstate = wxPyBeginAllowThreads();
31729 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 {
31734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31735 }
31736 return resultobj;
31737 fail:
31738 return NULL;
31739 }
31740
31741
31742 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31743 int argc;
31744 PyObject *argv[3];
31745
31746 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31747 --argc;
31748 if (argc == 2) {
31749 int _v = 0;
31750 {
31751 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31752 _v = SWIG_CheckState(res);
31753 }
31754 if (!_v) goto check_1;
31755 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31756 }
31757 check_1:
31758
31759 if (argc == 2) {
31760 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31761 }
31762
31763 fail:
31764 Py_INCREF(Py_NotImplemented);
31765 return Py_NotImplemented;
31766 }
31767
31768
31769 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31770 PyObject *resultobj = 0;
31771 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31772 wxDataFormat *arg2 = 0 ;
31773 bool result;
31774 void *argp1 = 0 ;
31775 int res1 = 0 ;
31776 void *argp2 = 0 ;
31777 int res2 = 0 ;
31778
31779 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31781 if (!SWIG_IsOK(res1)) {
31782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31783 }
31784 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31785 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31786 if (!SWIG_IsOK(res2)) {
31787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31788 }
31789 if (!argp2) {
31790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31791 }
31792 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 {
31800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31801 }
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31809 int argc;
31810 PyObject *argv[3];
31811
31812 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31813 --argc;
31814 if (argc == 2) {
31815 int _v = 0;
31816 {
31817 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31818 _v = SWIG_CheckState(res);
31819 }
31820 if (!_v) goto check_1;
31821 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31822 }
31823 check_1:
31824
31825 if (argc == 2) {
31826 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31827 }
31828
31829 fail:
31830 Py_INCREF(Py_NotImplemented);
31831 return Py_NotImplemented;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31836 PyObject *resultobj = 0;
31837 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31838 wxDataFormatId arg2 ;
31839 void *argp1 = 0 ;
31840 int res1 = 0 ;
31841 int val2 ;
31842 int ecode2 = 0 ;
31843 PyObject * obj0 = 0 ;
31844 PyObject * obj1 = 0 ;
31845 char * kwnames[] = {
31846 (char *) "self",(char *) "format", NULL
31847 };
31848
31849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31851 if (!SWIG_IsOK(res1)) {
31852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31853 }
31854 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31855 ecode2 = SWIG_AsVal_int(obj1, &val2);
31856 if (!SWIG_IsOK(ecode2)) {
31857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31858 }
31859 arg2 = static_cast< wxDataFormatId >(val2);
31860 {
31861 PyThreadState* __tstate = wxPyBeginAllowThreads();
31862 (arg1)->SetType(arg2);
31863 wxPyEndAllowThreads(__tstate);
31864 if (PyErr_Occurred()) SWIG_fail;
31865 }
31866 resultobj = SWIG_Py_Void();
31867 return resultobj;
31868 fail:
31869 return NULL;
31870 }
31871
31872
31873 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31874 PyObject *resultobj = 0;
31875 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31876 wxDataFormatId result;
31877 void *argp1 = 0 ;
31878 int res1 = 0 ;
31879 PyObject *swig_obj[1] ;
31880
31881 if (!args) SWIG_fail;
31882 swig_obj[0] = args;
31883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31884 if (!SWIG_IsOK(res1)) {
31885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31886 }
31887 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31888 {
31889 PyThreadState* __tstate = wxPyBeginAllowThreads();
31890 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31891 wxPyEndAllowThreads(__tstate);
31892 if (PyErr_Occurred()) SWIG_fail;
31893 }
31894 resultobj = SWIG_From_int(static_cast< int >(result));
31895 return resultobj;
31896 fail:
31897 return NULL;
31898 }
31899
31900
31901 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31902 PyObject *resultobj = 0;
31903 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31904 wxString result;
31905 void *argp1 = 0 ;
31906 int res1 = 0 ;
31907 PyObject *swig_obj[1] ;
31908
31909 if (!args) SWIG_fail;
31910 swig_obj[0] = args;
31911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31912 if (!SWIG_IsOK(res1)) {
31913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31914 }
31915 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31916 {
31917 PyThreadState* __tstate = wxPyBeginAllowThreads();
31918 result = ((wxDataFormat const *)arg1)->GetId();
31919 wxPyEndAllowThreads(__tstate);
31920 if (PyErr_Occurred()) SWIG_fail;
31921 }
31922 {
31923 #if wxUSE_UNICODE
31924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31925 #else
31926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31927 #endif
31928 }
31929 return resultobj;
31930 fail:
31931 return NULL;
31932 }
31933
31934
31935 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31936 PyObject *resultobj = 0;
31937 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31938 wxString *arg2 = 0 ;
31939 void *argp1 = 0 ;
31940 int res1 = 0 ;
31941 bool temp2 = false ;
31942 PyObject * obj0 = 0 ;
31943 PyObject * obj1 = 0 ;
31944 char * kwnames[] = {
31945 (char *) "self",(char *) "format", NULL
31946 };
31947
31948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31950 if (!SWIG_IsOK(res1)) {
31951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31952 }
31953 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31954 {
31955 arg2 = wxString_in_helper(obj1);
31956 if (arg2 == NULL) SWIG_fail;
31957 temp2 = true;
31958 }
31959 {
31960 PyThreadState* __tstate = wxPyBeginAllowThreads();
31961 (arg1)->SetId((wxString const &)*arg2);
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 resultobj = SWIG_Py_Void();
31966 {
31967 if (temp2)
31968 delete arg2;
31969 }
31970 return resultobj;
31971 fail:
31972 {
31973 if (temp2)
31974 delete arg2;
31975 }
31976 return NULL;
31977 }
31978
31979
31980 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31981 PyObject *obj;
31982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31983 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31984 return SWIG_Py_Void();
31985 }
31986
31987 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31988 return SWIG_Python_InitShadowInstance(args);
31989 }
31990
31991 SWIGINTERN int FormatInvalid_set(PyObject *) {
31992 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31993 return 1;
31994 }
31995
31996
31997 SWIGINTERN PyObject *FormatInvalid_get(void) {
31998 PyObject *pyobj = 0;
31999
32000 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32001 return pyobj;
32002 }
32003
32004
32005 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32006 PyObject *resultobj = 0;
32007 wxDataObject *arg1 = (wxDataObject *) 0 ;
32008 void *argp1 = 0 ;
32009 int res1 = 0 ;
32010 PyObject *swig_obj[1] ;
32011
32012 if (!args) SWIG_fail;
32013 swig_obj[0] = args;
32014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32015 if (!SWIG_IsOK(res1)) {
32016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32017 }
32018 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32019 {
32020 PyThreadState* __tstate = wxPyBeginAllowThreads();
32021 delete arg1;
32022
32023 wxPyEndAllowThreads(__tstate);
32024 if (PyErr_Occurred()) SWIG_fail;
32025 }
32026 resultobj = SWIG_Py_Void();
32027 return resultobj;
32028 fail:
32029 return NULL;
32030 }
32031
32032
32033 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32034 PyObject *resultobj = 0;
32035 wxDataObject *arg1 = (wxDataObject *) 0 ;
32036 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32037 SwigValueWrapper<wxDataFormat > result;
32038 void *argp1 = 0 ;
32039 int res1 = 0 ;
32040 int val2 ;
32041 int ecode2 = 0 ;
32042 PyObject * obj0 = 0 ;
32043 PyObject * obj1 = 0 ;
32044 char * kwnames[] = {
32045 (char *) "self",(char *) "dir", NULL
32046 };
32047
32048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32050 if (!SWIG_IsOK(res1)) {
32051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32052 }
32053 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32054 if (obj1) {
32055 ecode2 = SWIG_AsVal_int(obj1, &val2);
32056 if (!SWIG_IsOK(ecode2)) {
32057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32058 }
32059 arg2 = static_cast< wxDataObject::Direction >(val2);
32060 }
32061 {
32062 PyThreadState* __tstate = wxPyBeginAllowThreads();
32063 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32064 wxPyEndAllowThreads(__tstate);
32065 if (PyErr_Occurred()) SWIG_fail;
32066 }
32067 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32068 return resultobj;
32069 fail:
32070 return NULL;
32071 }
32072
32073
32074 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32075 PyObject *resultobj = 0;
32076 wxDataObject *arg1 = (wxDataObject *) 0 ;
32077 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32078 size_t result;
32079 void *argp1 = 0 ;
32080 int res1 = 0 ;
32081 int val2 ;
32082 int ecode2 = 0 ;
32083 PyObject * obj0 = 0 ;
32084 PyObject * obj1 = 0 ;
32085 char * kwnames[] = {
32086 (char *) "self",(char *) "dir", NULL
32087 };
32088
32089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32091 if (!SWIG_IsOK(res1)) {
32092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32093 }
32094 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32095 if (obj1) {
32096 ecode2 = SWIG_AsVal_int(obj1, &val2);
32097 if (!SWIG_IsOK(ecode2)) {
32098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32099 }
32100 arg2 = static_cast< wxDataObject::Direction >(val2);
32101 }
32102 {
32103 PyThreadState* __tstate = wxPyBeginAllowThreads();
32104 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32105 wxPyEndAllowThreads(__tstate);
32106 if (PyErr_Occurred()) SWIG_fail;
32107 }
32108 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32109 return resultobj;
32110 fail:
32111 return NULL;
32112 }
32113
32114
32115 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32116 PyObject *resultobj = 0;
32117 wxDataObject *arg1 = (wxDataObject *) 0 ;
32118 wxDataFormat *arg2 = 0 ;
32119 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32120 bool result;
32121 void *argp1 = 0 ;
32122 int res1 = 0 ;
32123 void *argp2 = 0 ;
32124 int res2 = 0 ;
32125 int val3 ;
32126 int ecode3 = 0 ;
32127 PyObject * obj0 = 0 ;
32128 PyObject * obj1 = 0 ;
32129 PyObject * obj2 = 0 ;
32130 char * kwnames[] = {
32131 (char *) "self",(char *) "format",(char *) "dir", NULL
32132 };
32133
32134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32136 if (!SWIG_IsOK(res1)) {
32137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32138 }
32139 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32140 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32141 if (!SWIG_IsOK(res2)) {
32142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32143 }
32144 if (!argp2) {
32145 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32146 }
32147 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32148 if (obj2) {
32149 ecode3 = SWIG_AsVal_int(obj2, &val3);
32150 if (!SWIG_IsOK(ecode3)) {
32151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32152 }
32153 arg3 = static_cast< wxDataObject::Direction >(val3);
32154 }
32155 {
32156 PyThreadState* __tstate = wxPyBeginAllowThreads();
32157 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32158 wxPyEndAllowThreads(__tstate);
32159 if (PyErr_Occurred()) SWIG_fail;
32160 }
32161 {
32162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32163 }
32164 return resultobj;
32165 fail:
32166 return NULL;
32167 }
32168
32169
32170 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32171 PyObject *resultobj = 0;
32172 wxDataObject *arg1 = (wxDataObject *) 0 ;
32173 wxDataFormat *arg2 = 0 ;
32174 size_t result;
32175 void *argp1 = 0 ;
32176 int res1 = 0 ;
32177 void *argp2 = 0 ;
32178 int res2 = 0 ;
32179 PyObject * obj0 = 0 ;
32180 PyObject * obj1 = 0 ;
32181 char * kwnames[] = {
32182 (char *) "self",(char *) "format", NULL
32183 };
32184
32185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32187 if (!SWIG_IsOK(res1)) {
32188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32189 }
32190 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32191 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32192 if (!SWIG_IsOK(res2)) {
32193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32194 }
32195 if (!argp2) {
32196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32197 }
32198 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32199 {
32200 PyThreadState* __tstate = wxPyBeginAllowThreads();
32201 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32202 wxPyEndAllowThreads(__tstate);
32203 if (PyErr_Occurred()) SWIG_fail;
32204 }
32205 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32206 return resultobj;
32207 fail:
32208 return NULL;
32209 }
32210
32211
32212 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32213 PyObject *resultobj = 0;
32214 wxDataObject *arg1 = (wxDataObject *) 0 ;
32215 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32216 PyObject *result = 0 ;
32217 void *argp1 = 0 ;
32218 int res1 = 0 ;
32219 int val2 ;
32220 int ecode2 = 0 ;
32221 PyObject * obj0 = 0 ;
32222 PyObject * obj1 = 0 ;
32223 char * kwnames[] = {
32224 (char *) "self",(char *) "dir", NULL
32225 };
32226
32227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32229 if (!SWIG_IsOK(res1)) {
32230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32231 }
32232 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32233 if (obj1) {
32234 ecode2 = SWIG_AsVal_int(obj1, &val2);
32235 if (!SWIG_IsOK(ecode2)) {
32236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32237 }
32238 arg2 = static_cast< wxDataObject::Direction >(val2);
32239 }
32240 {
32241 PyThreadState* __tstate = wxPyBeginAllowThreads();
32242 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32243 wxPyEndAllowThreads(__tstate);
32244 if (PyErr_Occurred()) SWIG_fail;
32245 }
32246 resultobj = result;
32247 return resultobj;
32248 fail:
32249 return NULL;
32250 }
32251
32252
32253 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32254 PyObject *resultobj = 0;
32255 wxDataObject *arg1 = (wxDataObject *) 0 ;
32256 wxDataFormat *arg2 = 0 ;
32257 PyObject *result = 0 ;
32258 void *argp1 = 0 ;
32259 int res1 = 0 ;
32260 void *argp2 = 0 ;
32261 int res2 = 0 ;
32262 PyObject * obj0 = 0 ;
32263 PyObject * obj1 = 0 ;
32264 char * kwnames[] = {
32265 (char *) "self",(char *) "format", NULL
32266 };
32267
32268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32270 if (!SWIG_IsOK(res1)) {
32271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32272 }
32273 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32274 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32275 if (!SWIG_IsOK(res2)) {
32276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32277 }
32278 if (!argp2) {
32279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32280 }
32281 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32282 {
32283 PyThreadState* __tstate = wxPyBeginAllowThreads();
32284 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32285 wxPyEndAllowThreads(__tstate);
32286 if (PyErr_Occurred()) SWIG_fail;
32287 }
32288 resultobj = result;
32289 return resultobj;
32290 fail:
32291 return NULL;
32292 }
32293
32294
32295 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32296 PyObject *resultobj = 0;
32297 wxDataObject *arg1 = (wxDataObject *) 0 ;
32298 wxDataFormat *arg2 = 0 ;
32299 PyObject *arg3 = (PyObject *) 0 ;
32300 bool result;
32301 void *argp1 = 0 ;
32302 int res1 = 0 ;
32303 void *argp2 = 0 ;
32304 int res2 = 0 ;
32305 PyObject * obj0 = 0 ;
32306 PyObject * obj1 = 0 ;
32307 PyObject * obj2 = 0 ;
32308 char * kwnames[] = {
32309 (char *) "self",(char *) "format",(char *) "data", NULL
32310 };
32311
32312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32314 if (!SWIG_IsOK(res1)) {
32315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32316 }
32317 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32318 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32319 if (!SWIG_IsOK(res2)) {
32320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32321 }
32322 if (!argp2) {
32323 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32324 }
32325 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32326 arg3 = obj2;
32327 {
32328 PyThreadState* __tstate = wxPyBeginAllowThreads();
32329 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32330 wxPyEndAllowThreads(__tstate);
32331 if (PyErr_Occurred()) SWIG_fail;
32332 }
32333 {
32334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32335 }
32336 return resultobj;
32337 fail:
32338 return NULL;
32339 }
32340
32341
32342 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32343 PyObject *obj;
32344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32345 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32346 return SWIG_Py_Void();
32347 }
32348
32349 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32350 PyObject *resultobj = 0;
32351 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32352 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32353 wxDataObjectSimple *result = 0 ;
32354 void *argp1 = 0 ;
32355 int res1 = 0 ;
32356 PyObject * obj0 = 0 ;
32357 char * kwnames[] = {
32358 (char *) "format", NULL
32359 };
32360
32361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32362 if (obj0) {
32363 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32364 if (!SWIG_IsOK(res1)) {
32365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32366 }
32367 if (!argp1) {
32368 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32369 }
32370 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32371 }
32372 {
32373 PyThreadState* __tstate = wxPyBeginAllowThreads();
32374 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32375 wxPyEndAllowThreads(__tstate);
32376 if (PyErr_Occurred()) SWIG_fail;
32377 }
32378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32379 return resultobj;
32380 fail:
32381 return NULL;
32382 }
32383
32384
32385 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32386 PyObject *resultobj = 0;
32387 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32388 wxDataFormat *result = 0 ;
32389 void *argp1 = 0 ;
32390 int res1 = 0 ;
32391 PyObject *swig_obj[1] ;
32392
32393 if (!args) SWIG_fail;
32394 swig_obj[0] = args;
32395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32396 if (!SWIG_IsOK(res1)) {
32397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32398 }
32399 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32400 {
32401 PyThreadState* __tstate = wxPyBeginAllowThreads();
32402 {
32403 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32404 result = (wxDataFormat *) &_result_ref;
32405 }
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32417 PyObject *resultobj = 0;
32418 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32419 wxDataFormat *arg2 = 0 ;
32420 void *argp1 = 0 ;
32421 int res1 = 0 ;
32422 void *argp2 = 0 ;
32423 int res2 = 0 ;
32424 PyObject * obj0 = 0 ;
32425 PyObject * obj1 = 0 ;
32426 char * kwnames[] = {
32427 (char *) "self",(char *) "format", NULL
32428 };
32429
32430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32432 if (!SWIG_IsOK(res1)) {
32433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32434 }
32435 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32436 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32437 if (!SWIG_IsOK(res2)) {
32438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32439 }
32440 if (!argp2) {
32441 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32442 }
32443 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32444 {
32445 PyThreadState* __tstate = wxPyBeginAllowThreads();
32446 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32447 wxPyEndAllowThreads(__tstate);
32448 if (PyErr_Occurred()) SWIG_fail;
32449 }
32450 resultobj = SWIG_Py_Void();
32451 return resultobj;
32452 fail:
32453 return NULL;
32454 }
32455
32456
32457 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32458 PyObject *resultobj = 0;
32459 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32460 size_t result;
32461 void *argp1 = 0 ;
32462 int res1 = 0 ;
32463 PyObject *swig_obj[1] ;
32464
32465 if (!args) SWIG_fail;
32466 swig_obj[0] = args;
32467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32468 if (!SWIG_IsOK(res1)) {
32469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32470 }
32471 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32472 {
32473 PyThreadState* __tstate = wxPyBeginAllowThreads();
32474 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32475 wxPyEndAllowThreads(__tstate);
32476 if (PyErr_Occurred()) SWIG_fail;
32477 }
32478 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32486 PyObject *resultobj = 0;
32487 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32488 PyObject *result = 0 ;
32489 void *argp1 = 0 ;
32490 int res1 = 0 ;
32491 PyObject *swig_obj[1] ;
32492
32493 if (!args) SWIG_fail;
32494 swig_obj[0] = args;
32495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32496 if (!SWIG_IsOK(res1)) {
32497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32498 }
32499 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32500 {
32501 PyThreadState* __tstate = wxPyBeginAllowThreads();
32502 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 resultobj = result;
32507 return resultobj;
32508 fail:
32509 return NULL;
32510 }
32511
32512
32513 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32514 PyObject *resultobj = 0;
32515 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32516 PyObject *arg2 = (PyObject *) 0 ;
32517 bool result;
32518 void *argp1 = 0 ;
32519 int res1 = 0 ;
32520 PyObject * obj0 = 0 ;
32521 PyObject * obj1 = 0 ;
32522 char * kwnames[] = {
32523 (char *) "self",(char *) "data", NULL
32524 };
32525
32526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32528 if (!SWIG_IsOK(res1)) {
32529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32530 }
32531 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32532 arg2 = obj1;
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 {
32540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32541 }
32542 return resultobj;
32543 fail:
32544 return NULL;
32545 }
32546
32547
32548 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32549 PyObject *obj;
32550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32551 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32552 return SWIG_Py_Void();
32553 }
32554
32555 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32556 return SWIG_Python_InitShadowInstance(args);
32557 }
32558
32559 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32560 PyObject *resultobj = 0;
32561 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32562 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32563 wxPyDataObjectSimple *result = 0 ;
32564 void *argp1 = 0 ;
32565 int res1 = 0 ;
32566 PyObject * obj0 = 0 ;
32567 char * kwnames[] = {
32568 (char *) "format", NULL
32569 };
32570
32571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32572 if (obj0) {
32573 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32574 if (!SWIG_IsOK(res1)) {
32575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32576 }
32577 if (!argp1) {
32578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32579 }
32580 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32581 }
32582 {
32583 PyThreadState* __tstate = wxPyBeginAllowThreads();
32584 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32585 wxPyEndAllowThreads(__tstate);
32586 if (PyErr_Occurred()) SWIG_fail;
32587 }
32588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32589 return resultobj;
32590 fail:
32591 return NULL;
32592 }
32593
32594
32595 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32596 PyObject *resultobj = 0;
32597 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32598 PyObject *arg2 = (PyObject *) 0 ;
32599 PyObject *arg3 = (PyObject *) 0 ;
32600 void *argp1 = 0 ;
32601 int res1 = 0 ;
32602 PyObject * obj0 = 0 ;
32603 PyObject * obj1 = 0 ;
32604 PyObject * obj2 = 0 ;
32605 char * kwnames[] = {
32606 (char *) "self",(char *) "self",(char *) "_class", NULL
32607 };
32608
32609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32611 if (!SWIG_IsOK(res1)) {
32612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32613 }
32614 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32615 arg2 = obj1;
32616 arg3 = obj2;
32617 {
32618 PyThreadState* __tstate = wxPyBeginAllowThreads();
32619 (arg1)->_setCallbackInfo(arg2,arg3);
32620 wxPyEndAllowThreads(__tstate);
32621 if (PyErr_Occurred()) SWIG_fail;
32622 }
32623 resultobj = SWIG_Py_Void();
32624 return resultobj;
32625 fail:
32626 return NULL;
32627 }
32628
32629
32630 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32631 PyObject *obj;
32632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32633 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32634 return SWIG_Py_Void();
32635 }
32636
32637 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32638 return SWIG_Python_InitShadowInstance(args);
32639 }
32640
32641 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32642 PyObject *resultobj = 0;
32643 wxDataObjectComposite *result = 0 ;
32644
32645 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32653 return resultobj;
32654 fail:
32655 return NULL;
32656 }
32657
32658
32659 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32660 PyObject *resultobj = 0;
32661 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32662 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32663 bool arg3 = (bool) false ;
32664 void *argp1 = 0 ;
32665 int res1 = 0 ;
32666 int res2 = 0 ;
32667 bool val3 ;
32668 int ecode3 = 0 ;
32669 PyObject * obj0 = 0 ;
32670 PyObject * obj1 = 0 ;
32671 PyObject * obj2 = 0 ;
32672 char * kwnames[] = {
32673 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32674 };
32675
32676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32678 if (!SWIG_IsOK(res1)) {
32679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32680 }
32681 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32682 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32683 if (!SWIG_IsOK(res2)) {
32684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32685 }
32686 if (obj2) {
32687 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32688 if (!SWIG_IsOK(ecode3)) {
32689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32690 }
32691 arg3 = static_cast< bool >(val3);
32692 }
32693 {
32694 PyThreadState* __tstate = wxPyBeginAllowThreads();
32695 (arg1)->Add(arg2,arg3);
32696 wxPyEndAllowThreads(__tstate);
32697 if (PyErr_Occurred()) SWIG_fail;
32698 }
32699 resultobj = SWIG_Py_Void();
32700 return resultobj;
32701 fail:
32702 return NULL;
32703 }
32704
32705
32706 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32707 PyObject *resultobj = 0;
32708 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32709 SwigValueWrapper<wxDataFormat > result;
32710 void *argp1 = 0 ;
32711 int res1 = 0 ;
32712 PyObject *swig_obj[1] ;
32713
32714 if (!args) SWIG_fail;
32715 swig_obj[0] = args;
32716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32717 if (!SWIG_IsOK(res1)) {
32718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32719 }
32720 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32724 wxPyEndAllowThreads(__tstate);
32725 if (PyErr_Occurred()) SWIG_fail;
32726 }
32727 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32728 return resultobj;
32729 fail:
32730 return NULL;
32731 }
32732
32733
32734 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32735 PyObject *obj;
32736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32737 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32738 return SWIG_Py_Void();
32739 }
32740
32741 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32742 return SWIG_Python_InitShadowInstance(args);
32743 }
32744
32745 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32746 PyObject *resultobj = 0;
32747 wxString const &arg1_defvalue = wxPyEmptyString ;
32748 wxString *arg1 = (wxString *) &arg1_defvalue ;
32749 wxTextDataObject *result = 0 ;
32750 bool temp1 = false ;
32751 PyObject * obj0 = 0 ;
32752 char * kwnames[] = {
32753 (char *) "text", NULL
32754 };
32755
32756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32757 if (obj0) {
32758 {
32759 arg1 = wxString_in_helper(obj0);
32760 if (arg1 == NULL) SWIG_fail;
32761 temp1 = true;
32762 }
32763 }
32764 {
32765 PyThreadState* __tstate = wxPyBeginAllowThreads();
32766 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32767 wxPyEndAllowThreads(__tstate);
32768 if (PyErr_Occurred()) SWIG_fail;
32769 }
32770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32771 {
32772 if (temp1)
32773 delete arg1;
32774 }
32775 return resultobj;
32776 fail:
32777 {
32778 if (temp1)
32779 delete arg1;
32780 }
32781 return NULL;
32782 }
32783
32784
32785 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32786 PyObject *resultobj = 0;
32787 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32788 size_t result;
32789 void *argp1 = 0 ;
32790 int res1 = 0 ;
32791 PyObject *swig_obj[1] ;
32792
32793 if (!args) SWIG_fail;
32794 swig_obj[0] = args;
32795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32796 if (!SWIG_IsOK(res1)) {
32797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32798 }
32799 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32800 {
32801 PyThreadState* __tstate = wxPyBeginAllowThreads();
32802 result = (size_t)(arg1)->GetTextLength();
32803 wxPyEndAllowThreads(__tstate);
32804 if (PyErr_Occurred()) SWIG_fail;
32805 }
32806 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32807 return resultobj;
32808 fail:
32809 return NULL;
32810 }
32811
32812
32813 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32814 PyObject *resultobj = 0;
32815 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32816 wxString result;
32817 void *argp1 = 0 ;
32818 int res1 = 0 ;
32819 PyObject *swig_obj[1] ;
32820
32821 if (!args) SWIG_fail;
32822 swig_obj[0] = args;
32823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32824 if (!SWIG_IsOK(res1)) {
32825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32826 }
32827 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32828 {
32829 PyThreadState* __tstate = wxPyBeginAllowThreads();
32830 result = (arg1)->GetText();
32831 wxPyEndAllowThreads(__tstate);
32832 if (PyErr_Occurred()) SWIG_fail;
32833 }
32834 {
32835 #if wxUSE_UNICODE
32836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32837 #else
32838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32839 #endif
32840 }
32841 return resultobj;
32842 fail:
32843 return NULL;
32844 }
32845
32846
32847 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32848 PyObject *resultobj = 0;
32849 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32850 wxString *arg2 = 0 ;
32851 void *argp1 = 0 ;
32852 int res1 = 0 ;
32853 bool temp2 = false ;
32854 PyObject * obj0 = 0 ;
32855 PyObject * obj1 = 0 ;
32856 char * kwnames[] = {
32857 (char *) "self",(char *) "text", NULL
32858 };
32859
32860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32862 if (!SWIG_IsOK(res1)) {
32863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32864 }
32865 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32866 {
32867 arg2 = wxString_in_helper(obj1);
32868 if (arg2 == NULL) SWIG_fail;
32869 temp2 = true;
32870 }
32871 {
32872 PyThreadState* __tstate = wxPyBeginAllowThreads();
32873 (arg1)->SetText((wxString const &)*arg2);
32874 wxPyEndAllowThreads(__tstate);
32875 if (PyErr_Occurred()) SWIG_fail;
32876 }
32877 resultobj = SWIG_Py_Void();
32878 {
32879 if (temp2)
32880 delete arg2;
32881 }
32882 return resultobj;
32883 fail:
32884 {
32885 if (temp2)
32886 delete arg2;
32887 }
32888 return NULL;
32889 }
32890
32891
32892 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32893 PyObject *obj;
32894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32895 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32896 return SWIG_Py_Void();
32897 }
32898
32899 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32900 return SWIG_Python_InitShadowInstance(args);
32901 }
32902
32903 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32904 PyObject *resultobj = 0;
32905 wxString const &arg1_defvalue = wxPyEmptyString ;
32906 wxString *arg1 = (wxString *) &arg1_defvalue ;
32907 wxPyTextDataObject *result = 0 ;
32908 bool temp1 = false ;
32909 PyObject * obj0 = 0 ;
32910 char * kwnames[] = {
32911 (char *) "text", NULL
32912 };
32913
32914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32915 if (obj0) {
32916 {
32917 arg1 = wxString_in_helper(obj0);
32918 if (arg1 == NULL) SWIG_fail;
32919 temp1 = true;
32920 }
32921 }
32922 {
32923 PyThreadState* __tstate = wxPyBeginAllowThreads();
32924 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32925 wxPyEndAllowThreads(__tstate);
32926 if (PyErr_Occurred()) SWIG_fail;
32927 }
32928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32929 {
32930 if (temp1)
32931 delete arg1;
32932 }
32933 return resultobj;
32934 fail:
32935 {
32936 if (temp1)
32937 delete arg1;
32938 }
32939 return NULL;
32940 }
32941
32942
32943 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32944 PyObject *resultobj = 0;
32945 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32946 PyObject *arg2 = (PyObject *) 0 ;
32947 PyObject *arg3 = (PyObject *) 0 ;
32948 void *argp1 = 0 ;
32949 int res1 = 0 ;
32950 PyObject * obj0 = 0 ;
32951 PyObject * obj1 = 0 ;
32952 PyObject * obj2 = 0 ;
32953 char * kwnames[] = {
32954 (char *) "self",(char *) "self",(char *) "_class", NULL
32955 };
32956
32957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32959 if (!SWIG_IsOK(res1)) {
32960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32961 }
32962 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32963 arg2 = obj1;
32964 arg3 = obj2;
32965 {
32966 PyThreadState* __tstate = wxPyBeginAllowThreads();
32967 (arg1)->_setCallbackInfo(arg2,arg3);
32968 wxPyEndAllowThreads(__tstate);
32969 if (PyErr_Occurred()) SWIG_fail;
32970 }
32971 resultobj = SWIG_Py_Void();
32972 return resultobj;
32973 fail:
32974 return NULL;
32975 }
32976
32977
32978 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32979 PyObject *obj;
32980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32981 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32982 return SWIG_Py_Void();
32983 }
32984
32985 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32986 return SWIG_Python_InitShadowInstance(args);
32987 }
32988
32989 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32990 PyObject *resultobj = 0;
32991 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32992 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32993 wxBitmapDataObject *result = 0 ;
32994 void *argp1 = 0 ;
32995 int res1 = 0 ;
32996 PyObject * obj0 = 0 ;
32997 char * kwnames[] = {
32998 (char *) "bitmap", NULL
32999 };
33000
33001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33002 if (obj0) {
33003 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33004 if (!SWIG_IsOK(res1)) {
33005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33006 }
33007 if (!argp1) {
33008 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33009 }
33010 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33011 }
33012 {
33013 PyThreadState* __tstate = wxPyBeginAllowThreads();
33014 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33015 wxPyEndAllowThreads(__tstate);
33016 if (PyErr_Occurred()) SWIG_fail;
33017 }
33018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33019 return resultobj;
33020 fail:
33021 return NULL;
33022 }
33023
33024
33025 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33026 PyObject *resultobj = 0;
33027 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33028 wxBitmap result;
33029 void *argp1 = 0 ;
33030 int res1 = 0 ;
33031 PyObject *swig_obj[1] ;
33032
33033 if (!args) SWIG_fail;
33034 swig_obj[0] = args;
33035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33036 if (!SWIG_IsOK(res1)) {
33037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33038 }
33039 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33047 return resultobj;
33048 fail:
33049 return NULL;
33050 }
33051
33052
33053 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33054 PyObject *resultobj = 0;
33055 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33056 wxBitmap *arg2 = 0 ;
33057 void *argp1 = 0 ;
33058 int res1 = 0 ;
33059 void *argp2 = 0 ;
33060 int res2 = 0 ;
33061 PyObject * obj0 = 0 ;
33062 PyObject * obj1 = 0 ;
33063 char * kwnames[] = {
33064 (char *) "self",(char *) "bitmap", NULL
33065 };
33066
33067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33069 if (!SWIG_IsOK(res1)) {
33070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33071 }
33072 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33073 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33074 if (!SWIG_IsOK(res2)) {
33075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33076 }
33077 if (!argp2) {
33078 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33079 }
33080 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33081 {
33082 PyThreadState* __tstate = wxPyBeginAllowThreads();
33083 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 resultobj = SWIG_Py_Void();
33088 return resultobj;
33089 fail:
33090 return NULL;
33091 }
33092
33093
33094 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33095 PyObject *obj;
33096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33097 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33098 return SWIG_Py_Void();
33099 }
33100
33101 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33102 return SWIG_Python_InitShadowInstance(args);
33103 }
33104
33105 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33106 PyObject *resultobj = 0;
33107 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33108 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33109 wxPyBitmapDataObject *result = 0 ;
33110 void *argp1 = 0 ;
33111 int res1 = 0 ;
33112 PyObject * obj0 = 0 ;
33113 char * kwnames[] = {
33114 (char *) "bitmap", NULL
33115 };
33116
33117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33118 if (obj0) {
33119 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33120 if (!SWIG_IsOK(res1)) {
33121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33122 }
33123 if (!argp1) {
33124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33125 }
33126 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33127 }
33128 {
33129 PyThreadState* __tstate = wxPyBeginAllowThreads();
33130 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33131 wxPyEndAllowThreads(__tstate);
33132 if (PyErr_Occurred()) SWIG_fail;
33133 }
33134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33135 return resultobj;
33136 fail:
33137 return NULL;
33138 }
33139
33140
33141 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33142 PyObject *resultobj = 0;
33143 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33144 PyObject *arg2 = (PyObject *) 0 ;
33145 PyObject *arg3 = (PyObject *) 0 ;
33146 void *argp1 = 0 ;
33147 int res1 = 0 ;
33148 PyObject * obj0 = 0 ;
33149 PyObject * obj1 = 0 ;
33150 PyObject * obj2 = 0 ;
33151 char * kwnames[] = {
33152 (char *) "self",(char *) "self",(char *) "_class", NULL
33153 };
33154
33155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33157 if (!SWIG_IsOK(res1)) {
33158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33159 }
33160 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33161 arg2 = obj1;
33162 arg3 = obj2;
33163 {
33164 PyThreadState* __tstate = wxPyBeginAllowThreads();
33165 (arg1)->_setCallbackInfo(arg2,arg3);
33166 wxPyEndAllowThreads(__tstate);
33167 if (PyErr_Occurred()) SWIG_fail;
33168 }
33169 resultobj = SWIG_Py_Void();
33170 return resultobj;
33171 fail:
33172 return NULL;
33173 }
33174
33175
33176 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33177 PyObject *obj;
33178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33179 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33180 return SWIG_Py_Void();
33181 }
33182
33183 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33184 return SWIG_Python_InitShadowInstance(args);
33185 }
33186
33187 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33188 PyObject *resultobj = 0;
33189 wxFileDataObject *result = 0 ;
33190
33191 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33192 {
33193 PyThreadState* __tstate = wxPyBeginAllowThreads();
33194 result = (wxFileDataObject *)new wxFileDataObject();
33195 wxPyEndAllowThreads(__tstate);
33196 if (PyErr_Occurred()) SWIG_fail;
33197 }
33198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33199 return resultobj;
33200 fail:
33201 return NULL;
33202 }
33203
33204
33205 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33206 PyObject *resultobj = 0;
33207 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33208 wxArrayString *result = 0 ;
33209 void *argp1 = 0 ;
33210 int res1 = 0 ;
33211 PyObject *swig_obj[1] ;
33212
33213 if (!args) SWIG_fail;
33214 swig_obj[0] = args;
33215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33216 if (!SWIG_IsOK(res1)) {
33217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33218 }
33219 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33220 {
33221 PyThreadState* __tstate = wxPyBeginAllowThreads();
33222 {
33223 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33224 result = (wxArrayString *) &_result_ref;
33225 }
33226 wxPyEndAllowThreads(__tstate);
33227 if (PyErr_Occurred()) SWIG_fail;
33228 }
33229 {
33230 resultobj = wxArrayString2PyList_helper(*result);
33231 }
33232 return resultobj;
33233 fail:
33234 return NULL;
33235 }
33236
33237
33238 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33239 PyObject *resultobj = 0;
33240 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33241 wxString *arg2 = 0 ;
33242 void *argp1 = 0 ;
33243 int res1 = 0 ;
33244 bool temp2 = false ;
33245 PyObject * obj0 = 0 ;
33246 PyObject * obj1 = 0 ;
33247 char * kwnames[] = {
33248 (char *) "self",(char *) "filename", NULL
33249 };
33250
33251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33253 if (!SWIG_IsOK(res1)) {
33254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33255 }
33256 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33257 {
33258 arg2 = wxString_in_helper(obj1);
33259 if (arg2 == NULL) SWIG_fail;
33260 temp2 = true;
33261 }
33262 {
33263 PyThreadState* __tstate = wxPyBeginAllowThreads();
33264 (arg1)->AddFile((wxString const &)*arg2);
33265 wxPyEndAllowThreads(__tstate);
33266 if (PyErr_Occurred()) SWIG_fail;
33267 }
33268 resultobj = SWIG_Py_Void();
33269 {
33270 if (temp2)
33271 delete arg2;
33272 }
33273 return resultobj;
33274 fail:
33275 {
33276 if (temp2)
33277 delete arg2;
33278 }
33279 return NULL;
33280 }
33281
33282
33283 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33284 PyObject *obj;
33285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33286 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33287 return SWIG_Py_Void();
33288 }
33289
33290 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33291 return SWIG_Python_InitShadowInstance(args);
33292 }
33293
33294 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33295 PyObject *resultobj = 0;
33296 wxDataFormat *arg1 = 0 ;
33297 wxCustomDataObject *result = 0 ;
33298 void *argp1 = 0 ;
33299 int res1 = 0 ;
33300
33301 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33303 if (!SWIG_IsOK(res1)) {
33304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33305 }
33306 if (!argp1) {
33307 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33308 }
33309 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33310 {
33311 PyThreadState* __tstate = wxPyBeginAllowThreads();
33312 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33313 wxPyEndAllowThreads(__tstate);
33314 if (PyErr_Occurred()) SWIG_fail;
33315 }
33316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33317 return resultobj;
33318 fail:
33319 return NULL;
33320 }
33321
33322
33323 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33324 PyObject *resultobj = 0;
33325 wxString *arg1 = 0 ;
33326 wxCustomDataObject *result = 0 ;
33327 bool temp1 = false ;
33328
33329 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33330 {
33331 arg1 = wxString_in_helper(swig_obj[0]);
33332 if (arg1 == NULL) SWIG_fail;
33333 temp1 = true;
33334 }
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33342 {
33343 if (temp1)
33344 delete arg1;
33345 }
33346 return resultobj;
33347 fail:
33348 {
33349 if (temp1)
33350 delete arg1;
33351 }
33352 return NULL;
33353 }
33354
33355
33356 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33357 PyObject *resultobj = 0;
33358 wxCustomDataObject *result = 0 ;
33359
33360 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33361 {
33362 PyThreadState* __tstate = wxPyBeginAllowThreads();
33363 result = (wxCustomDataObject *)new wxCustomDataObject();
33364 wxPyEndAllowThreads(__tstate);
33365 if (PyErr_Occurred()) SWIG_fail;
33366 }
33367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33368 return resultobj;
33369 fail:
33370 return NULL;
33371 }
33372
33373
33374 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33375 int argc;
33376 PyObject *argv[2];
33377
33378 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33379 --argc;
33380 if (argc == 0) {
33381 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33382 }
33383 if (argc == 1) {
33384 int _v = 0;
33385 {
33386 {
33387 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33388 }
33389 }
33390 if (!_v) goto check_2;
33391 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33392 }
33393 check_2:
33394
33395 if (argc == 1) {
33396 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33397 }
33398
33399 fail:
33400 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33401 return NULL;
33402 }
33403
33404
33405 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33406 PyObject *resultobj = 0;
33407 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33408 PyObject *arg2 = (PyObject *) 0 ;
33409 bool result;
33410 void *argp1 = 0 ;
33411 int res1 = 0 ;
33412 PyObject * obj0 = 0 ;
33413 PyObject * obj1 = 0 ;
33414 char * kwnames[] = {
33415 (char *) "self",(char *) "data", NULL
33416 };
33417
33418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33420 if (!SWIG_IsOK(res1)) {
33421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33422 }
33423 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33424 arg2 = obj1;
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 {
33432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33433 }
33434 return resultobj;
33435 fail:
33436 return NULL;
33437 }
33438
33439
33440 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33441 PyObject *resultobj = 0;
33442 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33443 size_t result;
33444 void *argp1 = 0 ;
33445 int res1 = 0 ;
33446 PyObject *swig_obj[1] ;
33447
33448 if (!args) SWIG_fail;
33449 swig_obj[0] = args;
33450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33451 if (!SWIG_IsOK(res1)) {
33452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33453 }
33454 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33455 {
33456 PyThreadState* __tstate = wxPyBeginAllowThreads();
33457 result = (size_t)(arg1)->GetSize();
33458 wxPyEndAllowThreads(__tstate);
33459 if (PyErr_Occurred()) SWIG_fail;
33460 }
33461 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33462 return resultobj;
33463 fail:
33464 return NULL;
33465 }
33466
33467
33468 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33469 PyObject *resultobj = 0;
33470 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33471 PyObject *result = 0 ;
33472 void *argp1 = 0 ;
33473 int res1 = 0 ;
33474 PyObject *swig_obj[1] ;
33475
33476 if (!args) SWIG_fail;
33477 swig_obj[0] = args;
33478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33479 if (!SWIG_IsOK(res1)) {
33480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33481 }
33482 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33483 {
33484 PyThreadState* __tstate = wxPyBeginAllowThreads();
33485 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33486 wxPyEndAllowThreads(__tstate);
33487 if (PyErr_Occurred()) SWIG_fail;
33488 }
33489 resultobj = result;
33490 return resultobj;
33491 fail:
33492 return NULL;
33493 }
33494
33495
33496 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33497 PyObject *obj;
33498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33499 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33500 return SWIG_Py_Void();
33501 }
33502
33503 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33504 return SWIG_Python_InitShadowInstance(args);
33505 }
33506
33507 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33508 PyObject *resultobj = 0;
33509 wxString const &arg1_defvalue = wxPyEmptyString ;
33510 wxString *arg1 = (wxString *) &arg1_defvalue ;
33511 wxURLDataObject *result = 0 ;
33512 bool temp1 = false ;
33513 PyObject * obj0 = 0 ;
33514 char * kwnames[] = {
33515 (char *) "url", NULL
33516 };
33517
33518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33519 if (obj0) {
33520 {
33521 arg1 = wxString_in_helper(obj0);
33522 if (arg1 == NULL) SWIG_fail;
33523 temp1 = true;
33524 }
33525 }
33526 {
33527 PyThreadState* __tstate = wxPyBeginAllowThreads();
33528 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33529 wxPyEndAllowThreads(__tstate);
33530 if (PyErr_Occurred()) SWIG_fail;
33531 }
33532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33533 {
33534 if (temp1)
33535 delete arg1;
33536 }
33537 return resultobj;
33538 fail:
33539 {
33540 if (temp1)
33541 delete arg1;
33542 }
33543 return NULL;
33544 }
33545
33546
33547 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33548 PyObject *resultobj = 0;
33549 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33550 wxString result;
33551 void *argp1 = 0 ;
33552 int res1 = 0 ;
33553 PyObject *swig_obj[1] ;
33554
33555 if (!args) SWIG_fail;
33556 swig_obj[0] = args;
33557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33558 if (!SWIG_IsOK(res1)) {
33559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33560 }
33561 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33562 {
33563 PyThreadState* __tstate = wxPyBeginAllowThreads();
33564 result = (arg1)->GetURL();
33565 wxPyEndAllowThreads(__tstate);
33566 if (PyErr_Occurred()) SWIG_fail;
33567 }
33568 {
33569 #if wxUSE_UNICODE
33570 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33571 #else
33572 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33573 #endif
33574 }
33575 return resultobj;
33576 fail:
33577 return NULL;
33578 }
33579
33580
33581 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33582 PyObject *resultobj = 0;
33583 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33584 wxString *arg2 = 0 ;
33585 void *argp1 = 0 ;
33586 int res1 = 0 ;
33587 bool temp2 = false ;
33588 PyObject * obj0 = 0 ;
33589 PyObject * obj1 = 0 ;
33590 char * kwnames[] = {
33591 (char *) "self",(char *) "url", NULL
33592 };
33593
33594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33596 if (!SWIG_IsOK(res1)) {
33597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33598 }
33599 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33600 {
33601 arg2 = wxString_in_helper(obj1);
33602 if (arg2 == NULL) SWIG_fail;
33603 temp2 = true;
33604 }
33605 {
33606 PyThreadState* __tstate = wxPyBeginAllowThreads();
33607 (arg1)->SetURL((wxString const &)*arg2);
33608 wxPyEndAllowThreads(__tstate);
33609 if (PyErr_Occurred()) SWIG_fail;
33610 }
33611 resultobj = SWIG_Py_Void();
33612 {
33613 if (temp2)
33614 delete arg2;
33615 }
33616 return resultobj;
33617 fail:
33618 {
33619 if (temp2)
33620 delete arg2;
33621 }
33622 return NULL;
33623 }
33624
33625
33626 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33627 PyObject *obj;
33628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33629 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33630 return SWIG_Py_Void();
33631 }
33632
33633 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33634 return SWIG_Python_InitShadowInstance(args);
33635 }
33636
33637 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33638 PyObject *resultobj = 0;
33639 wxMetafileDataObject *result = 0 ;
33640
33641 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33649 return resultobj;
33650 fail:
33651 return NULL;
33652 }
33653
33654
33655 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33656 PyObject *resultobj = 0;
33657 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33658 wxMetafile *arg2 = 0 ;
33659 void *argp1 = 0 ;
33660 int res1 = 0 ;
33661 void *argp2 = 0 ;
33662 int res2 = 0 ;
33663 PyObject * obj0 = 0 ;
33664 PyObject * obj1 = 0 ;
33665 char * kwnames[] = {
33666 (char *) "self",(char *) "metafile", NULL
33667 };
33668
33669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33671 if (!SWIG_IsOK(res1)) {
33672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33673 }
33674 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33675 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33676 if (!SWIG_IsOK(res2)) {
33677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33678 }
33679 if (!argp2) {
33680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33681 }
33682 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33683 {
33684 PyThreadState* __tstate = wxPyBeginAllowThreads();
33685 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33686 wxPyEndAllowThreads(__tstate);
33687 if (PyErr_Occurred()) SWIG_fail;
33688 }
33689 resultobj = SWIG_Py_Void();
33690 return resultobj;
33691 fail:
33692 return NULL;
33693 }
33694
33695
33696 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33697 PyObject *resultobj = 0;
33698 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33699 wxMetafile result;
33700 void *argp1 = 0 ;
33701 int res1 = 0 ;
33702 PyObject *swig_obj[1] ;
33703
33704 if (!args) SWIG_fail;
33705 swig_obj[0] = args;
33706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33707 if (!SWIG_IsOK(res1)) {
33708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33709 }
33710 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33711 {
33712 PyThreadState* __tstate = wxPyBeginAllowThreads();
33713 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33714 wxPyEndAllowThreads(__tstate);
33715 if (PyErr_Occurred()) SWIG_fail;
33716 }
33717 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33718 return resultobj;
33719 fail:
33720 return NULL;
33721 }
33722
33723
33724 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33725 PyObject *obj;
33726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33727 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33728 return SWIG_Py_Void();
33729 }
33730
33731 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33732 return SWIG_Python_InitShadowInstance(args);
33733 }
33734
33735 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33736 PyObject *resultobj = 0;
33737 wxDragResult arg1 ;
33738 bool result;
33739 int val1 ;
33740 int ecode1 = 0 ;
33741 PyObject * obj0 = 0 ;
33742 char * kwnames[] = {
33743 (char *) "res", NULL
33744 };
33745
33746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33747 ecode1 = SWIG_AsVal_int(obj0, &val1);
33748 if (!SWIG_IsOK(ecode1)) {
33749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33750 }
33751 arg1 = static_cast< wxDragResult >(val1);
33752 {
33753 PyThreadState* __tstate = wxPyBeginAllowThreads();
33754 result = (bool)wxIsDragResultOk(arg1);
33755 wxPyEndAllowThreads(__tstate);
33756 if (PyErr_Occurred()) SWIG_fail;
33757 }
33758 {
33759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33760 }
33761 return resultobj;
33762 fail:
33763 return NULL;
33764 }
33765
33766
33767 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33768 PyObject *resultobj = 0;
33769 wxWindow *arg1 = (wxWindow *) 0 ;
33770 wxCursor const &arg2_defvalue = wxNullCursor ;
33771 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33772 wxCursor const &arg3_defvalue = wxNullCursor ;
33773 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33774 wxCursor const &arg4_defvalue = wxNullCursor ;
33775 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33776 wxPyDropSource *result = 0 ;
33777 void *argp1 = 0 ;
33778 int res1 = 0 ;
33779 void *argp2 = 0 ;
33780 int res2 = 0 ;
33781 void *argp3 = 0 ;
33782 int res3 = 0 ;
33783 void *argp4 = 0 ;
33784 int res4 = 0 ;
33785 PyObject * obj0 = 0 ;
33786 PyObject * obj1 = 0 ;
33787 PyObject * obj2 = 0 ;
33788 PyObject * obj3 = 0 ;
33789 char * kwnames[] = {
33790 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33791 };
33792
33793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33795 if (!SWIG_IsOK(res1)) {
33796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33797 }
33798 arg1 = reinterpret_cast< wxWindow * >(argp1);
33799 if (obj1) {
33800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33801 if (!SWIG_IsOK(res2)) {
33802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33803 }
33804 if (!argp2) {
33805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33806 }
33807 arg2 = reinterpret_cast< wxCursor * >(argp2);
33808 }
33809 if (obj2) {
33810 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33811 if (!SWIG_IsOK(res3)) {
33812 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33813 }
33814 if (!argp3) {
33815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33816 }
33817 arg3 = reinterpret_cast< wxCursor * >(argp3);
33818 }
33819 if (obj3) {
33820 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33821 if (!SWIG_IsOK(res4)) {
33822 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33823 }
33824 if (!argp4) {
33825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33826 }
33827 arg4 = reinterpret_cast< wxCursor * >(argp4);
33828 }
33829 {
33830 PyThreadState* __tstate = wxPyBeginAllowThreads();
33831 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33832 wxPyEndAllowThreads(__tstate);
33833 if (PyErr_Occurred()) SWIG_fail;
33834 }
33835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33836 return resultobj;
33837 fail:
33838 return NULL;
33839 }
33840
33841
33842 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33843 PyObject *resultobj = 0;
33844 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33845 PyObject *arg2 = (PyObject *) 0 ;
33846 PyObject *arg3 = (PyObject *) 0 ;
33847 int arg4 ;
33848 void *argp1 = 0 ;
33849 int res1 = 0 ;
33850 int val4 ;
33851 int ecode4 = 0 ;
33852 PyObject * obj0 = 0 ;
33853 PyObject * obj1 = 0 ;
33854 PyObject * obj2 = 0 ;
33855 PyObject * obj3 = 0 ;
33856 char * kwnames[] = {
33857 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33858 };
33859
33860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33862 if (!SWIG_IsOK(res1)) {
33863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33864 }
33865 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33866 arg2 = obj1;
33867 arg3 = obj2;
33868 ecode4 = SWIG_AsVal_int(obj3, &val4);
33869 if (!SWIG_IsOK(ecode4)) {
33870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33871 }
33872 arg4 = static_cast< int >(val4);
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33876 wxPyEndAllowThreads(__tstate);
33877 if (PyErr_Occurred()) SWIG_fail;
33878 }
33879 resultobj = SWIG_Py_Void();
33880 return resultobj;
33881 fail:
33882 return NULL;
33883 }
33884
33885
33886 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33887 PyObject *resultobj = 0;
33888 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33889 void *argp1 = 0 ;
33890 int res1 = 0 ;
33891 PyObject *swig_obj[1] ;
33892
33893 if (!args) SWIG_fail;
33894 swig_obj[0] = args;
33895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33896 if (!SWIG_IsOK(res1)) {
33897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33898 }
33899 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 delete arg1;
33903
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 resultobj = SWIG_Py_Void();
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj = 0;
33916 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33917 wxDataObject *arg2 = 0 ;
33918 void *argp1 = 0 ;
33919 int res1 = 0 ;
33920 void *argp2 = 0 ;
33921 int res2 = 0 ;
33922 PyObject * obj0 = 0 ;
33923 PyObject * obj1 = 0 ;
33924 char * kwnames[] = {
33925 (char *) "self",(char *) "data", NULL
33926 };
33927
33928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33930 if (!SWIG_IsOK(res1)) {
33931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33932 }
33933 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33935 if (!SWIG_IsOK(res2)) {
33936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33937 }
33938 if (!argp2) {
33939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33940 }
33941 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33942 {
33943 PyThreadState* __tstate = wxPyBeginAllowThreads();
33944 (arg1)->SetData(*arg2);
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 resultobj = SWIG_Py_Void();
33949 return resultobj;
33950 fail:
33951 return NULL;
33952 }
33953
33954
33955 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33956 PyObject *resultobj = 0;
33957 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33958 wxDataObject *result = 0 ;
33959 void *argp1 = 0 ;
33960 int res1 = 0 ;
33961 PyObject *swig_obj[1] ;
33962
33963 if (!args) SWIG_fail;
33964 swig_obj[0] = args;
33965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33966 if (!SWIG_IsOK(res1)) {
33967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33968 }
33969 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 result = (wxDataObject *)(arg1)->GetDataObject();
33973 wxPyEndAllowThreads(__tstate);
33974 if (PyErr_Occurred()) SWIG_fail;
33975 }
33976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33977 return resultobj;
33978 fail:
33979 return NULL;
33980 }
33981
33982
33983 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33984 PyObject *resultobj = 0;
33985 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33986 wxDragResult arg2 ;
33987 wxCursor *arg3 = 0 ;
33988 void *argp1 = 0 ;
33989 int res1 = 0 ;
33990 int val2 ;
33991 int ecode2 = 0 ;
33992 void *argp3 = 0 ;
33993 int res3 = 0 ;
33994 PyObject * obj0 = 0 ;
33995 PyObject * obj1 = 0 ;
33996 PyObject * obj2 = 0 ;
33997 char * kwnames[] = {
33998 (char *) "self",(char *) "res",(char *) "cursor", NULL
33999 };
34000
34001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34003 if (!SWIG_IsOK(res1)) {
34004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34005 }
34006 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34007 ecode2 = SWIG_AsVal_int(obj1, &val2);
34008 if (!SWIG_IsOK(ecode2)) {
34009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34010 }
34011 arg2 = static_cast< wxDragResult >(val2);
34012 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34013 if (!SWIG_IsOK(res3)) {
34014 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34015 }
34016 if (!argp3) {
34017 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34018 }
34019 arg3 = reinterpret_cast< wxCursor * >(argp3);
34020 {
34021 PyThreadState* __tstate = wxPyBeginAllowThreads();
34022 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34023 wxPyEndAllowThreads(__tstate);
34024 if (PyErr_Occurred()) SWIG_fail;
34025 }
34026 resultobj = SWIG_Py_Void();
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34034 PyObject *resultobj = 0;
34035 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34036 int arg2 = (int) wxDrag_CopyOnly ;
34037 wxDragResult result;
34038 void *argp1 = 0 ;
34039 int res1 = 0 ;
34040 int val2 ;
34041 int ecode2 = 0 ;
34042 PyObject * obj0 = 0 ;
34043 PyObject * obj1 = 0 ;
34044 char * kwnames[] = {
34045 (char *) "self",(char *) "flags", NULL
34046 };
34047
34048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34050 if (!SWIG_IsOK(res1)) {
34051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34052 }
34053 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34054 if (obj1) {
34055 ecode2 = SWIG_AsVal_int(obj1, &val2);
34056 if (!SWIG_IsOK(ecode2)) {
34057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34058 }
34059 arg2 = static_cast< int >(val2);
34060 }
34061 {
34062 PyThreadState* __tstate = wxPyBeginAllowThreads();
34063 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34064 wxPyEndAllowThreads(__tstate);
34065 if (PyErr_Occurred()) SWIG_fail;
34066 }
34067 resultobj = SWIG_From_int(static_cast< int >(result));
34068 return resultobj;
34069 fail:
34070 return NULL;
34071 }
34072
34073
34074 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34075 PyObject *resultobj = 0;
34076 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34077 wxDragResult arg2 ;
34078 bool result;
34079 void *argp1 = 0 ;
34080 int res1 = 0 ;
34081 int val2 ;
34082 int ecode2 = 0 ;
34083 PyObject * obj0 = 0 ;
34084 PyObject * obj1 = 0 ;
34085 char * kwnames[] = {
34086 (char *) "self",(char *) "effect", NULL
34087 };
34088
34089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34091 if (!SWIG_IsOK(res1)) {
34092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34093 }
34094 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34095 ecode2 = SWIG_AsVal_int(obj1, &val2);
34096 if (!SWIG_IsOK(ecode2)) {
34097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34098 }
34099 arg2 = static_cast< wxDragResult >(val2);
34100 {
34101 PyThreadState* __tstate = wxPyBeginAllowThreads();
34102 result = (bool)(arg1)->GiveFeedback(arg2);
34103 wxPyEndAllowThreads(__tstate);
34104 if (PyErr_Occurred()) SWIG_fail;
34105 }
34106 {
34107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34108 }
34109 return resultobj;
34110 fail:
34111 return NULL;
34112 }
34113
34114
34115 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34116 PyObject *obj;
34117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34118 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34119 return SWIG_Py_Void();
34120 }
34121
34122 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34123 return SWIG_Python_InitShadowInstance(args);
34124 }
34125
34126 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34127 PyObject *resultobj = 0;
34128 wxDataObject *arg1 = (wxDataObject *) NULL ;
34129 wxPyDropTarget *result = 0 ;
34130 int res1 = 0 ;
34131 PyObject * obj0 = 0 ;
34132 char * kwnames[] = {
34133 (char *) "dataObject", NULL
34134 };
34135
34136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34137 if (obj0) {
34138 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34139 if (!SWIG_IsOK(res1)) {
34140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34141 }
34142 }
34143 {
34144 PyThreadState* __tstate = wxPyBeginAllowThreads();
34145 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34146 wxPyEndAllowThreads(__tstate);
34147 if (PyErr_Occurred()) SWIG_fail;
34148 }
34149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34150 return resultobj;
34151 fail:
34152 return NULL;
34153 }
34154
34155
34156 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34157 PyObject *resultobj = 0;
34158 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34159 PyObject *arg2 = (PyObject *) 0 ;
34160 PyObject *arg3 = (PyObject *) 0 ;
34161 void *argp1 = 0 ;
34162 int res1 = 0 ;
34163 PyObject * obj0 = 0 ;
34164 PyObject * obj1 = 0 ;
34165 PyObject * obj2 = 0 ;
34166 char * kwnames[] = {
34167 (char *) "self",(char *) "self",(char *) "_class", NULL
34168 };
34169
34170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34172 if (!SWIG_IsOK(res1)) {
34173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34174 }
34175 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34176 arg2 = obj1;
34177 arg3 = obj2;
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 (arg1)->_setCallbackInfo(arg2,arg3);
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 resultobj = SWIG_Py_Void();
34185 return resultobj;
34186 fail:
34187 return NULL;
34188 }
34189
34190
34191 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34192 PyObject *resultobj = 0;
34193 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34194 void *argp1 = 0 ;
34195 int res1 = 0 ;
34196 PyObject *swig_obj[1] ;
34197
34198 if (!args) SWIG_fail;
34199 swig_obj[0] = args;
34200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34201 if (!SWIG_IsOK(res1)) {
34202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34203 }
34204 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34205 {
34206 PyThreadState* __tstate = wxPyBeginAllowThreads();
34207 delete arg1;
34208
34209 wxPyEndAllowThreads(__tstate);
34210 if (PyErr_Occurred()) SWIG_fail;
34211 }
34212 resultobj = SWIG_Py_Void();
34213 return resultobj;
34214 fail:
34215 return NULL;
34216 }
34217
34218
34219 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34220 PyObject *resultobj = 0;
34221 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34222 wxDataObject *result = 0 ;
34223 void *argp1 = 0 ;
34224 int res1 = 0 ;
34225 PyObject *swig_obj[1] ;
34226
34227 if (!args) SWIG_fail;
34228 swig_obj[0] = args;
34229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34230 if (!SWIG_IsOK(res1)) {
34231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34232 }
34233 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34234 {
34235 PyThreadState* __tstate = wxPyBeginAllowThreads();
34236 result = (wxDataObject *)(arg1)->GetDataObject();
34237 wxPyEndAllowThreads(__tstate);
34238 if (PyErr_Occurred()) SWIG_fail;
34239 }
34240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34241 return resultobj;
34242 fail:
34243 return NULL;
34244 }
34245
34246
34247 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34248 PyObject *resultobj = 0;
34249 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34250 wxDataObject *arg2 = (wxDataObject *) 0 ;
34251 void *argp1 = 0 ;
34252 int res1 = 0 ;
34253 int res2 = 0 ;
34254 PyObject * obj0 = 0 ;
34255 PyObject * obj1 = 0 ;
34256 char * kwnames[] = {
34257 (char *) "self",(char *) "dataObject", NULL
34258 };
34259
34260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34262 if (!SWIG_IsOK(res1)) {
34263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34264 }
34265 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34266 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34267 if (!SWIG_IsOK(res2)) {
34268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34269 }
34270 {
34271 PyThreadState* __tstate = wxPyBeginAllowThreads();
34272 (arg1)->SetDataObject(arg2);
34273 wxPyEndAllowThreads(__tstate);
34274 if (PyErr_Occurred()) SWIG_fail;
34275 }
34276 resultobj = SWIG_Py_Void();
34277 return resultobj;
34278 fail:
34279 return NULL;
34280 }
34281
34282
34283 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34284 PyObject *resultobj = 0;
34285 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34286 int arg2 ;
34287 int arg3 ;
34288 wxDragResult arg4 ;
34289 wxDragResult result;
34290 void *argp1 = 0 ;
34291 int res1 = 0 ;
34292 int val2 ;
34293 int ecode2 = 0 ;
34294 int val3 ;
34295 int ecode3 = 0 ;
34296 int val4 ;
34297 int ecode4 = 0 ;
34298 PyObject * obj0 = 0 ;
34299 PyObject * obj1 = 0 ;
34300 PyObject * obj2 = 0 ;
34301 PyObject * obj3 = 0 ;
34302 char * kwnames[] = {
34303 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34304 };
34305
34306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34308 if (!SWIG_IsOK(res1)) {
34309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34310 }
34311 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34312 ecode2 = SWIG_AsVal_int(obj1, &val2);
34313 if (!SWIG_IsOK(ecode2)) {
34314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34315 }
34316 arg2 = static_cast< int >(val2);
34317 ecode3 = SWIG_AsVal_int(obj2, &val3);
34318 if (!SWIG_IsOK(ecode3)) {
34319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34320 }
34321 arg3 = static_cast< int >(val3);
34322 ecode4 = SWIG_AsVal_int(obj3, &val4);
34323 if (!SWIG_IsOK(ecode4)) {
34324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34325 }
34326 arg4 = static_cast< wxDragResult >(val4);
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 resultobj = SWIG_From_int(static_cast< int >(result));
34334 return resultobj;
34335 fail:
34336 return NULL;
34337 }
34338
34339
34340 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34341 PyObject *resultobj = 0;
34342 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34343 int arg2 ;
34344 int arg3 ;
34345 wxDragResult arg4 ;
34346 wxDragResult result;
34347 void *argp1 = 0 ;
34348 int res1 = 0 ;
34349 int val2 ;
34350 int ecode2 = 0 ;
34351 int val3 ;
34352 int ecode3 = 0 ;
34353 int val4 ;
34354 int ecode4 = 0 ;
34355 PyObject * obj0 = 0 ;
34356 PyObject * obj1 = 0 ;
34357 PyObject * obj2 = 0 ;
34358 PyObject * obj3 = 0 ;
34359 char * kwnames[] = {
34360 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34361 };
34362
34363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34365 if (!SWIG_IsOK(res1)) {
34366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34367 }
34368 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34369 ecode2 = SWIG_AsVal_int(obj1, &val2);
34370 if (!SWIG_IsOK(ecode2)) {
34371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34372 }
34373 arg2 = static_cast< int >(val2);
34374 ecode3 = SWIG_AsVal_int(obj2, &val3);
34375 if (!SWIG_IsOK(ecode3)) {
34376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34377 }
34378 arg3 = static_cast< int >(val3);
34379 ecode4 = SWIG_AsVal_int(obj3, &val4);
34380 if (!SWIG_IsOK(ecode4)) {
34381 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34382 }
34383 arg4 = static_cast< wxDragResult >(val4);
34384 {
34385 PyThreadState* __tstate = wxPyBeginAllowThreads();
34386 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34387 wxPyEndAllowThreads(__tstate);
34388 if (PyErr_Occurred()) SWIG_fail;
34389 }
34390 resultobj = SWIG_From_int(static_cast< int >(result));
34391 return resultobj;
34392 fail:
34393 return NULL;
34394 }
34395
34396
34397 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34398 PyObject *resultobj = 0;
34399 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34400 void *argp1 = 0 ;
34401 int res1 = 0 ;
34402 PyObject *swig_obj[1] ;
34403
34404 if (!args) SWIG_fail;
34405 swig_obj[0] = args;
34406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34407 if (!SWIG_IsOK(res1)) {
34408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34409 }
34410 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34411 {
34412 PyThreadState* __tstate = wxPyBeginAllowThreads();
34413 (arg1)->OnLeave();
34414 wxPyEndAllowThreads(__tstate);
34415 if (PyErr_Occurred()) SWIG_fail;
34416 }
34417 resultobj = SWIG_Py_Void();
34418 return resultobj;
34419 fail:
34420 return NULL;
34421 }
34422
34423
34424 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34425 PyObject *resultobj = 0;
34426 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34427 int arg2 ;
34428 int arg3 ;
34429 bool result;
34430 void *argp1 = 0 ;
34431 int res1 = 0 ;
34432 int val2 ;
34433 int ecode2 = 0 ;
34434 int val3 ;
34435 int ecode3 = 0 ;
34436 PyObject * obj0 = 0 ;
34437 PyObject * obj1 = 0 ;
34438 PyObject * obj2 = 0 ;
34439 char * kwnames[] = {
34440 (char *) "self",(char *) "x",(char *) "y", NULL
34441 };
34442
34443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34445 if (!SWIG_IsOK(res1)) {
34446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34447 }
34448 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34449 ecode2 = SWIG_AsVal_int(obj1, &val2);
34450 if (!SWIG_IsOK(ecode2)) {
34451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34452 }
34453 arg2 = static_cast< int >(val2);
34454 ecode3 = SWIG_AsVal_int(obj2, &val3);
34455 if (!SWIG_IsOK(ecode3)) {
34456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34457 }
34458 arg3 = static_cast< int >(val3);
34459 {
34460 PyThreadState* __tstate = wxPyBeginAllowThreads();
34461 result = (bool)(arg1)->OnDrop(arg2,arg3);
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 {
34466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34467 }
34468 return resultobj;
34469 fail:
34470 return NULL;
34471 }
34472
34473
34474 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34475 PyObject *resultobj = 0;
34476 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34477 bool result;
34478 void *argp1 = 0 ;
34479 int res1 = 0 ;
34480 PyObject *swig_obj[1] ;
34481
34482 if (!args) SWIG_fail;
34483 swig_obj[0] = args;
34484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34485 if (!SWIG_IsOK(res1)) {
34486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34487 }
34488 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34489 {
34490 PyThreadState* __tstate = wxPyBeginAllowThreads();
34491 result = (bool)(arg1)->GetData();
34492 wxPyEndAllowThreads(__tstate);
34493 if (PyErr_Occurred()) SWIG_fail;
34494 }
34495 {
34496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34497 }
34498 return resultobj;
34499 fail:
34500 return NULL;
34501 }
34502
34503
34504 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34505 PyObject *resultobj = 0;
34506 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34507 wxDragResult arg2 ;
34508 void *argp1 = 0 ;
34509 int res1 = 0 ;
34510 int val2 ;
34511 int ecode2 = 0 ;
34512 PyObject * obj0 = 0 ;
34513 PyObject * obj1 = 0 ;
34514 char * kwnames[] = {
34515 (char *) "self",(char *) "action", NULL
34516 };
34517
34518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34520 if (!SWIG_IsOK(res1)) {
34521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34522 }
34523 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34524 ecode2 = SWIG_AsVal_int(obj1, &val2);
34525 if (!SWIG_IsOK(ecode2)) {
34526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34527 }
34528 arg2 = static_cast< wxDragResult >(val2);
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 (arg1)->SetDefaultAction(arg2);
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 resultobj = SWIG_Py_Void();
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34543 PyObject *resultobj = 0;
34544 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34545 wxDragResult result;
34546 void *argp1 = 0 ;
34547 int res1 = 0 ;
34548 PyObject *swig_obj[1] ;
34549
34550 if (!args) SWIG_fail;
34551 swig_obj[0] = args;
34552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34553 if (!SWIG_IsOK(res1)) {
34554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34555 }
34556 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 result = (wxDragResult)(arg1)->GetDefaultAction();
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 resultobj = SWIG_From_int(static_cast< int >(result));
34564 return resultobj;
34565 fail:
34566 return NULL;
34567 }
34568
34569
34570 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34571 PyObject *obj;
34572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34573 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34574 return SWIG_Py_Void();
34575 }
34576
34577 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34578 return SWIG_Python_InitShadowInstance(args);
34579 }
34580
34581 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34582 PyObject *resultobj = 0;
34583 wxPyTextDropTarget *result = 0 ;
34584
34585 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34586 {
34587 PyThreadState* __tstate = wxPyBeginAllowThreads();
34588 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34589 wxPyEndAllowThreads(__tstate);
34590 if (PyErr_Occurred()) SWIG_fail;
34591 }
34592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34593 return resultobj;
34594 fail:
34595 return NULL;
34596 }
34597
34598
34599 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34600 PyObject *resultobj = 0;
34601 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34602 PyObject *arg2 = (PyObject *) 0 ;
34603 PyObject *arg3 = (PyObject *) 0 ;
34604 void *argp1 = 0 ;
34605 int res1 = 0 ;
34606 PyObject * obj0 = 0 ;
34607 PyObject * obj1 = 0 ;
34608 PyObject * obj2 = 0 ;
34609 char * kwnames[] = {
34610 (char *) "self",(char *) "self",(char *) "_class", NULL
34611 };
34612
34613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34615 if (!SWIG_IsOK(res1)) {
34616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34617 }
34618 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34619 arg2 = obj1;
34620 arg3 = obj2;
34621 {
34622 PyThreadState* __tstate = wxPyBeginAllowThreads();
34623 (arg1)->_setCallbackInfo(arg2,arg3);
34624 wxPyEndAllowThreads(__tstate);
34625 if (PyErr_Occurred()) SWIG_fail;
34626 }
34627 resultobj = SWIG_Py_Void();
34628 return resultobj;
34629 fail:
34630 return NULL;
34631 }
34632
34633
34634 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34635 PyObject *resultobj = 0;
34636 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34637 int arg2 ;
34638 int arg3 ;
34639 wxString *arg4 = 0 ;
34640 bool result;
34641 void *argp1 = 0 ;
34642 int res1 = 0 ;
34643 int val2 ;
34644 int ecode2 = 0 ;
34645 int val3 ;
34646 int ecode3 = 0 ;
34647 bool temp4 = false ;
34648 PyObject * obj0 = 0 ;
34649 PyObject * obj1 = 0 ;
34650 PyObject * obj2 = 0 ;
34651 PyObject * obj3 = 0 ;
34652 char * kwnames[] = {
34653 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34654 };
34655
34656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34658 if (!SWIG_IsOK(res1)) {
34659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34660 }
34661 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34662 ecode2 = SWIG_AsVal_int(obj1, &val2);
34663 if (!SWIG_IsOK(ecode2)) {
34664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34665 }
34666 arg2 = static_cast< int >(val2);
34667 ecode3 = SWIG_AsVal_int(obj2, &val3);
34668 if (!SWIG_IsOK(ecode3)) {
34669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34670 }
34671 arg3 = static_cast< int >(val3);
34672 {
34673 arg4 = wxString_in_helper(obj3);
34674 if (arg4 == NULL) SWIG_fail;
34675 temp4 = true;
34676 }
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 {
34684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34685 }
34686 {
34687 if (temp4)
34688 delete arg4;
34689 }
34690 return resultobj;
34691 fail:
34692 {
34693 if (temp4)
34694 delete arg4;
34695 }
34696 return NULL;
34697 }
34698
34699
34700 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34701 PyObject *resultobj = 0;
34702 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34703 int arg2 ;
34704 int arg3 ;
34705 wxDragResult arg4 ;
34706 wxDragResult result;
34707 void *argp1 = 0 ;
34708 int res1 = 0 ;
34709 int val2 ;
34710 int ecode2 = 0 ;
34711 int val3 ;
34712 int ecode3 = 0 ;
34713 int val4 ;
34714 int ecode4 = 0 ;
34715 PyObject * obj0 = 0 ;
34716 PyObject * obj1 = 0 ;
34717 PyObject * obj2 = 0 ;
34718 PyObject * obj3 = 0 ;
34719 char * kwnames[] = {
34720 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34721 };
34722
34723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34725 if (!SWIG_IsOK(res1)) {
34726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34727 }
34728 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34729 ecode2 = SWIG_AsVal_int(obj1, &val2);
34730 if (!SWIG_IsOK(ecode2)) {
34731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34732 }
34733 arg2 = static_cast< int >(val2);
34734 ecode3 = SWIG_AsVal_int(obj2, &val3);
34735 if (!SWIG_IsOK(ecode3)) {
34736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34737 }
34738 arg3 = static_cast< int >(val3);
34739 ecode4 = SWIG_AsVal_int(obj3, &val4);
34740 if (!SWIG_IsOK(ecode4)) {
34741 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34742 }
34743 arg4 = static_cast< wxDragResult >(val4);
34744 {
34745 PyThreadState* __tstate = wxPyBeginAllowThreads();
34746 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34747 wxPyEndAllowThreads(__tstate);
34748 if (PyErr_Occurred()) SWIG_fail;
34749 }
34750 resultobj = SWIG_From_int(static_cast< int >(result));
34751 return resultobj;
34752 fail:
34753 return NULL;
34754 }
34755
34756
34757 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34758 PyObject *resultobj = 0;
34759 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34760 int arg2 ;
34761 int arg3 ;
34762 wxDragResult arg4 ;
34763 wxDragResult result;
34764 void *argp1 = 0 ;
34765 int res1 = 0 ;
34766 int val2 ;
34767 int ecode2 = 0 ;
34768 int val3 ;
34769 int ecode3 = 0 ;
34770 int val4 ;
34771 int ecode4 = 0 ;
34772 PyObject * obj0 = 0 ;
34773 PyObject * obj1 = 0 ;
34774 PyObject * obj2 = 0 ;
34775 PyObject * obj3 = 0 ;
34776 char * kwnames[] = {
34777 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34778 };
34779
34780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34782 if (!SWIG_IsOK(res1)) {
34783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34784 }
34785 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34786 ecode2 = SWIG_AsVal_int(obj1, &val2);
34787 if (!SWIG_IsOK(ecode2)) {
34788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34789 }
34790 arg2 = static_cast< int >(val2);
34791 ecode3 = SWIG_AsVal_int(obj2, &val3);
34792 if (!SWIG_IsOK(ecode3)) {
34793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34794 }
34795 arg3 = static_cast< int >(val3);
34796 ecode4 = SWIG_AsVal_int(obj3, &val4);
34797 if (!SWIG_IsOK(ecode4)) {
34798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34799 }
34800 arg4 = static_cast< wxDragResult >(val4);
34801 {
34802 PyThreadState* __tstate = wxPyBeginAllowThreads();
34803 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34804 wxPyEndAllowThreads(__tstate);
34805 if (PyErr_Occurred()) SWIG_fail;
34806 }
34807 resultobj = SWIG_From_int(static_cast< int >(result));
34808 return resultobj;
34809 fail:
34810 return NULL;
34811 }
34812
34813
34814 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34815 PyObject *resultobj = 0;
34816 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34817 void *argp1 = 0 ;
34818 int res1 = 0 ;
34819 PyObject *swig_obj[1] ;
34820
34821 if (!args) SWIG_fail;
34822 swig_obj[0] = args;
34823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34824 if (!SWIG_IsOK(res1)) {
34825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34826 }
34827 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34828 {
34829 PyThreadState* __tstate = wxPyBeginAllowThreads();
34830 (arg1)->OnLeave();
34831 wxPyEndAllowThreads(__tstate);
34832 if (PyErr_Occurred()) SWIG_fail;
34833 }
34834 resultobj = SWIG_Py_Void();
34835 return resultobj;
34836 fail:
34837 return NULL;
34838 }
34839
34840
34841 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34842 PyObject *resultobj = 0;
34843 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34844 int arg2 ;
34845 int arg3 ;
34846 bool result;
34847 void *argp1 = 0 ;
34848 int res1 = 0 ;
34849 int val2 ;
34850 int ecode2 = 0 ;
34851 int val3 ;
34852 int ecode3 = 0 ;
34853 PyObject * obj0 = 0 ;
34854 PyObject * obj1 = 0 ;
34855 PyObject * obj2 = 0 ;
34856 char * kwnames[] = {
34857 (char *) "self",(char *) "x",(char *) "y", NULL
34858 };
34859
34860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34862 if (!SWIG_IsOK(res1)) {
34863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34864 }
34865 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34866 ecode2 = SWIG_AsVal_int(obj1, &val2);
34867 if (!SWIG_IsOK(ecode2)) {
34868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34869 }
34870 arg2 = static_cast< int >(val2);
34871 ecode3 = SWIG_AsVal_int(obj2, &val3);
34872 if (!SWIG_IsOK(ecode3)) {
34873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34874 }
34875 arg3 = static_cast< int >(val3);
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 result = (bool)(arg1)->OnDrop(arg2,arg3);
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 {
34883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34884 }
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj = 0;
34893 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34894 int arg2 ;
34895 int arg3 ;
34896 wxDragResult arg4 ;
34897 wxDragResult result;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 int val2 ;
34901 int ecode2 = 0 ;
34902 int val3 ;
34903 int ecode3 = 0 ;
34904 int val4 ;
34905 int ecode4 = 0 ;
34906 PyObject * obj0 = 0 ;
34907 PyObject * obj1 = 0 ;
34908 PyObject * obj2 = 0 ;
34909 PyObject * obj3 = 0 ;
34910 char * kwnames[] = {
34911 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34912 };
34913
34914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34916 if (!SWIG_IsOK(res1)) {
34917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34918 }
34919 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34920 ecode2 = SWIG_AsVal_int(obj1, &val2);
34921 if (!SWIG_IsOK(ecode2)) {
34922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34923 }
34924 arg2 = static_cast< int >(val2);
34925 ecode3 = SWIG_AsVal_int(obj2, &val3);
34926 if (!SWIG_IsOK(ecode3)) {
34927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34928 }
34929 arg3 = static_cast< int >(val3);
34930 ecode4 = SWIG_AsVal_int(obj3, &val4);
34931 if (!SWIG_IsOK(ecode4)) {
34932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34933 }
34934 arg4 = static_cast< wxDragResult >(val4);
34935 {
34936 PyThreadState* __tstate = wxPyBeginAllowThreads();
34937 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34938 wxPyEndAllowThreads(__tstate);
34939 if (PyErr_Occurred()) SWIG_fail;
34940 }
34941 resultobj = SWIG_From_int(static_cast< int >(result));
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34949 PyObject *obj;
34950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34951 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34952 return SWIG_Py_Void();
34953 }
34954
34955 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34956 return SWIG_Python_InitShadowInstance(args);
34957 }
34958
34959 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34960 PyObject *resultobj = 0;
34961 wxPyFileDropTarget *result = 0 ;
34962
34963 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34964 {
34965 PyThreadState* __tstate = wxPyBeginAllowThreads();
34966 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34967 wxPyEndAllowThreads(__tstate);
34968 if (PyErr_Occurred()) SWIG_fail;
34969 }
34970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34971 return resultobj;
34972 fail:
34973 return NULL;
34974 }
34975
34976
34977 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34978 PyObject *resultobj = 0;
34979 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34980 PyObject *arg2 = (PyObject *) 0 ;
34981 PyObject *arg3 = (PyObject *) 0 ;
34982 void *argp1 = 0 ;
34983 int res1 = 0 ;
34984 PyObject * obj0 = 0 ;
34985 PyObject * obj1 = 0 ;
34986 PyObject * obj2 = 0 ;
34987 char * kwnames[] = {
34988 (char *) "self",(char *) "self",(char *) "_class", NULL
34989 };
34990
34991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34993 if (!SWIG_IsOK(res1)) {
34994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34995 }
34996 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34997 arg2 = obj1;
34998 arg3 = obj2;
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 (arg1)->_setCallbackInfo(arg2,arg3);
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 resultobj = SWIG_Py_Void();
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35013 PyObject *resultobj = 0;
35014 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35015 int arg2 ;
35016 int arg3 ;
35017 wxArrayString *arg4 = 0 ;
35018 bool result;
35019 void *argp1 = 0 ;
35020 int res1 = 0 ;
35021 int val2 ;
35022 int ecode2 = 0 ;
35023 int val3 ;
35024 int ecode3 = 0 ;
35025 bool temp4 = false ;
35026 PyObject * obj0 = 0 ;
35027 PyObject * obj1 = 0 ;
35028 PyObject * obj2 = 0 ;
35029 PyObject * obj3 = 0 ;
35030 char * kwnames[] = {
35031 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35032 };
35033
35034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35036 if (!SWIG_IsOK(res1)) {
35037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35038 }
35039 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35040 ecode2 = SWIG_AsVal_int(obj1, &val2);
35041 if (!SWIG_IsOK(ecode2)) {
35042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35043 }
35044 arg2 = static_cast< int >(val2);
35045 ecode3 = SWIG_AsVal_int(obj2, &val3);
35046 if (!SWIG_IsOK(ecode3)) {
35047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35048 }
35049 arg3 = static_cast< int >(val3);
35050 {
35051 if (! PySequence_Check(obj3)) {
35052 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35053 SWIG_fail;
35054 }
35055 arg4 = new wxArrayString;
35056 temp4 = true;
35057 int i, len=PySequence_Length(obj3);
35058 for (i=0; i<len; i++) {
35059 PyObject* item = PySequence_GetItem(obj3, i);
35060 wxString* s = wxString_in_helper(item);
35061 if (PyErr_Occurred()) SWIG_fail;
35062 arg4->Add(*s);
35063 delete s;
35064 Py_DECREF(item);
35065 }
35066 }
35067 {
35068 PyThreadState* __tstate = wxPyBeginAllowThreads();
35069 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35070 wxPyEndAllowThreads(__tstate);
35071 if (PyErr_Occurred()) SWIG_fail;
35072 }
35073 {
35074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35075 }
35076 {
35077 if (temp4) delete arg4;
35078 }
35079 return resultobj;
35080 fail:
35081 {
35082 if (temp4) delete arg4;
35083 }
35084 return NULL;
35085 }
35086
35087
35088 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35089 PyObject *resultobj = 0;
35090 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35091 int arg2 ;
35092 int arg3 ;
35093 wxDragResult arg4 ;
35094 wxDragResult result;
35095 void *argp1 = 0 ;
35096 int res1 = 0 ;
35097 int val2 ;
35098 int ecode2 = 0 ;
35099 int val3 ;
35100 int ecode3 = 0 ;
35101 int val4 ;
35102 int ecode4 = 0 ;
35103 PyObject * obj0 = 0 ;
35104 PyObject * obj1 = 0 ;
35105 PyObject * obj2 = 0 ;
35106 PyObject * obj3 = 0 ;
35107 char * kwnames[] = {
35108 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35109 };
35110
35111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35115 }
35116 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35117 ecode2 = SWIG_AsVal_int(obj1, &val2);
35118 if (!SWIG_IsOK(ecode2)) {
35119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35120 }
35121 arg2 = static_cast< int >(val2);
35122 ecode3 = SWIG_AsVal_int(obj2, &val3);
35123 if (!SWIG_IsOK(ecode3)) {
35124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35125 }
35126 arg3 = static_cast< int >(val3);
35127 ecode4 = SWIG_AsVal_int(obj3, &val4);
35128 if (!SWIG_IsOK(ecode4)) {
35129 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35130 }
35131 arg4 = static_cast< wxDragResult >(val4);
35132 {
35133 PyThreadState* __tstate = wxPyBeginAllowThreads();
35134 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35135 wxPyEndAllowThreads(__tstate);
35136 if (PyErr_Occurred()) SWIG_fail;
35137 }
35138 resultobj = SWIG_From_int(static_cast< int >(result));
35139 return resultobj;
35140 fail:
35141 return NULL;
35142 }
35143
35144
35145 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35146 PyObject *resultobj = 0;
35147 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35148 int arg2 ;
35149 int arg3 ;
35150 wxDragResult arg4 ;
35151 wxDragResult result;
35152 void *argp1 = 0 ;
35153 int res1 = 0 ;
35154 int val2 ;
35155 int ecode2 = 0 ;
35156 int val3 ;
35157 int ecode3 = 0 ;
35158 int val4 ;
35159 int ecode4 = 0 ;
35160 PyObject * obj0 = 0 ;
35161 PyObject * obj1 = 0 ;
35162 PyObject * obj2 = 0 ;
35163 PyObject * obj3 = 0 ;
35164 char * kwnames[] = {
35165 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35166 };
35167
35168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35170 if (!SWIG_IsOK(res1)) {
35171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35172 }
35173 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35174 ecode2 = SWIG_AsVal_int(obj1, &val2);
35175 if (!SWIG_IsOK(ecode2)) {
35176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35177 }
35178 arg2 = static_cast< int >(val2);
35179 ecode3 = SWIG_AsVal_int(obj2, &val3);
35180 if (!SWIG_IsOK(ecode3)) {
35181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35182 }
35183 arg3 = static_cast< int >(val3);
35184 ecode4 = SWIG_AsVal_int(obj3, &val4);
35185 if (!SWIG_IsOK(ecode4)) {
35186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35187 }
35188 arg4 = static_cast< wxDragResult >(val4);
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 resultobj = SWIG_From_int(static_cast< int >(result));
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35203 PyObject *resultobj = 0;
35204 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35205 void *argp1 = 0 ;
35206 int res1 = 0 ;
35207 PyObject *swig_obj[1] ;
35208
35209 if (!args) SWIG_fail;
35210 swig_obj[0] = args;
35211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35212 if (!SWIG_IsOK(res1)) {
35213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35214 }
35215 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35216 {
35217 PyThreadState* __tstate = wxPyBeginAllowThreads();
35218 (arg1)->OnLeave();
35219 wxPyEndAllowThreads(__tstate);
35220 if (PyErr_Occurred()) SWIG_fail;
35221 }
35222 resultobj = SWIG_Py_Void();
35223 return resultobj;
35224 fail:
35225 return NULL;
35226 }
35227
35228
35229 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35230 PyObject *resultobj = 0;
35231 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35232 int arg2 ;
35233 int arg3 ;
35234 bool result;
35235 void *argp1 = 0 ;
35236 int res1 = 0 ;
35237 int val2 ;
35238 int ecode2 = 0 ;
35239 int val3 ;
35240 int ecode3 = 0 ;
35241 PyObject * obj0 = 0 ;
35242 PyObject * obj1 = 0 ;
35243 PyObject * obj2 = 0 ;
35244 char * kwnames[] = {
35245 (char *) "self",(char *) "x",(char *) "y", NULL
35246 };
35247
35248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35250 if (!SWIG_IsOK(res1)) {
35251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35252 }
35253 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35254 ecode2 = SWIG_AsVal_int(obj1, &val2);
35255 if (!SWIG_IsOK(ecode2)) {
35256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35257 }
35258 arg2 = static_cast< int >(val2);
35259 ecode3 = SWIG_AsVal_int(obj2, &val3);
35260 if (!SWIG_IsOK(ecode3)) {
35261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35262 }
35263 arg3 = static_cast< int >(val3);
35264 {
35265 PyThreadState* __tstate = wxPyBeginAllowThreads();
35266 result = (bool)(arg1)->OnDrop(arg2,arg3);
35267 wxPyEndAllowThreads(__tstate);
35268 if (PyErr_Occurred()) SWIG_fail;
35269 }
35270 {
35271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35272 }
35273 return resultobj;
35274 fail:
35275 return NULL;
35276 }
35277
35278
35279 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35280 PyObject *resultobj = 0;
35281 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35282 int arg2 ;
35283 int arg3 ;
35284 wxDragResult arg4 ;
35285 wxDragResult result;
35286 void *argp1 = 0 ;
35287 int res1 = 0 ;
35288 int val2 ;
35289 int ecode2 = 0 ;
35290 int val3 ;
35291 int ecode3 = 0 ;
35292 int val4 ;
35293 int ecode4 = 0 ;
35294 PyObject * obj0 = 0 ;
35295 PyObject * obj1 = 0 ;
35296 PyObject * obj2 = 0 ;
35297 PyObject * obj3 = 0 ;
35298 char * kwnames[] = {
35299 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35300 };
35301
35302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35304 if (!SWIG_IsOK(res1)) {
35305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35306 }
35307 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35308 ecode2 = SWIG_AsVal_int(obj1, &val2);
35309 if (!SWIG_IsOK(ecode2)) {
35310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35311 }
35312 arg2 = static_cast< int >(val2);
35313 ecode3 = SWIG_AsVal_int(obj2, &val3);
35314 if (!SWIG_IsOK(ecode3)) {
35315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35316 }
35317 arg3 = static_cast< int >(val3);
35318 ecode4 = SWIG_AsVal_int(obj3, &val4);
35319 if (!SWIG_IsOK(ecode4)) {
35320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35321 }
35322 arg4 = static_cast< wxDragResult >(val4);
35323 {
35324 PyThreadState* __tstate = wxPyBeginAllowThreads();
35325 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35326 wxPyEndAllowThreads(__tstate);
35327 if (PyErr_Occurred()) SWIG_fail;
35328 }
35329 resultobj = SWIG_From_int(static_cast< int >(result));
35330 return resultobj;
35331 fail:
35332 return NULL;
35333 }
35334
35335
35336 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35337 PyObject *obj;
35338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35339 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35340 return SWIG_Py_Void();
35341 }
35342
35343 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35344 return SWIG_Python_InitShadowInstance(args);
35345 }
35346
35347 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35348 PyObject *resultobj = 0;
35349 wxClipboard *result = 0 ;
35350
35351 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35352 {
35353 PyThreadState* __tstate = wxPyBeginAllowThreads();
35354 result = (wxClipboard *)new wxClipboard();
35355 wxPyEndAllowThreads(__tstate);
35356 if (PyErr_Occurred()) SWIG_fail;
35357 }
35358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35359 return resultobj;
35360 fail:
35361 return NULL;
35362 }
35363
35364
35365 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35366 PyObject *resultobj = 0;
35367 wxClipboard *arg1 = (wxClipboard *) 0 ;
35368 void *argp1 = 0 ;
35369 int res1 = 0 ;
35370 PyObject *swig_obj[1] ;
35371
35372 if (!args) SWIG_fail;
35373 swig_obj[0] = args;
35374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35375 if (!SWIG_IsOK(res1)) {
35376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35377 }
35378 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35379 {
35380 PyThreadState* __tstate = wxPyBeginAllowThreads();
35381 delete arg1;
35382
35383 wxPyEndAllowThreads(__tstate);
35384 if (PyErr_Occurred()) SWIG_fail;
35385 }
35386 resultobj = SWIG_Py_Void();
35387 return resultobj;
35388 fail:
35389 return NULL;
35390 }
35391
35392
35393 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35394 PyObject *resultobj = 0;
35395 wxClipboard *arg1 = (wxClipboard *) 0 ;
35396 bool result;
35397 void *argp1 = 0 ;
35398 int res1 = 0 ;
35399 PyObject *swig_obj[1] ;
35400
35401 if (!args) SWIG_fail;
35402 swig_obj[0] = args;
35403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35404 if (!SWIG_IsOK(res1)) {
35405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35406 }
35407 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35408 {
35409 PyThreadState* __tstate = wxPyBeginAllowThreads();
35410 result = (bool)(arg1)->Open();
35411 wxPyEndAllowThreads(__tstate);
35412 if (PyErr_Occurred()) SWIG_fail;
35413 }
35414 {
35415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35416 }
35417 return resultobj;
35418 fail:
35419 return NULL;
35420 }
35421
35422
35423 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35424 PyObject *resultobj = 0;
35425 wxClipboard *arg1 = (wxClipboard *) 0 ;
35426 void *argp1 = 0 ;
35427 int res1 = 0 ;
35428 PyObject *swig_obj[1] ;
35429
35430 if (!args) SWIG_fail;
35431 swig_obj[0] = args;
35432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35433 if (!SWIG_IsOK(res1)) {
35434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35435 }
35436 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 (arg1)->Close();
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 resultobj = SWIG_Py_Void();
35444 return resultobj;
35445 fail:
35446 return NULL;
35447 }
35448
35449
35450 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35451 PyObject *resultobj = 0;
35452 wxClipboard *arg1 = (wxClipboard *) 0 ;
35453 bool result;
35454 void *argp1 = 0 ;
35455 int res1 = 0 ;
35456 PyObject *swig_obj[1] ;
35457
35458 if (!args) SWIG_fail;
35459 swig_obj[0] = args;
35460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35461 if (!SWIG_IsOK(res1)) {
35462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35463 }
35464 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35465 {
35466 PyThreadState* __tstate = wxPyBeginAllowThreads();
35467 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35468 wxPyEndAllowThreads(__tstate);
35469 if (PyErr_Occurred()) SWIG_fail;
35470 }
35471 {
35472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35473 }
35474 return resultobj;
35475 fail:
35476 return NULL;
35477 }
35478
35479
35480 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35481 PyObject *resultobj = 0;
35482 wxClipboard *arg1 = (wxClipboard *) 0 ;
35483 wxDataObject *arg2 = (wxDataObject *) 0 ;
35484 bool result;
35485 void *argp1 = 0 ;
35486 int res1 = 0 ;
35487 int res2 = 0 ;
35488 PyObject * obj0 = 0 ;
35489 PyObject * obj1 = 0 ;
35490 char * kwnames[] = {
35491 (char *) "self",(char *) "data", NULL
35492 };
35493
35494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35496 if (!SWIG_IsOK(res1)) {
35497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35498 }
35499 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35500 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35501 if (!SWIG_IsOK(res2)) {
35502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35503 }
35504 {
35505 PyThreadState* __tstate = wxPyBeginAllowThreads();
35506 result = (bool)(arg1)->AddData(arg2);
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 {
35511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35512 }
35513 return resultobj;
35514 fail:
35515 return NULL;
35516 }
35517
35518
35519 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35520 PyObject *resultobj = 0;
35521 wxClipboard *arg1 = (wxClipboard *) 0 ;
35522 wxDataObject *arg2 = (wxDataObject *) 0 ;
35523 bool result;
35524 void *argp1 = 0 ;
35525 int res1 = 0 ;
35526 int res2 = 0 ;
35527 PyObject * obj0 = 0 ;
35528 PyObject * obj1 = 0 ;
35529 char * kwnames[] = {
35530 (char *) "self",(char *) "data", NULL
35531 };
35532
35533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35535 if (!SWIG_IsOK(res1)) {
35536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35537 }
35538 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35539 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35540 if (!SWIG_IsOK(res2)) {
35541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35542 }
35543 {
35544 PyThreadState* __tstate = wxPyBeginAllowThreads();
35545 result = (bool)(arg1)->SetData(arg2);
35546 wxPyEndAllowThreads(__tstate);
35547 if (PyErr_Occurred()) SWIG_fail;
35548 }
35549 {
35550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35551 }
35552 return resultobj;
35553 fail:
35554 return NULL;
35555 }
35556
35557
35558 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35559 PyObject *resultobj = 0;
35560 wxClipboard *arg1 = (wxClipboard *) 0 ;
35561 wxDataFormat *arg2 = 0 ;
35562 bool result;
35563 void *argp1 = 0 ;
35564 int res1 = 0 ;
35565 void *argp2 = 0 ;
35566 int res2 = 0 ;
35567 PyObject * obj0 = 0 ;
35568 PyObject * obj1 = 0 ;
35569 char * kwnames[] = {
35570 (char *) "self",(char *) "format", NULL
35571 };
35572
35573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35575 if (!SWIG_IsOK(res1)) {
35576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35577 }
35578 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35580 if (!SWIG_IsOK(res2)) {
35581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35582 }
35583 if (!argp2) {
35584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35585 }
35586 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35587 {
35588 PyThreadState* __tstate = wxPyBeginAllowThreads();
35589 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35590 wxPyEndAllowThreads(__tstate);
35591 if (PyErr_Occurred()) SWIG_fail;
35592 }
35593 {
35594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35595 }
35596 return resultobj;
35597 fail:
35598 return NULL;
35599 }
35600
35601
35602 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35603 PyObject *resultobj = 0;
35604 wxClipboard *arg1 = (wxClipboard *) 0 ;
35605 wxDataObject *arg2 = 0 ;
35606 bool result;
35607 void *argp1 = 0 ;
35608 int res1 = 0 ;
35609 void *argp2 = 0 ;
35610 int res2 = 0 ;
35611 PyObject * obj0 = 0 ;
35612 PyObject * obj1 = 0 ;
35613 char * kwnames[] = {
35614 (char *) "self",(char *) "data", NULL
35615 };
35616
35617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35619 if (!SWIG_IsOK(res1)) {
35620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35621 }
35622 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35623 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35624 if (!SWIG_IsOK(res2)) {
35625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35626 }
35627 if (!argp2) {
35628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35629 }
35630 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35631 {
35632 PyThreadState* __tstate = wxPyBeginAllowThreads();
35633 result = (bool)(arg1)->GetData(*arg2);
35634 wxPyEndAllowThreads(__tstate);
35635 if (PyErr_Occurred()) SWIG_fail;
35636 }
35637 {
35638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35639 }
35640 return resultobj;
35641 fail:
35642 return NULL;
35643 }
35644
35645
35646 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35647 PyObject *resultobj = 0;
35648 wxClipboard *arg1 = (wxClipboard *) 0 ;
35649 void *argp1 = 0 ;
35650 int res1 = 0 ;
35651 PyObject *swig_obj[1] ;
35652
35653 if (!args) SWIG_fail;
35654 swig_obj[0] = args;
35655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35656 if (!SWIG_IsOK(res1)) {
35657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35658 }
35659 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35660 {
35661 PyThreadState* __tstate = wxPyBeginAllowThreads();
35662 (arg1)->Clear();
35663 wxPyEndAllowThreads(__tstate);
35664 if (PyErr_Occurred()) SWIG_fail;
35665 }
35666 resultobj = SWIG_Py_Void();
35667 return resultobj;
35668 fail:
35669 return NULL;
35670 }
35671
35672
35673 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35674 PyObject *resultobj = 0;
35675 wxClipboard *arg1 = (wxClipboard *) 0 ;
35676 bool result;
35677 void *argp1 = 0 ;
35678 int res1 = 0 ;
35679 PyObject *swig_obj[1] ;
35680
35681 if (!args) SWIG_fail;
35682 swig_obj[0] = args;
35683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35684 if (!SWIG_IsOK(res1)) {
35685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35686 }
35687 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35688 {
35689 PyThreadState* __tstate = wxPyBeginAllowThreads();
35690 result = (bool)(arg1)->Flush();
35691 wxPyEndAllowThreads(__tstate);
35692 if (PyErr_Occurred()) SWIG_fail;
35693 }
35694 {
35695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35696 }
35697 return resultobj;
35698 fail:
35699 return NULL;
35700 }
35701
35702
35703 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35704 PyObject *resultobj = 0;
35705 wxClipboard *arg1 = (wxClipboard *) 0 ;
35706 bool arg2 = (bool) true ;
35707 void *argp1 = 0 ;
35708 int res1 = 0 ;
35709 bool val2 ;
35710 int ecode2 = 0 ;
35711 PyObject * obj0 = 0 ;
35712 PyObject * obj1 = 0 ;
35713 char * kwnames[] = {
35714 (char *) "self",(char *) "primary", NULL
35715 };
35716
35717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35719 if (!SWIG_IsOK(res1)) {
35720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35721 }
35722 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35723 if (obj1) {
35724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35725 if (!SWIG_IsOK(ecode2)) {
35726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35727 }
35728 arg2 = static_cast< bool >(val2);
35729 }
35730 {
35731 PyThreadState* __tstate = wxPyBeginAllowThreads();
35732 (arg1)->UsePrimarySelection(arg2);
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 resultobj = SWIG_Py_Void();
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35744 PyObject *resultobj = 0;
35745 wxClipboard *result = 0 ;
35746
35747 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35748 {
35749 PyThreadState* __tstate = wxPyBeginAllowThreads();
35750 result = (wxClipboard *)wxClipboard::Get();
35751 wxPyEndAllowThreads(__tstate);
35752 if (PyErr_Occurred()) SWIG_fail;
35753 }
35754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35755 return resultobj;
35756 fail:
35757 return NULL;
35758 }
35759
35760
35761 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35762 PyObject *obj;
35763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35764 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35765 return SWIG_Py_Void();
35766 }
35767
35768 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35769 return SWIG_Python_InitShadowInstance(args);
35770 }
35771
35772 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35773 PyObject *resultobj = 0;
35774 wxClipboard *arg1 = (wxClipboard *) NULL ;
35775 wxClipboardLocker *result = 0 ;
35776 void *argp1 = 0 ;
35777 int res1 = 0 ;
35778 PyObject * obj0 = 0 ;
35779 char * kwnames[] = {
35780 (char *) "clipboard", NULL
35781 };
35782
35783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35784 if (obj0) {
35785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35786 if (!SWIG_IsOK(res1)) {
35787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35788 }
35789 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35790 }
35791 {
35792 PyThreadState* __tstate = wxPyBeginAllowThreads();
35793 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35794 wxPyEndAllowThreads(__tstate);
35795 if (PyErr_Occurred()) SWIG_fail;
35796 }
35797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35798 return resultobj;
35799 fail:
35800 return NULL;
35801 }
35802
35803
35804 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35805 PyObject *resultobj = 0;
35806 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35807 void *argp1 = 0 ;
35808 int res1 = 0 ;
35809 PyObject *swig_obj[1] ;
35810
35811 if (!args) SWIG_fail;
35812 swig_obj[0] = args;
35813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35814 if (!SWIG_IsOK(res1)) {
35815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35816 }
35817 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35818 {
35819 PyThreadState* __tstate = wxPyBeginAllowThreads();
35820 delete arg1;
35821
35822 wxPyEndAllowThreads(__tstate);
35823 if (PyErr_Occurred()) SWIG_fail;
35824 }
35825 resultobj = SWIG_Py_Void();
35826 return resultobj;
35827 fail:
35828 return NULL;
35829 }
35830
35831
35832 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35833 PyObject *resultobj = 0;
35834 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35835 bool result;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838 PyObject *swig_obj[1] ;
35839
35840 if (!args) SWIG_fail;
35841 swig_obj[0] = args;
35842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35843 if (!SWIG_IsOK(res1)) {
35844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35845 }
35846 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35847 {
35848 PyThreadState* __tstate = wxPyBeginAllowThreads();
35849 result = (bool)wxClipboardLocker___nonzero__(arg1);
35850 wxPyEndAllowThreads(__tstate);
35851 if (PyErr_Occurred()) SWIG_fail;
35852 }
35853 {
35854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35855 }
35856 return resultobj;
35857 fail:
35858 return NULL;
35859 }
35860
35861
35862 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35863 PyObject *obj;
35864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35865 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35866 return SWIG_Py_Void();
35867 }
35868
35869 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35870 return SWIG_Python_InitShadowInstance(args);
35871 }
35872
35873 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35874 PyObject *resultobj = 0;
35875 int arg1 = (int) 0 ;
35876 int arg2 = (int) 0 ;
35877 int arg3 = (int) 0 ;
35878 int arg4 = (int) 0 ;
35879 wxVideoMode *result = 0 ;
35880 int val1 ;
35881 int ecode1 = 0 ;
35882 int val2 ;
35883 int ecode2 = 0 ;
35884 int val3 ;
35885 int ecode3 = 0 ;
35886 int val4 ;
35887 int ecode4 = 0 ;
35888 PyObject * obj0 = 0 ;
35889 PyObject * obj1 = 0 ;
35890 PyObject * obj2 = 0 ;
35891 PyObject * obj3 = 0 ;
35892 char * kwnames[] = {
35893 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35894 };
35895
35896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35897 if (obj0) {
35898 ecode1 = SWIG_AsVal_int(obj0, &val1);
35899 if (!SWIG_IsOK(ecode1)) {
35900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35901 }
35902 arg1 = static_cast< int >(val1);
35903 }
35904 if (obj1) {
35905 ecode2 = SWIG_AsVal_int(obj1, &val2);
35906 if (!SWIG_IsOK(ecode2)) {
35907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35908 }
35909 arg2 = static_cast< int >(val2);
35910 }
35911 if (obj2) {
35912 ecode3 = SWIG_AsVal_int(obj2, &val3);
35913 if (!SWIG_IsOK(ecode3)) {
35914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35915 }
35916 arg3 = static_cast< int >(val3);
35917 }
35918 if (obj3) {
35919 ecode4 = SWIG_AsVal_int(obj3, &val4);
35920 if (!SWIG_IsOK(ecode4)) {
35921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35922 }
35923 arg4 = static_cast< int >(val4);
35924 }
35925 {
35926 PyThreadState* __tstate = wxPyBeginAllowThreads();
35927 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35928 wxPyEndAllowThreads(__tstate);
35929 if (PyErr_Occurred()) SWIG_fail;
35930 }
35931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35939 PyObject *resultobj = 0;
35940 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35941 void *argp1 = 0 ;
35942 int res1 = 0 ;
35943 PyObject *swig_obj[1] ;
35944
35945 if (!args) SWIG_fail;
35946 swig_obj[0] = args;
35947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35948 if (!SWIG_IsOK(res1)) {
35949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35950 }
35951 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35952 {
35953 PyThreadState* __tstate = wxPyBeginAllowThreads();
35954 delete arg1;
35955
35956 wxPyEndAllowThreads(__tstate);
35957 if (PyErr_Occurred()) SWIG_fail;
35958 }
35959 resultobj = SWIG_Py_Void();
35960 return resultobj;
35961 fail:
35962 return NULL;
35963 }
35964
35965
35966 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35967 PyObject *resultobj = 0;
35968 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35969 wxVideoMode *arg2 = 0 ;
35970 bool result;
35971 void *argp1 = 0 ;
35972 int res1 = 0 ;
35973 void *argp2 = 0 ;
35974 int res2 = 0 ;
35975 PyObject * obj0 = 0 ;
35976 PyObject * obj1 = 0 ;
35977 char * kwnames[] = {
35978 (char *) "self",(char *) "other", NULL
35979 };
35980
35981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35983 if (!SWIG_IsOK(res1)) {
35984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35985 }
35986 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35987 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35988 if (!SWIG_IsOK(res2)) {
35989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35990 }
35991 if (!argp2) {
35992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35993 }
35994 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35995 {
35996 PyThreadState* __tstate = wxPyBeginAllowThreads();
35997 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35998 wxPyEndAllowThreads(__tstate);
35999 if (PyErr_Occurred()) SWIG_fail;
36000 }
36001 {
36002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36003 }
36004 return resultobj;
36005 fail:
36006 return NULL;
36007 }
36008
36009
36010 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36011 PyObject *resultobj = 0;
36012 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36013 int result;
36014 void *argp1 = 0 ;
36015 int res1 = 0 ;
36016 PyObject *swig_obj[1] ;
36017
36018 if (!args) SWIG_fail;
36019 swig_obj[0] = args;
36020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36021 if (!SWIG_IsOK(res1)) {
36022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36023 }
36024 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36025 {
36026 PyThreadState* __tstate = wxPyBeginAllowThreads();
36027 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36028 wxPyEndAllowThreads(__tstate);
36029 if (PyErr_Occurred()) SWIG_fail;
36030 }
36031 resultobj = SWIG_From_int(static_cast< int >(result));
36032 return resultobj;
36033 fail:
36034 return NULL;
36035 }
36036
36037
36038 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36039 PyObject *resultobj = 0;
36040 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36041 int result;
36042 void *argp1 = 0 ;
36043 int res1 = 0 ;
36044 PyObject *swig_obj[1] ;
36045
36046 if (!args) SWIG_fail;
36047 swig_obj[0] = args;
36048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36049 if (!SWIG_IsOK(res1)) {
36050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36051 }
36052 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36053 {
36054 PyThreadState* __tstate = wxPyBeginAllowThreads();
36055 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36056 wxPyEndAllowThreads(__tstate);
36057 if (PyErr_Occurred()) SWIG_fail;
36058 }
36059 resultobj = SWIG_From_int(static_cast< int >(result));
36060 return resultobj;
36061 fail:
36062 return NULL;
36063 }
36064
36065
36066 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36067 PyObject *resultobj = 0;
36068 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36069 int result;
36070 void *argp1 = 0 ;
36071 int res1 = 0 ;
36072 PyObject *swig_obj[1] ;
36073
36074 if (!args) SWIG_fail;
36075 swig_obj[0] = args;
36076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36077 if (!SWIG_IsOK(res1)) {
36078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36079 }
36080 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36081 {
36082 PyThreadState* __tstate = wxPyBeginAllowThreads();
36083 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36084 wxPyEndAllowThreads(__tstate);
36085 if (PyErr_Occurred()) SWIG_fail;
36086 }
36087 resultobj = SWIG_From_int(static_cast< int >(result));
36088 return resultobj;
36089 fail:
36090 return NULL;
36091 }
36092
36093
36094 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36095 PyObject *resultobj = 0;
36096 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36097 bool result;
36098 void *argp1 = 0 ;
36099 int res1 = 0 ;
36100 PyObject *swig_obj[1] ;
36101
36102 if (!args) SWIG_fail;
36103 swig_obj[0] = args;
36104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36105 if (!SWIG_IsOK(res1)) {
36106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36107 }
36108 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36109 {
36110 PyThreadState* __tstate = wxPyBeginAllowThreads();
36111 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36112 wxPyEndAllowThreads(__tstate);
36113 if (PyErr_Occurred()) SWIG_fail;
36114 }
36115 {
36116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36117 }
36118 return resultobj;
36119 fail:
36120 return NULL;
36121 }
36122
36123
36124 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36125 PyObject *resultobj = 0;
36126 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36127 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36128 bool result;
36129 void *argp1 = 0 ;
36130 int res1 = 0 ;
36131 void *argp2 = 0 ;
36132 int res2 = 0 ;
36133 PyObject * obj0 = 0 ;
36134 PyObject * obj1 = 0 ;
36135 char * kwnames[] = {
36136 (char *) "self",(char *) "other", NULL
36137 };
36138
36139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36141 if (!SWIG_IsOK(res1)) {
36142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36143 }
36144 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36146 if (!SWIG_IsOK(res2)) {
36147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36148 }
36149 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36150 {
36151 PyThreadState* __tstate = wxPyBeginAllowThreads();
36152 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36153 wxPyEndAllowThreads(__tstate);
36154 if (PyErr_Occurred()) SWIG_fail;
36155 }
36156 {
36157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36158 }
36159 return resultobj;
36160 fail:
36161 return NULL;
36162 }
36163
36164
36165 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36166 PyObject *resultobj = 0;
36167 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36168 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36169 bool result;
36170 void *argp1 = 0 ;
36171 int res1 = 0 ;
36172 void *argp2 = 0 ;
36173 int res2 = 0 ;
36174 PyObject * obj0 = 0 ;
36175 PyObject * obj1 = 0 ;
36176 char * kwnames[] = {
36177 (char *) "self",(char *) "other", NULL
36178 };
36179
36180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36182 if (!SWIG_IsOK(res1)) {
36183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36184 }
36185 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36187 if (!SWIG_IsOK(res2)) {
36188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36189 }
36190 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36191 {
36192 PyThreadState* __tstate = wxPyBeginAllowThreads();
36193 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36194 wxPyEndAllowThreads(__tstate);
36195 if (PyErr_Occurred()) SWIG_fail;
36196 }
36197 {
36198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36199 }
36200 return resultobj;
36201 fail:
36202 return NULL;
36203 }
36204
36205
36206 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36207 PyObject *resultobj = 0;
36208 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36209 int arg2 ;
36210 void *argp1 = 0 ;
36211 int res1 = 0 ;
36212 int val2 ;
36213 int ecode2 = 0 ;
36214 PyObject *swig_obj[2] ;
36215
36216 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36218 if (!SWIG_IsOK(res1)) {
36219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36220 }
36221 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36222 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36223 if (!SWIG_IsOK(ecode2)) {
36224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36225 }
36226 arg2 = static_cast< int >(val2);
36227 if (arg1) (arg1)->w = arg2;
36228
36229 resultobj = SWIG_Py_Void();
36230 return resultobj;
36231 fail:
36232 return NULL;
36233 }
36234
36235
36236 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36237 PyObject *resultobj = 0;
36238 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36239 int result;
36240 void *argp1 = 0 ;
36241 int res1 = 0 ;
36242 PyObject *swig_obj[1] ;
36243
36244 if (!args) SWIG_fail;
36245 swig_obj[0] = args;
36246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36247 if (!SWIG_IsOK(res1)) {
36248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36249 }
36250 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36251 result = (int) ((arg1)->w);
36252 resultobj = SWIG_From_int(static_cast< int >(result));
36253 return resultobj;
36254 fail:
36255 return NULL;
36256 }
36257
36258
36259 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36260 PyObject *resultobj = 0;
36261 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36262 int arg2 ;
36263 void *argp1 = 0 ;
36264 int res1 = 0 ;
36265 int val2 ;
36266 int ecode2 = 0 ;
36267 PyObject *swig_obj[2] ;
36268
36269 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36271 if (!SWIG_IsOK(res1)) {
36272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36273 }
36274 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36275 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36276 if (!SWIG_IsOK(ecode2)) {
36277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36278 }
36279 arg2 = static_cast< int >(val2);
36280 if (arg1) (arg1)->h = arg2;
36281
36282 resultobj = SWIG_Py_Void();
36283 return resultobj;
36284 fail:
36285 return NULL;
36286 }
36287
36288
36289 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36290 PyObject *resultobj = 0;
36291 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36292 int result;
36293 void *argp1 = 0 ;
36294 int res1 = 0 ;
36295 PyObject *swig_obj[1] ;
36296
36297 if (!args) SWIG_fail;
36298 swig_obj[0] = args;
36299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36300 if (!SWIG_IsOK(res1)) {
36301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36302 }
36303 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36304 result = (int) ((arg1)->h);
36305 resultobj = SWIG_From_int(static_cast< int >(result));
36306 return resultobj;
36307 fail:
36308 return NULL;
36309 }
36310
36311
36312 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36313 PyObject *resultobj = 0;
36314 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36315 int arg2 ;
36316 void *argp1 = 0 ;
36317 int res1 = 0 ;
36318 int val2 ;
36319 int ecode2 = 0 ;
36320 PyObject *swig_obj[2] ;
36321
36322 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36324 if (!SWIG_IsOK(res1)) {
36325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36326 }
36327 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36328 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36329 if (!SWIG_IsOK(ecode2)) {
36330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36331 }
36332 arg2 = static_cast< int >(val2);
36333 if (arg1) (arg1)->bpp = arg2;
36334
36335 resultobj = SWIG_Py_Void();
36336 return resultobj;
36337 fail:
36338 return NULL;
36339 }
36340
36341
36342 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36343 PyObject *resultobj = 0;
36344 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36345 int result;
36346 void *argp1 = 0 ;
36347 int res1 = 0 ;
36348 PyObject *swig_obj[1] ;
36349
36350 if (!args) SWIG_fail;
36351 swig_obj[0] = args;
36352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36353 if (!SWIG_IsOK(res1)) {
36354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36355 }
36356 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36357 result = (int) ((arg1)->bpp);
36358 resultobj = SWIG_From_int(static_cast< int >(result));
36359 return resultobj;
36360 fail:
36361 return NULL;
36362 }
36363
36364
36365 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36366 PyObject *resultobj = 0;
36367 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36368 int arg2 ;
36369 void *argp1 = 0 ;
36370 int res1 = 0 ;
36371 int val2 ;
36372 int ecode2 = 0 ;
36373 PyObject *swig_obj[2] ;
36374
36375 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36377 if (!SWIG_IsOK(res1)) {
36378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36379 }
36380 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36381 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36382 if (!SWIG_IsOK(ecode2)) {
36383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36384 }
36385 arg2 = static_cast< int >(val2);
36386 if (arg1) (arg1)->refresh = arg2;
36387
36388 resultobj = SWIG_Py_Void();
36389 return resultobj;
36390 fail:
36391 return NULL;
36392 }
36393
36394
36395 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36396 PyObject *resultobj = 0;
36397 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36398 int result;
36399 void *argp1 = 0 ;
36400 int res1 = 0 ;
36401 PyObject *swig_obj[1] ;
36402
36403 if (!args) SWIG_fail;
36404 swig_obj[0] = args;
36405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36406 if (!SWIG_IsOK(res1)) {
36407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36408 }
36409 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36410 result = (int) ((arg1)->refresh);
36411 resultobj = SWIG_From_int(static_cast< int >(result));
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36419 PyObject *obj;
36420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36421 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36422 return SWIG_Py_Void();
36423 }
36424
36425 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36426 return SWIG_Python_InitShadowInstance(args);
36427 }
36428
36429 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36430 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36431 return 1;
36432 }
36433
36434
36435 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36436 PyObject *pyobj = 0;
36437
36438 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36439 return pyobj;
36440 }
36441
36442
36443 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36444 PyObject *resultobj = 0;
36445 unsigned int arg1 = (unsigned int) 0 ;
36446 wxDisplay *result = 0 ;
36447 unsigned int val1 ;
36448 int ecode1 = 0 ;
36449 PyObject * obj0 = 0 ;
36450 char * kwnames[] = {
36451 (char *) "index", NULL
36452 };
36453
36454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36455 if (obj0) {
36456 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36457 if (!SWIG_IsOK(ecode1)) {
36458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36459 }
36460 arg1 = static_cast< unsigned int >(val1);
36461 }
36462 {
36463 PyThreadState* __tstate = wxPyBeginAllowThreads();
36464 result = (wxDisplay *)new wxDisplay(arg1);
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36476 PyObject *resultobj = 0;
36477 wxDisplay *arg1 = (wxDisplay *) 0 ;
36478 void *argp1 = 0 ;
36479 int res1 = 0 ;
36480 PyObject *swig_obj[1] ;
36481
36482 if (!args) SWIG_fail;
36483 swig_obj[0] = args;
36484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36485 if (!SWIG_IsOK(res1)) {
36486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36487 }
36488 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36489 {
36490 PyThreadState* __tstate = wxPyBeginAllowThreads();
36491 delete arg1;
36492
36493 wxPyEndAllowThreads(__tstate);
36494 if (PyErr_Occurred()) SWIG_fail;
36495 }
36496 resultobj = SWIG_Py_Void();
36497 return resultobj;
36498 fail:
36499 return NULL;
36500 }
36501
36502
36503 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36504 PyObject *resultobj = 0;
36505 unsigned int result;
36506
36507 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36508 {
36509 PyThreadState* __tstate = wxPyBeginAllowThreads();
36510 result = (unsigned int)wxDisplay::GetCount();
36511 wxPyEndAllowThreads(__tstate);
36512 if (PyErr_Occurred()) SWIG_fail;
36513 }
36514 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36515 return resultobj;
36516 fail:
36517 return NULL;
36518 }
36519
36520
36521 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36522 PyObject *resultobj = 0;
36523 wxPoint *arg1 = 0 ;
36524 int result;
36525 wxPoint temp1 ;
36526 PyObject * obj0 = 0 ;
36527 char * kwnames[] = {
36528 (char *) "pt", NULL
36529 };
36530
36531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36532 {
36533 arg1 = &temp1;
36534 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36535 }
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36539 wxPyEndAllowThreads(__tstate);
36540 if (PyErr_Occurred()) SWIG_fail;
36541 }
36542 resultobj = SWIG_From_int(static_cast< int >(result));
36543 return resultobj;
36544 fail:
36545 return NULL;
36546 }
36547
36548
36549 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36550 PyObject *resultobj = 0;
36551 wxWindow *arg1 = (wxWindow *) 0 ;
36552 int result;
36553 void *argp1 = 0 ;
36554 int res1 = 0 ;
36555 PyObject * obj0 = 0 ;
36556 char * kwnames[] = {
36557 (char *) "window", NULL
36558 };
36559
36560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36562 if (!SWIG_IsOK(res1)) {
36563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36564 }
36565 arg1 = reinterpret_cast< wxWindow * >(argp1);
36566 {
36567 PyThreadState* __tstate = wxPyBeginAllowThreads();
36568 result = (int)wxDisplay::GetFromWindow(arg1);
36569 wxPyEndAllowThreads(__tstate);
36570 if (PyErr_Occurred()) SWIG_fail;
36571 }
36572 resultobj = SWIG_From_int(static_cast< int >(result));
36573 return resultobj;
36574 fail:
36575 return NULL;
36576 }
36577
36578
36579 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36580 PyObject *resultobj = 0;
36581 wxDisplay *arg1 = (wxDisplay *) 0 ;
36582 bool result;
36583 void *argp1 = 0 ;
36584 int res1 = 0 ;
36585 PyObject *swig_obj[1] ;
36586
36587 if (!args) SWIG_fail;
36588 swig_obj[0] = args;
36589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36592 }
36593 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36594 {
36595 PyThreadState* __tstate = wxPyBeginAllowThreads();
36596 result = (bool)((wxDisplay const *)arg1)->IsOk();
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 {
36601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36602 }
36603 return resultobj;
36604 fail:
36605 return NULL;
36606 }
36607
36608
36609 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36610 PyObject *resultobj = 0;
36611 wxDisplay *arg1 = (wxDisplay *) 0 ;
36612 wxRect result;
36613 void *argp1 = 0 ;
36614 int res1 = 0 ;
36615 PyObject *swig_obj[1] ;
36616
36617 if (!args) SWIG_fail;
36618 swig_obj[0] = args;
36619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36620 if (!SWIG_IsOK(res1)) {
36621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36622 }
36623 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36624 {
36625 PyThreadState* __tstate = wxPyBeginAllowThreads();
36626 result = ((wxDisplay const *)arg1)->GetGeometry();
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36631 return resultobj;
36632 fail:
36633 return NULL;
36634 }
36635
36636
36637 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36638 PyObject *resultobj = 0;
36639 wxDisplay *arg1 = (wxDisplay *) 0 ;
36640 wxRect result;
36641 void *argp1 = 0 ;
36642 int res1 = 0 ;
36643 PyObject *swig_obj[1] ;
36644
36645 if (!args) SWIG_fail;
36646 swig_obj[0] = args;
36647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36648 if (!SWIG_IsOK(res1)) {
36649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36650 }
36651 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36652 {
36653 PyThreadState* __tstate = wxPyBeginAllowThreads();
36654 result = ((wxDisplay const *)arg1)->GetClientArea();
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36666 PyObject *resultobj = 0;
36667 wxDisplay *arg1 = (wxDisplay *) 0 ;
36668 wxString result;
36669 void *argp1 = 0 ;
36670 int res1 = 0 ;
36671 PyObject *swig_obj[1] ;
36672
36673 if (!args) SWIG_fail;
36674 swig_obj[0] = args;
36675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36676 if (!SWIG_IsOK(res1)) {
36677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36678 }
36679 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36680 {
36681 PyThreadState* __tstate = wxPyBeginAllowThreads();
36682 result = ((wxDisplay const *)arg1)->GetName();
36683 wxPyEndAllowThreads(__tstate);
36684 if (PyErr_Occurred()) SWIG_fail;
36685 }
36686 {
36687 #if wxUSE_UNICODE
36688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36689 #else
36690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36691 #endif
36692 }
36693 return resultobj;
36694 fail:
36695 return NULL;
36696 }
36697
36698
36699 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36700 PyObject *resultobj = 0;
36701 wxDisplay *arg1 = (wxDisplay *) 0 ;
36702 bool result;
36703 void *argp1 = 0 ;
36704 int res1 = 0 ;
36705 PyObject *swig_obj[1] ;
36706
36707 if (!args) SWIG_fail;
36708 swig_obj[0] = args;
36709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36710 if (!SWIG_IsOK(res1)) {
36711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36712 }
36713 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36714 {
36715 PyThreadState* __tstate = wxPyBeginAllowThreads();
36716 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36717 wxPyEndAllowThreads(__tstate);
36718 if (PyErr_Occurred()) SWIG_fail;
36719 }
36720 {
36721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36722 }
36723 return resultobj;
36724 fail:
36725 return NULL;
36726 }
36727
36728
36729 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36730 PyObject *resultobj = 0;
36731 wxDisplay *arg1 = (wxDisplay *) 0 ;
36732 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36733 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36734 PyObject *result = 0 ;
36735 void *argp1 = 0 ;
36736 int res1 = 0 ;
36737 void *argp2 = 0 ;
36738 int res2 = 0 ;
36739 PyObject * obj0 = 0 ;
36740 PyObject * obj1 = 0 ;
36741 char * kwnames[] = {
36742 (char *) "self",(char *) "mode", NULL
36743 };
36744
36745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36747 if (!SWIG_IsOK(res1)) {
36748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36749 }
36750 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36751 if (obj1) {
36752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36753 if (!SWIG_IsOK(res2)) {
36754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36755 }
36756 if (!argp2) {
36757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36758 }
36759 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36760 }
36761 {
36762 PyThreadState* __tstate = wxPyBeginAllowThreads();
36763 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36764 wxPyEndAllowThreads(__tstate);
36765 if (PyErr_Occurred()) SWIG_fail;
36766 }
36767 resultobj = result;
36768 return resultobj;
36769 fail:
36770 return NULL;
36771 }
36772
36773
36774 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36775 PyObject *resultobj = 0;
36776 wxDisplay *arg1 = (wxDisplay *) 0 ;
36777 wxVideoMode result;
36778 void *argp1 = 0 ;
36779 int res1 = 0 ;
36780 PyObject *swig_obj[1] ;
36781
36782 if (!args) SWIG_fail;
36783 swig_obj[0] = args;
36784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36785 if (!SWIG_IsOK(res1)) {
36786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36787 }
36788 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36789 {
36790 PyThreadState* __tstate = wxPyBeginAllowThreads();
36791 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36792 wxPyEndAllowThreads(__tstate);
36793 if (PyErr_Occurred()) SWIG_fail;
36794 }
36795 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36796 return resultobj;
36797 fail:
36798 return NULL;
36799 }
36800
36801
36802 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36803 PyObject *resultobj = 0;
36804 wxDisplay *arg1 = (wxDisplay *) 0 ;
36805 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36806 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36807 bool result;
36808 void *argp1 = 0 ;
36809 int res1 = 0 ;
36810 void *argp2 = 0 ;
36811 int res2 = 0 ;
36812 PyObject * obj0 = 0 ;
36813 PyObject * obj1 = 0 ;
36814 char * kwnames[] = {
36815 (char *) "self",(char *) "mode", NULL
36816 };
36817
36818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36820 if (!SWIG_IsOK(res1)) {
36821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36822 }
36823 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36824 if (obj1) {
36825 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36826 if (!SWIG_IsOK(res2)) {
36827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36828 }
36829 if (!argp2) {
36830 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36831 }
36832 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36833 }
36834 {
36835 PyThreadState* __tstate = wxPyBeginAllowThreads();
36836 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36837 wxPyEndAllowThreads(__tstate);
36838 if (PyErr_Occurred()) SWIG_fail;
36839 }
36840 {
36841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36842 }
36843 return resultobj;
36844 fail:
36845 return NULL;
36846 }
36847
36848
36849 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36850 PyObject *resultobj = 0;
36851 wxDisplay *arg1 = (wxDisplay *) 0 ;
36852 void *argp1 = 0 ;
36853 int res1 = 0 ;
36854 PyObject *swig_obj[1] ;
36855
36856 if (!args) SWIG_fail;
36857 swig_obj[0] = args;
36858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36859 if (!SWIG_IsOK(res1)) {
36860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36861 }
36862 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36863 {
36864 PyThreadState* __tstate = wxPyBeginAllowThreads();
36865 wxDisplay_ResetMode(arg1);
36866 wxPyEndAllowThreads(__tstate);
36867 if (PyErr_Occurred()) SWIG_fail;
36868 }
36869 resultobj = SWIG_Py_Void();
36870 return resultobj;
36871 fail:
36872 return NULL;
36873 }
36874
36875
36876 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36877 PyObject *obj;
36878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36879 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36880 return SWIG_Py_Void();
36881 }
36882
36883 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36884 return SWIG_Python_InitShadowInstance(args);
36885 }
36886
36887 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36888 PyObject *resultobj = 0;
36889 wxStandardPaths *result = 0 ;
36890
36891 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36892 {
36893 PyThreadState* __tstate = wxPyBeginAllowThreads();
36894 result = (wxStandardPaths *)wxStandardPaths_Get();
36895 wxPyEndAllowThreads(__tstate);
36896 if (PyErr_Occurred()) SWIG_fail;
36897 }
36898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36899 return resultobj;
36900 fail:
36901 return NULL;
36902 }
36903
36904
36905 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36906 PyObject *resultobj = 0;
36907 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36908 wxString result;
36909 void *argp1 = 0 ;
36910 int res1 = 0 ;
36911 PyObject *swig_obj[1] ;
36912
36913 if (!args) SWIG_fail;
36914 swig_obj[0] = args;
36915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36916 if (!SWIG_IsOK(res1)) {
36917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36918 }
36919 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36920 {
36921 PyThreadState* __tstate = wxPyBeginAllowThreads();
36922 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36923 wxPyEndAllowThreads(__tstate);
36924 if (PyErr_Occurred()) SWIG_fail;
36925 }
36926 {
36927 #if wxUSE_UNICODE
36928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36929 #else
36930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36931 #endif
36932 }
36933 return resultobj;
36934 fail:
36935 return NULL;
36936 }
36937
36938
36939 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36940 PyObject *resultobj = 0;
36941 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36942 wxString result;
36943 void *argp1 = 0 ;
36944 int res1 = 0 ;
36945 PyObject *swig_obj[1] ;
36946
36947 if (!args) SWIG_fail;
36948 swig_obj[0] = args;
36949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36950 if (!SWIG_IsOK(res1)) {
36951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36952 }
36953 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 {
36961 #if wxUSE_UNICODE
36962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36963 #else
36964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36965 #endif
36966 }
36967 return resultobj;
36968 fail:
36969 return NULL;
36970 }
36971
36972
36973 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36974 PyObject *resultobj = 0;
36975 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36976 wxString result;
36977 void *argp1 = 0 ;
36978 int res1 = 0 ;
36979 PyObject *swig_obj[1] ;
36980
36981 if (!args) SWIG_fail;
36982 swig_obj[0] = args;
36983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36984 if (!SWIG_IsOK(res1)) {
36985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36986 }
36987 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36988 {
36989 PyThreadState* __tstate = wxPyBeginAllowThreads();
36990 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36991 wxPyEndAllowThreads(__tstate);
36992 if (PyErr_Occurred()) SWIG_fail;
36993 }
36994 {
36995 #if wxUSE_UNICODE
36996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36997 #else
36998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36999 #endif
37000 }
37001 return resultobj;
37002 fail:
37003 return NULL;
37004 }
37005
37006
37007 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37008 PyObject *resultobj = 0;
37009 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37010 wxString result;
37011 void *argp1 = 0 ;
37012 int res1 = 0 ;
37013 PyObject *swig_obj[1] ;
37014
37015 if (!args) SWIG_fail;
37016 swig_obj[0] = args;
37017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37018 if (!SWIG_IsOK(res1)) {
37019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37020 }
37021 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37022 {
37023 PyThreadState* __tstate = wxPyBeginAllowThreads();
37024 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37025 wxPyEndAllowThreads(__tstate);
37026 if (PyErr_Occurred()) SWIG_fail;
37027 }
37028 {
37029 #if wxUSE_UNICODE
37030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37031 #else
37032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37033 #endif
37034 }
37035 return resultobj;
37036 fail:
37037 return NULL;
37038 }
37039
37040
37041 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37042 PyObject *resultobj = 0;
37043 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37044 wxString result;
37045 void *argp1 = 0 ;
37046 int res1 = 0 ;
37047 PyObject *swig_obj[1] ;
37048
37049 if (!args) SWIG_fail;
37050 swig_obj[0] = args;
37051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37052 if (!SWIG_IsOK(res1)) {
37053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37054 }
37055 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37056 {
37057 PyThreadState* __tstate = wxPyBeginAllowThreads();
37058 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37059 wxPyEndAllowThreads(__tstate);
37060 if (PyErr_Occurred()) SWIG_fail;
37061 }
37062 {
37063 #if wxUSE_UNICODE
37064 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37065 #else
37066 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37067 #endif
37068 }
37069 return resultobj;
37070 fail:
37071 return NULL;
37072 }
37073
37074
37075 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37076 PyObject *resultobj = 0;
37077 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37078 wxString result;
37079 void *argp1 = 0 ;
37080 int res1 = 0 ;
37081 PyObject *swig_obj[1] ;
37082
37083 if (!args) SWIG_fail;
37084 swig_obj[0] = args;
37085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37086 if (!SWIG_IsOK(res1)) {
37087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37088 }
37089 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37090 {
37091 PyThreadState* __tstate = wxPyBeginAllowThreads();
37092 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37093 wxPyEndAllowThreads(__tstate);
37094 if (PyErr_Occurred()) SWIG_fail;
37095 }
37096 {
37097 #if wxUSE_UNICODE
37098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37099 #else
37100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37101 #endif
37102 }
37103 return resultobj;
37104 fail:
37105 return NULL;
37106 }
37107
37108
37109 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37110 PyObject *resultobj = 0;
37111 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37112 wxString result;
37113 void *argp1 = 0 ;
37114 int res1 = 0 ;
37115 PyObject *swig_obj[1] ;
37116
37117 if (!args) SWIG_fail;
37118 swig_obj[0] = args;
37119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37120 if (!SWIG_IsOK(res1)) {
37121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37122 }
37123 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37124 {
37125 PyThreadState* __tstate = wxPyBeginAllowThreads();
37126 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37127 wxPyEndAllowThreads(__tstate);
37128 if (PyErr_Occurred()) SWIG_fail;
37129 }
37130 {
37131 #if wxUSE_UNICODE
37132 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37133 #else
37134 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37135 #endif
37136 }
37137 return resultobj;
37138 fail:
37139 return NULL;
37140 }
37141
37142
37143 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37144 PyObject *resultobj = 0;
37145 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37146 wxString result;
37147 void *argp1 = 0 ;
37148 int res1 = 0 ;
37149 PyObject *swig_obj[1] ;
37150
37151 if (!args) SWIG_fail;
37152 swig_obj[0] = args;
37153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37154 if (!SWIG_IsOK(res1)) {
37155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37156 }
37157 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 {
37165 #if wxUSE_UNICODE
37166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37167 #else
37168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37169 #endif
37170 }
37171 return resultobj;
37172 fail:
37173 return NULL;
37174 }
37175
37176
37177 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37178 PyObject *resultobj = 0;
37179 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37180 wxString *arg2 = 0 ;
37181 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37182 wxString result;
37183 void *argp1 = 0 ;
37184 int res1 = 0 ;
37185 bool temp2 = false ;
37186 int val3 ;
37187 int ecode3 = 0 ;
37188 PyObject * obj0 = 0 ;
37189 PyObject * obj1 = 0 ;
37190 PyObject * obj2 = 0 ;
37191 char * kwnames[] = {
37192 (char *) "self",(char *) "lang",(char *) "category", NULL
37193 };
37194
37195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37197 if (!SWIG_IsOK(res1)) {
37198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37199 }
37200 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37201 {
37202 arg2 = wxString_in_helper(obj1);
37203 if (arg2 == NULL) SWIG_fail;
37204 temp2 = true;
37205 }
37206 if (obj2) {
37207 ecode3 = SWIG_AsVal_int(obj2, &val3);
37208 if (!SWIG_IsOK(ecode3)) {
37209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37210 }
37211 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37212 }
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37216 wxPyEndAllowThreads(__tstate);
37217 if (PyErr_Occurred()) SWIG_fail;
37218 }
37219 {
37220 #if wxUSE_UNICODE
37221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37222 #else
37223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37224 #endif
37225 }
37226 {
37227 if (temp2)
37228 delete arg2;
37229 }
37230 return resultobj;
37231 fail:
37232 {
37233 if (temp2)
37234 delete arg2;
37235 }
37236 return NULL;
37237 }
37238
37239
37240 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37241 PyObject *resultobj = 0;
37242 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37243 wxString result;
37244 void *argp1 = 0 ;
37245 int res1 = 0 ;
37246 PyObject *swig_obj[1] ;
37247
37248 if (!args) SWIG_fail;
37249 swig_obj[0] = args;
37250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37251 if (!SWIG_IsOK(res1)) {
37252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37253 }
37254 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37255 {
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 {
37262 #if wxUSE_UNICODE
37263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37264 #else
37265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37266 #endif
37267 }
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37275 PyObject *resultobj = 0;
37276 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37277 wxString result;
37278 void *argp1 = 0 ;
37279 int res1 = 0 ;
37280 PyObject *swig_obj[1] ;
37281
37282 if (!args) SWIG_fail;
37283 swig_obj[0] = args;
37284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37285 if (!SWIG_IsOK(res1)) {
37286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37287 }
37288 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 {
37296 #if wxUSE_UNICODE
37297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37298 #else
37299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37300 #endif
37301 }
37302 return resultobj;
37303 fail:
37304 return NULL;
37305 }
37306
37307
37308 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37309 PyObject *resultobj = 0;
37310 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37311 wxString *arg2 = 0 ;
37312 void *argp1 = 0 ;
37313 int res1 = 0 ;
37314 bool temp2 = false ;
37315 PyObject * obj0 = 0 ;
37316 PyObject * obj1 = 0 ;
37317 char * kwnames[] = {
37318 (char *) "self",(char *) "prefix", NULL
37319 };
37320
37321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37323 if (!SWIG_IsOK(res1)) {
37324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37325 }
37326 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37327 {
37328 arg2 = wxString_in_helper(obj1);
37329 if (arg2 == NULL) SWIG_fail;
37330 temp2 = true;
37331 }
37332 {
37333 PyThreadState* __tstate = wxPyBeginAllowThreads();
37334 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37335 wxPyEndAllowThreads(__tstate);
37336 if (PyErr_Occurred()) SWIG_fail;
37337 }
37338 resultobj = SWIG_Py_Void();
37339 {
37340 if (temp2)
37341 delete arg2;
37342 }
37343 return resultobj;
37344 fail:
37345 {
37346 if (temp2)
37347 delete arg2;
37348 }
37349 return NULL;
37350 }
37351
37352
37353 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37354 PyObject *resultobj = 0;
37355 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37356 wxString result;
37357 void *argp1 = 0 ;
37358 int res1 = 0 ;
37359 PyObject *swig_obj[1] ;
37360
37361 if (!args) SWIG_fail;
37362 swig_obj[0] = args;
37363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37364 if (!SWIG_IsOK(res1)) {
37365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37366 }
37367 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37368 {
37369 PyThreadState* __tstate = wxPyBeginAllowThreads();
37370 result = wxStandardPaths_GetInstallPrefix(arg1);
37371 wxPyEndAllowThreads(__tstate);
37372 if (PyErr_Occurred()) SWIG_fail;
37373 }
37374 {
37375 #if wxUSE_UNICODE
37376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37377 #else
37378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37379 #endif
37380 }
37381 return resultobj;
37382 fail:
37383 return NULL;
37384 }
37385
37386
37387 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37388 PyObject *obj;
37389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37390 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37391 return SWIG_Py_Void();
37392 }
37393
37394 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37395 PyObject *resultobj = 0;
37396 wxEventType arg1 ;
37397 wxPowerEvent *result = 0 ;
37398 int val1 ;
37399 int ecode1 = 0 ;
37400 PyObject * obj0 = 0 ;
37401 char * kwnames[] = {
37402 (char *) "evtType", NULL
37403 };
37404
37405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37406 ecode1 = SWIG_AsVal_int(obj0, &val1);
37407 if (!SWIG_IsOK(ecode1)) {
37408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37409 }
37410 arg1 = static_cast< wxEventType >(val1);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37425 PyObject *resultobj = 0;
37426 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37427 void *argp1 = 0 ;
37428 int res1 = 0 ;
37429 PyObject *swig_obj[1] ;
37430
37431 if (!args) SWIG_fail;
37432 swig_obj[0] = args;
37433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37434 if (!SWIG_IsOK(res1)) {
37435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37436 }
37437 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37438 {
37439 PyThreadState* __tstate = wxPyBeginAllowThreads();
37440 (arg1)->Veto();
37441 wxPyEndAllowThreads(__tstate);
37442 if (PyErr_Occurred()) SWIG_fail;
37443 }
37444 resultobj = SWIG_Py_Void();
37445 return resultobj;
37446 fail:
37447 return NULL;
37448 }
37449
37450
37451 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37452 PyObject *resultobj = 0;
37453 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37454 bool result;
37455 void *argp1 = 0 ;
37456 int res1 = 0 ;
37457 PyObject *swig_obj[1] ;
37458
37459 if (!args) SWIG_fail;
37460 swig_obj[0] = args;
37461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37462 if (!SWIG_IsOK(res1)) {
37463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37464 }
37465 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37466 {
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 {
37473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37474 }
37475 return resultobj;
37476 fail:
37477 return NULL;
37478 }
37479
37480
37481 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37482 PyObject *obj;
37483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37484 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37485 return SWIG_Py_Void();
37486 }
37487
37488 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37489 return SWIG_Python_InitShadowInstance(args);
37490 }
37491
37492 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37493 PyObject *resultobj = 0;
37494 wxPowerType result;
37495
37496 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37497 {
37498 PyThreadState* __tstate = wxPyBeginAllowThreads();
37499 result = (wxPowerType)wxGetPowerType();
37500 wxPyEndAllowThreads(__tstate);
37501 if (PyErr_Occurred()) SWIG_fail;
37502 }
37503 resultobj = SWIG_From_int(static_cast< int >(result));
37504 return resultobj;
37505 fail:
37506 return NULL;
37507 }
37508
37509
37510 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37511 PyObject *resultobj = 0;
37512 wxBatteryState result;
37513
37514 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37515 {
37516 PyThreadState* __tstate = wxPyBeginAllowThreads();
37517 result = (wxBatteryState)wxGetBatteryState();
37518 wxPyEndAllowThreads(__tstate);
37519 if (PyErr_Occurred()) SWIG_fail;
37520 }
37521 resultobj = SWIG_From_int(static_cast< int >(result));
37522 return resultobj;
37523 fail:
37524 return NULL;
37525 }
37526
37527
37528 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37529 PyObject *resultobj = 0;
37530 wxAboutDialogInfo *result = 0 ;
37531
37532 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37533 {
37534 PyThreadState* __tstate = wxPyBeginAllowThreads();
37535 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37536 wxPyEndAllowThreads(__tstate);
37537 if (PyErr_Occurred()) SWIG_fail;
37538 }
37539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37540 return resultobj;
37541 fail:
37542 return NULL;
37543 }
37544
37545
37546 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37547 PyObject *resultobj = 0;
37548 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37549 void *argp1 = 0 ;
37550 int res1 = 0 ;
37551 PyObject *swig_obj[1] ;
37552
37553 if (!args) SWIG_fail;
37554 swig_obj[0] = args;
37555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37556 if (!SWIG_IsOK(res1)) {
37557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37558 }
37559 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37560 {
37561 PyThreadState* __tstate = wxPyBeginAllowThreads();
37562 delete arg1;
37563
37564 wxPyEndAllowThreads(__tstate);
37565 if (PyErr_Occurred()) SWIG_fail;
37566 }
37567 resultobj = SWIG_Py_Void();
37568 return resultobj;
37569 fail:
37570 return NULL;
37571 }
37572
37573
37574 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37575 PyObject *resultobj = 0;
37576 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37577 wxString *arg2 = 0 ;
37578 void *argp1 = 0 ;
37579 int res1 = 0 ;
37580 bool temp2 = false ;
37581 PyObject * obj0 = 0 ;
37582 PyObject * obj1 = 0 ;
37583 char * kwnames[] = {
37584 (char *) "self",(char *) "name", NULL
37585 };
37586
37587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37589 if (!SWIG_IsOK(res1)) {
37590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37591 }
37592 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37593 {
37594 arg2 = wxString_in_helper(obj1);
37595 if (arg2 == NULL) SWIG_fail;
37596 temp2 = true;
37597 }
37598 {
37599 PyThreadState* __tstate = wxPyBeginAllowThreads();
37600 (arg1)->SetName((wxString const &)*arg2);
37601 wxPyEndAllowThreads(__tstate);
37602 if (PyErr_Occurred()) SWIG_fail;
37603 }
37604 resultobj = SWIG_Py_Void();
37605 {
37606 if (temp2)
37607 delete arg2;
37608 }
37609 return resultobj;
37610 fail:
37611 {
37612 if (temp2)
37613 delete arg2;
37614 }
37615 return NULL;
37616 }
37617
37618
37619 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37620 PyObject *resultobj = 0;
37621 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37622 wxString result;
37623 void *argp1 = 0 ;
37624 int res1 = 0 ;
37625 PyObject *swig_obj[1] ;
37626
37627 if (!args) SWIG_fail;
37628 swig_obj[0] = args;
37629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37630 if (!SWIG_IsOK(res1)) {
37631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37632 }
37633 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37634 {
37635 PyThreadState* __tstate = wxPyBeginAllowThreads();
37636 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37637 wxPyEndAllowThreads(__tstate);
37638 if (PyErr_Occurred()) SWIG_fail;
37639 }
37640 {
37641 #if wxUSE_UNICODE
37642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37643 #else
37644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37645 #endif
37646 }
37647 return resultobj;
37648 fail:
37649 return NULL;
37650 }
37651
37652
37653 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37654 PyObject *resultobj = 0;
37655 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37656 wxString *arg2 = 0 ;
37657 void *argp1 = 0 ;
37658 int res1 = 0 ;
37659 bool temp2 = false ;
37660 PyObject * obj0 = 0 ;
37661 PyObject * obj1 = 0 ;
37662 char * kwnames[] = {
37663 (char *) "self",(char *) "version", NULL
37664 };
37665
37666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37668 if (!SWIG_IsOK(res1)) {
37669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37670 }
37671 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37672 {
37673 arg2 = wxString_in_helper(obj1);
37674 if (arg2 == NULL) SWIG_fail;
37675 temp2 = true;
37676 }
37677 {
37678 PyThreadState* __tstate = wxPyBeginAllowThreads();
37679 (arg1)->SetVersion((wxString const &)*arg2);
37680 wxPyEndAllowThreads(__tstate);
37681 if (PyErr_Occurred()) SWIG_fail;
37682 }
37683 resultobj = SWIG_Py_Void();
37684 {
37685 if (temp2)
37686 delete arg2;
37687 }
37688 return resultobj;
37689 fail:
37690 {
37691 if (temp2)
37692 delete arg2;
37693 }
37694 return NULL;
37695 }
37696
37697
37698 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37699 PyObject *resultobj = 0;
37700 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37701 bool result;
37702 void *argp1 = 0 ;
37703 int res1 = 0 ;
37704 PyObject *swig_obj[1] ;
37705
37706 if (!args) SWIG_fail;
37707 swig_obj[0] = args;
37708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37709 if (!SWIG_IsOK(res1)) {
37710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37711 }
37712 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37713 {
37714 PyThreadState* __tstate = wxPyBeginAllowThreads();
37715 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37716 wxPyEndAllowThreads(__tstate);
37717 if (PyErr_Occurred()) SWIG_fail;
37718 }
37719 {
37720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37721 }
37722 return resultobj;
37723 fail:
37724 return NULL;
37725 }
37726
37727
37728 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37729 PyObject *resultobj = 0;
37730 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37731 wxString result;
37732 void *argp1 = 0 ;
37733 int res1 = 0 ;
37734 PyObject *swig_obj[1] ;
37735
37736 if (!args) SWIG_fail;
37737 swig_obj[0] = args;
37738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37739 if (!SWIG_IsOK(res1)) {
37740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37741 }
37742 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37743 {
37744 PyThreadState* __tstate = wxPyBeginAllowThreads();
37745 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37746 wxPyEndAllowThreads(__tstate);
37747 if (PyErr_Occurred()) SWIG_fail;
37748 }
37749 {
37750 #if wxUSE_UNICODE
37751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37752 #else
37753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37754 #endif
37755 }
37756 return resultobj;
37757 fail:
37758 return NULL;
37759 }
37760
37761
37762 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37763 PyObject *resultobj = 0;
37764 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37765 wxString *arg2 = 0 ;
37766 void *argp1 = 0 ;
37767 int res1 = 0 ;
37768 bool temp2 = false ;
37769 PyObject * obj0 = 0 ;
37770 PyObject * obj1 = 0 ;
37771 char * kwnames[] = {
37772 (char *) "self",(char *) "desc", NULL
37773 };
37774
37775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37777 if (!SWIG_IsOK(res1)) {
37778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37779 }
37780 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37781 {
37782 arg2 = wxString_in_helper(obj1);
37783 if (arg2 == NULL) SWIG_fail;
37784 temp2 = true;
37785 }
37786 {
37787 PyThreadState* __tstate = wxPyBeginAllowThreads();
37788 (arg1)->SetDescription((wxString const &)*arg2);
37789 wxPyEndAllowThreads(__tstate);
37790 if (PyErr_Occurred()) SWIG_fail;
37791 }
37792 resultobj = SWIG_Py_Void();
37793 {
37794 if (temp2)
37795 delete arg2;
37796 }
37797 return resultobj;
37798 fail:
37799 {
37800 if (temp2)
37801 delete arg2;
37802 }
37803 return NULL;
37804 }
37805
37806
37807 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37808 PyObject *resultobj = 0;
37809 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37810 bool result;
37811 void *argp1 = 0 ;
37812 int res1 = 0 ;
37813 PyObject *swig_obj[1] ;
37814
37815 if (!args) SWIG_fail;
37816 swig_obj[0] = args;
37817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37818 if (!SWIG_IsOK(res1)) {
37819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37820 }
37821 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37822 {
37823 PyThreadState* __tstate = wxPyBeginAllowThreads();
37824 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37825 wxPyEndAllowThreads(__tstate);
37826 if (PyErr_Occurred()) SWIG_fail;
37827 }
37828 {
37829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37830 }
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37838 PyObject *resultobj = 0;
37839 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37840 wxString result;
37841 void *argp1 = 0 ;
37842 int res1 = 0 ;
37843 PyObject *swig_obj[1] ;
37844
37845 if (!args) SWIG_fail;
37846 swig_obj[0] = args;
37847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37848 if (!SWIG_IsOK(res1)) {
37849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37850 }
37851 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37852 {
37853 PyThreadState* __tstate = wxPyBeginAllowThreads();
37854 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37855 wxPyEndAllowThreads(__tstate);
37856 if (PyErr_Occurred()) SWIG_fail;
37857 }
37858 {
37859 #if wxUSE_UNICODE
37860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37861 #else
37862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37863 #endif
37864 }
37865 return resultobj;
37866 fail:
37867 return NULL;
37868 }
37869
37870
37871 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37872 PyObject *resultobj = 0;
37873 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37874 wxString *arg2 = 0 ;
37875 void *argp1 = 0 ;
37876 int res1 = 0 ;
37877 bool temp2 = false ;
37878 PyObject * obj0 = 0 ;
37879 PyObject * obj1 = 0 ;
37880 char * kwnames[] = {
37881 (char *) "self",(char *) "copyright", NULL
37882 };
37883
37884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37886 if (!SWIG_IsOK(res1)) {
37887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37888 }
37889 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37890 {
37891 arg2 = wxString_in_helper(obj1);
37892 if (arg2 == NULL) SWIG_fail;
37893 temp2 = true;
37894 }
37895 {
37896 PyThreadState* __tstate = wxPyBeginAllowThreads();
37897 (arg1)->SetCopyright((wxString const &)*arg2);
37898 wxPyEndAllowThreads(__tstate);
37899 if (PyErr_Occurred()) SWIG_fail;
37900 }
37901 resultobj = SWIG_Py_Void();
37902 {
37903 if (temp2)
37904 delete arg2;
37905 }
37906 return resultobj;
37907 fail:
37908 {
37909 if (temp2)
37910 delete arg2;
37911 }
37912 return NULL;
37913 }
37914
37915
37916 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37917 PyObject *resultobj = 0;
37918 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37919 bool result;
37920 void *argp1 = 0 ;
37921 int res1 = 0 ;
37922 PyObject *swig_obj[1] ;
37923
37924 if (!args) SWIG_fail;
37925 swig_obj[0] = args;
37926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37927 if (!SWIG_IsOK(res1)) {
37928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37929 }
37930 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37931 {
37932 PyThreadState* __tstate = wxPyBeginAllowThreads();
37933 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37934 wxPyEndAllowThreads(__tstate);
37935 if (PyErr_Occurred()) SWIG_fail;
37936 }
37937 {
37938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37939 }
37940 return resultobj;
37941 fail:
37942 return NULL;
37943 }
37944
37945
37946 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37947 PyObject *resultobj = 0;
37948 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37949 wxString result;
37950 void *argp1 = 0 ;
37951 int res1 = 0 ;
37952 PyObject *swig_obj[1] ;
37953
37954 if (!args) SWIG_fail;
37955 swig_obj[0] = args;
37956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37957 if (!SWIG_IsOK(res1)) {
37958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37959 }
37960 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37961 {
37962 PyThreadState* __tstate = wxPyBeginAllowThreads();
37963 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37964 wxPyEndAllowThreads(__tstate);
37965 if (PyErr_Occurred()) SWIG_fail;
37966 }
37967 {
37968 #if wxUSE_UNICODE
37969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37970 #else
37971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37972 #endif
37973 }
37974 return resultobj;
37975 fail:
37976 return NULL;
37977 }
37978
37979
37980 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37981 PyObject *resultobj = 0;
37982 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37983 wxString *arg2 = 0 ;
37984 void *argp1 = 0 ;
37985 int res1 = 0 ;
37986 bool temp2 = false ;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 char * kwnames[] = {
37990 (char *) "self",(char *) "licence", NULL
37991 };
37992
37993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37995 if (!SWIG_IsOK(res1)) {
37996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37997 }
37998 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37999 {
38000 arg2 = wxString_in_helper(obj1);
38001 if (arg2 == NULL) SWIG_fail;
38002 temp2 = true;
38003 }
38004 {
38005 PyThreadState* __tstate = wxPyBeginAllowThreads();
38006 (arg1)->SetLicence((wxString const &)*arg2);
38007 wxPyEndAllowThreads(__tstate);
38008 if (PyErr_Occurred()) SWIG_fail;
38009 }
38010 resultobj = SWIG_Py_Void();
38011 {
38012 if (temp2)
38013 delete arg2;
38014 }
38015 return resultobj;
38016 fail:
38017 {
38018 if (temp2)
38019 delete arg2;
38020 }
38021 return NULL;
38022 }
38023
38024
38025 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38026 PyObject *resultobj = 0;
38027 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38028 wxString *arg2 = 0 ;
38029 void *argp1 = 0 ;
38030 int res1 = 0 ;
38031 bool temp2 = false ;
38032 PyObject * obj0 = 0 ;
38033 PyObject * obj1 = 0 ;
38034 char * kwnames[] = {
38035 (char *) "self",(char *) "licence", NULL
38036 };
38037
38038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38040 if (!SWIG_IsOK(res1)) {
38041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38042 }
38043 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38044 {
38045 arg2 = wxString_in_helper(obj1);
38046 if (arg2 == NULL) SWIG_fail;
38047 temp2 = true;
38048 }
38049 {
38050 PyThreadState* __tstate = wxPyBeginAllowThreads();
38051 (arg1)->SetLicense((wxString const &)*arg2);
38052 wxPyEndAllowThreads(__tstate);
38053 if (PyErr_Occurred()) SWIG_fail;
38054 }
38055 resultobj = SWIG_Py_Void();
38056 {
38057 if (temp2)
38058 delete arg2;
38059 }
38060 return resultobj;
38061 fail:
38062 {
38063 if (temp2)
38064 delete arg2;
38065 }
38066 return NULL;
38067 }
38068
38069
38070 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38071 PyObject *resultobj = 0;
38072 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38073 bool result;
38074 void *argp1 = 0 ;
38075 int res1 = 0 ;
38076 PyObject *swig_obj[1] ;
38077
38078 if (!args) SWIG_fail;
38079 swig_obj[0] = args;
38080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38081 if (!SWIG_IsOK(res1)) {
38082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38083 }
38084 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38085 {
38086 PyThreadState* __tstate = wxPyBeginAllowThreads();
38087 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38088 wxPyEndAllowThreads(__tstate);
38089 if (PyErr_Occurred()) SWIG_fail;
38090 }
38091 {
38092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38093 }
38094 return resultobj;
38095 fail:
38096 return NULL;
38097 }
38098
38099
38100 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38101 PyObject *resultobj = 0;
38102 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38103 wxString result;
38104 void *argp1 = 0 ;
38105 int res1 = 0 ;
38106 PyObject *swig_obj[1] ;
38107
38108 if (!args) SWIG_fail;
38109 swig_obj[0] = args;
38110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38111 if (!SWIG_IsOK(res1)) {
38112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38113 }
38114 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38115 {
38116 PyThreadState* __tstate = wxPyBeginAllowThreads();
38117 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38118 wxPyEndAllowThreads(__tstate);
38119 if (PyErr_Occurred()) SWIG_fail;
38120 }
38121 {
38122 #if wxUSE_UNICODE
38123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38124 #else
38125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38126 #endif
38127 }
38128 return resultobj;
38129 fail:
38130 return NULL;
38131 }
38132
38133
38134 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38135 PyObject *resultobj = 0;
38136 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38137 wxIcon *arg2 = 0 ;
38138 void *argp1 = 0 ;
38139 int res1 = 0 ;
38140 void *argp2 = 0 ;
38141 int res2 = 0 ;
38142 PyObject * obj0 = 0 ;
38143 PyObject * obj1 = 0 ;
38144 char * kwnames[] = {
38145 (char *) "self",(char *) "icon", NULL
38146 };
38147
38148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38150 if (!SWIG_IsOK(res1)) {
38151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38152 }
38153 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38154 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38155 if (!SWIG_IsOK(res2)) {
38156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38157 }
38158 if (!argp2) {
38159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38160 }
38161 arg2 = reinterpret_cast< wxIcon * >(argp2);
38162 {
38163 PyThreadState* __tstate = wxPyBeginAllowThreads();
38164 (arg1)->SetIcon((wxIcon const &)*arg2);
38165 wxPyEndAllowThreads(__tstate);
38166 if (PyErr_Occurred()) SWIG_fail;
38167 }
38168 resultobj = SWIG_Py_Void();
38169 return resultobj;
38170 fail:
38171 return NULL;
38172 }
38173
38174
38175 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38176 PyObject *resultobj = 0;
38177 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38178 bool result;
38179 void *argp1 = 0 ;
38180 int res1 = 0 ;
38181 PyObject *swig_obj[1] ;
38182
38183 if (!args) SWIG_fail;
38184 swig_obj[0] = args;
38185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38186 if (!SWIG_IsOK(res1)) {
38187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38188 }
38189 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38190 {
38191 PyThreadState* __tstate = wxPyBeginAllowThreads();
38192 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38193 wxPyEndAllowThreads(__tstate);
38194 if (PyErr_Occurred()) SWIG_fail;
38195 }
38196 {
38197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38198 }
38199 return resultobj;
38200 fail:
38201 return NULL;
38202 }
38203
38204
38205 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38206 PyObject *resultobj = 0;
38207 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38208 wxIcon result;
38209 void *argp1 = 0 ;
38210 int res1 = 0 ;
38211 PyObject *swig_obj[1] ;
38212
38213 if (!args) SWIG_fail;
38214 swig_obj[0] = args;
38215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38216 if (!SWIG_IsOK(res1)) {
38217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38218 }
38219 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38220 {
38221 PyThreadState* __tstate = wxPyBeginAllowThreads();
38222 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38223 wxPyEndAllowThreads(__tstate);
38224 if (PyErr_Occurred()) SWIG_fail;
38225 }
38226 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38227 return resultobj;
38228 fail:
38229 return NULL;
38230 }
38231
38232
38233 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38234 PyObject *resultobj = 0;
38235 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38236 wxString *arg2 = 0 ;
38237 wxString const &arg3_defvalue = wxEmptyString ;
38238 wxString *arg3 = (wxString *) &arg3_defvalue ;
38239 void *argp1 = 0 ;
38240 int res1 = 0 ;
38241 bool temp2 = false ;
38242 bool temp3 = false ;
38243 PyObject * obj0 = 0 ;
38244 PyObject * obj1 = 0 ;
38245 PyObject * obj2 = 0 ;
38246 char * kwnames[] = {
38247 (char *) "self",(char *) "url",(char *) "desc", NULL
38248 };
38249
38250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38252 if (!SWIG_IsOK(res1)) {
38253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38254 }
38255 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38256 {
38257 arg2 = wxString_in_helper(obj1);
38258 if (arg2 == NULL) SWIG_fail;
38259 temp2 = true;
38260 }
38261 if (obj2) {
38262 {
38263 arg3 = wxString_in_helper(obj2);
38264 if (arg3 == NULL) SWIG_fail;
38265 temp3 = true;
38266 }
38267 }
38268 {
38269 PyThreadState* __tstate = wxPyBeginAllowThreads();
38270 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38271 wxPyEndAllowThreads(__tstate);
38272 if (PyErr_Occurred()) SWIG_fail;
38273 }
38274 resultobj = SWIG_Py_Void();
38275 {
38276 if (temp2)
38277 delete arg2;
38278 }
38279 {
38280 if (temp3)
38281 delete arg3;
38282 }
38283 return resultobj;
38284 fail:
38285 {
38286 if (temp2)
38287 delete arg2;
38288 }
38289 {
38290 if (temp3)
38291 delete arg3;
38292 }
38293 return NULL;
38294 }
38295
38296
38297 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38298 PyObject *resultobj = 0;
38299 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38300 wxString result;
38301 void *argp1 = 0 ;
38302 int res1 = 0 ;
38303 PyObject *swig_obj[1] ;
38304
38305 if (!args) SWIG_fail;
38306 swig_obj[0] = args;
38307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38308 if (!SWIG_IsOK(res1)) {
38309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38310 }
38311 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38315 wxPyEndAllowThreads(__tstate);
38316 if (PyErr_Occurred()) SWIG_fail;
38317 }
38318 {
38319 #if wxUSE_UNICODE
38320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38321 #else
38322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38323 #endif
38324 }
38325 return resultobj;
38326 fail:
38327 return NULL;
38328 }
38329
38330
38331 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38332 PyObject *resultobj = 0;
38333 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38334 wxString result;
38335 void *argp1 = 0 ;
38336 int res1 = 0 ;
38337 PyObject *swig_obj[1] ;
38338
38339 if (!args) SWIG_fail;
38340 swig_obj[0] = args;
38341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38342 if (!SWIG_IsOK(res1)) {
38343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38344 }
38345 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38346 {
38347 PyThreadState* __tstate = wxPyBeginAllowThreads();
38348 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38349 wxPyEndAllowThreads(__tstate);
38350 if (PyErr_Occurred()) SWIG_fail;
38351 }
38352 {
38353 #if wxUSE_UNICODE
38354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38355 #else
38356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38357 #endif
38358 }
38359 return resultobj;
38360 fail:
38361 return NULL;
38362 }
38363
38364
38365 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38366 PyObject *resultobj = 0;
38367 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38368 bool result;
38369 void *argp1 = 0 ;
38370 int res1 = 0 ;
38371 PyObject *swig_obj[1] ;
38372
38373 if (!args) SWIG_fail;
38374 swig_obj[0] = args;
38375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38376 if (!SWIG_IsOK(res1)) {
38377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38378 }
38379 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38380 {
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38383 wxPyEndAllowThreads(__tstate);
38384 if (PyErr_Occurred()) SWIG_fail;
38385 }
38386 {
38387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38388 }
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj = 0;
38397 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38398 wxArrayString *arg2 = 0 ;
38399 void *argp1 = 0 ;
38400 int res1 = 0 ;
38401 bool temp2 = false ;
38402 PyObject * obj0 = 0 ;
38403 PyObject * obj1 = 0 ;
38404 char * kwnames[] = {
38405 (char *) "self",(char *) "developers", NULL
38406 };
38407
38408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38410 if (!SWIG_IsOK(res1)) {
38411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38412 }
38413 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38414 {
38415 if (! PySequence_Check(obj1)) {
38416 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38417 SWIG_fail;
38418 }
38419 arg2 = new wxArrayString;
38420 temp2 = true;
38421 int i, len=PySequence_Length(obj1);
38422 for (i=0; i<len; i++) {
38423 PyObject* item = PySequence_GetItem(obj1, i);
38424 wxString* s = wxString_in_helper(item);
38425 if (PyErr_Occurred()) SWIG_fail;
38426 arg2->Add(*s);
38427 delete s;
38428 Py_DECREF(item);
38429 }
38430 }
38431 {
38432 PyThreadState* __tstate = wxPyBeginAllowThreads();
38433 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38434 wxPyEndAllowThreads(__tstate);
38435 if (PyErr_Occurred()) SWIG_fail;
38436 }
38437 resultobj = SWIG_Py_Void();
38438 {
38439 if (temp2) delete arg2;
38440 }
38441 return resultobj;
38442 fail:
38443 {
38444 if (temp2) delete arg2;
38445 }
38446 return NULL;
38447 }
38448
38449
38450 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38451 PyObject *resultobj = 0;
38452 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38453 wxString *arg2 = 0 ;
38454 void *argp1 = 0 ;
38455 int res1 = 0 ;
38456 bool temp2 = false ;
38457 PyObject * obj0 = 0 ;
38458 PyObject * obj1 = 0 ;
38459 char * kwnames[] = {
38460 (char *) "self",(char *) "developer", NULL
38461 };
38462
38463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38465 if (!SWIG_IsOK(res1)) {
38466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38467 }
38468 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38469 {
38470 arg2 = wxString_in_helper(obj1);
38471 if (arg2 == NULL) SWIG_fail;
38472 temp2 = true;
38473 }
38474 {
38475 PyThreadState* __tstate = wxPyBeginAllowThreads();
38476 (arg1)->AddDeveloper((wxString const &)*arg2);
38477 wxPyEndAllowThreads(__tstate);
38478 if (PyErr_Occurred()) SWIG_fail;
38479 }
38480 resultobj = SWIG_Py_Void();
38481 {
38482 if (temp2)
38483 delete arg2;
38484 }
38485 return resultobj;
38486 fail:
38487 {
38488 if (temp2)
38489 delete arg2;
38490 }
38491 return NULL;
38492 }
38493
38494
38495 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38496 PyObject *resultobj = 0;
38497 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38498 bool result;
38499 void *argp1 = 0 ;
38500 int res1 = 0 ;
38501 PyObject *swig_obj[1] ;
38502
38503 if (!args) SWIG_fail;
38504 swig_obj[0] = args;
38505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38506 if (!SWIG_IsOK(res1)) {
38507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38508 }
38509 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38510 {
38511 PyThreadState* __tstate = wxPyBeginAllowThreads();
38512 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 {
38517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38518 }
38519 return resultobj;
38520 fail:
38521 return NULL;
38522 }
38523
38524
38525 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38526 PyObject *resultobj = 0;
38527 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38528 wxArrayString *result = 0 ;
38529 void *argp1 = 0 ;
38530 int res1 = 0 ;
38531 PyObject *swig_obj[1] ;
38532
38533 if (!args) SWIG_fail;
38534 swig_obj[0] = args;
38535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38536 if (!SWIG_IsOK(res1)) {
38537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38538 }
38539 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38540 {
38541 PyThreadState* __tstate = wxPyBeginAllowThreads();
38542 {
38543 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38544 result = (wxArrayString *) &_result_ref;
38545 }
38546 wxPyEndAllowThreads(__tstate);
38547 if (PyErr_Occurred()) SWIG_fail;
38548 }
38549 {
38550 resultobj = wxArrayString2PyList_helper(*result);
38551 }
38552 return resultobj;
38553 fail:
38554 return NULL;
38555 }
38556
38557
38558 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38559 PyObject *resultobj = 0;
38560 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38561 wxArrayString *arg2 = 0 ;
38562 void *argp1 = 0 ;
38563 int res1 = 0 ;
38564 bool temp2 = false ;
38565 PyObject * obj0 = 0 ;
38566 PyObject * obj1 = 0 ;
38567 char * kwnames[] = {
38568 (char *) "self",(char *) "docwriters", NULL
38569 };
38570
38571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38573 if (!SWIG_IsOK(res1)) {
38574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38575 }
38576 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38577 {
38578 if (! PySequence_Check(obj1)) {
38579 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38580 SWIG_fail;
38581 }
38582 arg2 = new wxArrayString;
38583 temp2 = true;
38584 int i, len=PySequence_Length(obj1);
38585 for (i=0; i<len; i++) {
38586 PyObject* item = PySequence_GetItem(obj1, i);
38587 wxString* s = wxString_in_helper(item);
38588 if (PyErr_Occurred()) SWIG_fail;
38589 arg2->Add(*s);
38590 delete s;
38591 Py_DECREF(item);
38592 }
38593 }
38594 {
38595 PyThreadState* __tstate = wxPyBeginAllowThreads();
38596 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38597 wxPyEndAllowThreads(__tstate);
38598 if (PyErr_Occurred()) SWIG_fail;
38599 }
38600 resultobj = SWIG_Py_Void();
38601 {
38602 if (temp2) delete arg2;
38603 }
38604 return resultobj;
38605 fail:
38606 {
38607 if (temp2) delete arg2;
38608 }
38609 return NULL;
38610 }
38611
38612
38613 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38614 PyObject *resultobj = 0;
38615 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38616 wxString *arg2 = 0 ;
38617 void *argp1 = 0 ;
38618 int res1 = 0 ;
38619 bool temp2 = false ;
38620 PyObject * obj0 = 0 ;
38621 PyObject * obj1 = 0 ;
38622 char * kwnames[] = {
38623 (char *) "self",(char *) "docwriter", NULL
38624 };
38625
38626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38628 if (!SWIG_IsOK(res1)) {
38629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38630 }
38631 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38632 {
38633 arg2 = wxString_in_helper(obj1);
38634 if (arg2 == NULL) SWIG_fail;
38635 temp2 = true;
38636 }
38637 {
38638 PyThreadState* __tstate = wxPyBeginAllowThreads();
38639 (arg1)->AddDocWriter((wxString const &)*arg2);
38640 wxPyEndAllowThreads(__tstate);
38641 if (PyErr_Occurred()) SWIG_fail;
38642 }
38643 resultobj = SWIG_Py_Void();
38644 {
38645 if (temp2)
38646 delete arg2;
38647 }
38648 return resultobj;
38649 fail:
38650 {
38651 if (temp2)
38652 delete arg2;
38653 }
38654 return NULL;
38655 }
38656
38657
38658 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38659 PyObject *resultobj = 0;
38660 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38661 bool result;
38662 void *argp1 = 0 ;
38663 int res1 = 0 ;
38664 PyObject *swig_obj[1] ;
38665
38666 if (!args) SWIG_fail;
38667 swig_obj[0] = args;
38668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38669 if (!SWIG_IsOK(res1)) {
38670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38671 }
38672 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38673 {
38674 PyThreadState* __tstate = wxPyBeginAllowThreads();
38675 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38676 wxPyEndAllowThreads(__tstate);
38677 if (PyErr_Occurred()) SWIG_fail;
38678 }
38679 {
38680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38681 }
38682 return resultobj;
38683 fail:
38684 return NULL;
38685 }
38686
38687
38688 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38689 PyObject *resultobj = 0;
38690 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38691 wxArrayString *result = 0 ;
38692 void *argp1 = 0 ;
38693 int res1 = 0 ;
38694 PyObject *swig_obj[1] ;
38695
38696 if (!args) SWIG_fail;
38697 swig_obj[0] = args;
38698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38699 if (!SWIG_IsOK(res1)) {
38700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38701 }
38702 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38703 {
38704 PyThreadState* __tstate = wxPyBeginAllowThreads();
38705 {
38706 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38707 result = (wxArrayString *) &_result_ref;
38708 }
38709 wxPyEndAllowThreads(__tstate);
38710 if (PyErr_Occurred()) SWIG_fail;
38711 }
38712 {
38713 resultobj = wxArrayString2PyList_helper(*result);
38714 }
38715 return resultobj;
38716 fail:
38717 return NULL;
38718 }
38719
38720
38721 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38722 PyObject *resultobj = 0;
38723 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38724 wxArrayString *arg2 = 0 ;
38725 void *argp1 = 0 ;
38726 int res1 = 0 ;
38727 bool temp2 = false ;
38728 PyObject * obj0 = 0 ;
38729 PyObject * obj1 = 0 ;
38730 char * kwnames[] = {
38731 (char *) "self",(char *) "artists", NULL
38732 };
38733
38734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38736 if (!SWIG_IsOK(res1)) {
38737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38738 }
38739 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38740 {
38741 if (! PySequence_Check(obj1)) {
38742 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38743 SWIG_fail;
38744 }
38745 arg2 = new wxArrayString;
38746 temp2 = true;
38747 int i, len=PySequence_Length(obj1);
38748 for (i=0; i<len; i++) {
38749 PyObject* item = PySequence_GetItem(obj1, i);
38750 wxString* s = wxString_in_helper(item);
38751 if (PyErr_Occurred()) SWIG_fail;
38752 arg2->Add(*s);
38753 delete s;
38754 Py_DECREF(item);
38755 }
38756 }
38757 {
38758 PyThreadState* __tstate = wxPyBeginAllowThreads();
38759 (arg1)->SetArtists((wxArrayString const &)*arg2);
38760 wxPyEndAllowThreads(__tstate);
38761 if (PyErr_Occurred()) SWIG_fail;
38762 }
38763 resultobj = SWIG_Py_Void();
38764 {
38765 if (temp2) delete arg2;
38766 }
38767 return resultobj;
38768 fail:
38769 {
38770 if (temp2) delete arg2;
38771 }
38772 return NULL;
38773 }
38774
38775
38776 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38777 PyObject *resultobj = 0;
38778 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38779 wxString *arg2 = 0 ;
38780 void *argp1 = 0 ;
38781 int res1 = 0 ;
38782 bool temp2 = false ;
38783 PyObject * obj0 = 0 ;
38784 PyObject * obj1 = 0 ;
38785 char * kwnames[] = {
38786 (char *) "self",(char *) "artist", NULL
38787 };
38788
38789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38791 if (!SWIG_IsOK(res1)) {
38792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38793 }
38794 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38795 {
38796 arg2 = wxString_in_helper(obj1);
38797 if (arg2 == NULL) SWIG_fail;
38798 temp2 = true;
38799 }
38800 {
38801 PyThreadState* __tstate = wxPyBeginAllowThreads();
38802 (arg1)->AddArtist((wxString const &)*arg2);
38803 wxPyEndAllowThreads(__tstate);
38804 if (PyErr_Occurred()) SWIG_fail;
38805 }
38806 resultobj = SWIG_Py_Void();
38807 {
38808 if (temp2)
38809 delete arg2;
38810 }
38811 return resultobj;
38812 fail:
38813 {
38814 if (temp2)
38815 delete arg2;
38816 }
38817 return NULL;
38818 }
38819
38820
38821 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38822 PyObject *resultobj = 0;
38823 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38824 bool result;
38825 void *argp1 = 0 ;
38826 int res1 = 0 ;
38827 PyObject *swig_obj[1] ;
38828
38829 if (!args) SWIG_fail;
38830 swig_obj[0] = args;
38831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38832 if (!SWIG_IsOK(res1)) {
38833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38834 }
38835 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38839 wxPyEndAllowThreads(__tstate);
38840 if (PyErr_Occurred()) SWIG_fail;
38841 }
38842 {
38843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38844 }
38845 return resultobj;
38846 fail:
38847 return NULL;
38848 }
38849
38850
38851 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38852 PyObject *resultobj = 0;
38853 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38854 wxArrayString *result = 0 ;
38855 void *argp1 = 0 ;
38856 int res1 = 0 ;
38857 PyObject *swig_obj[1] ;
38858
38859 if (!args) SWIG_fail;
38860 swig_obj[0] = args;
38861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38862 if (!SWIG_IsOK(res1)) {
38863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38864 }
38865 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38866 {
38867 PyThreadState* __tstate = wxPyBeginAllowThreads();
38868 {
38869 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38870 result = (wxArrayString *) &_result_ref;
38871 }
38872 wxPyEndAllowThreads(__tstate);
38873 if (PyErr_Occurred()) SWIG_fail;
38874 }
38875 {
38876 resultobj = wxArrayString2PyList_helper(*result);
38877 }
38878 return resultobj;
38879 fail:
38880 return NULL;
38881 }
38882
38883
38884 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38885 PyObject *resultobj = 0;
38886 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38887 wxArrayString *arg2 = 0 ;
38888 void *argp1 = 0 ;
38889 int res1 = 0 ;
38890 bool temp2 = false ;
38891 PyObject * obj0 = 0 ;
38892 PyObject * obj1 = 0 ;
38893 char * kwnames[] = {
38894 (char *) "self",(char *) "translators", NULL
38895 };
38896
38897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38899 if (!SWIG_IsOK(res1)) {
38900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38901 }
38902 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38903 {
38904 if (! PySequence_Check(obj1)) {
38905 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38906 SWIG_fail;
38907 }
38908 arg2 = new wxArrayString;
38909 temp2 = true;
38910 int i, len=PySequence_Length(obj1);
38911 for (i=0; i<len; i++) {
38912 PyObject* item = PySequence_GetItem(obj1, i);
38913 wxString* s = wxString_in_helper(item);
38914 if (PyErr_Occurred()) SWIG_fail;
38915 arg2->Add(*s);
38916 delete s;
38917 Py_DECREF(item);
38918 }
38919 }
38920 {
38921 PyThreadState* __tstate = wxPyBeginAllowThreads();
38922 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38923 wxPyEndAllowThreads(__tstate);
38924 if (PyErr_Occurred()) SWIG_fail;
38925 }
38926 resultobj = SWIG_Py_Void();
38927 {
38928 if (temp2) delete arg2;
38929 }
38930 return resultobj;
38931 fail:
38932 {
38933 if (temp2) delete arg2;
38934 }
38935 return NULL;
38936 }
38937
38938
38939 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38940 PyObject *resultobj = 0;
38941 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38942 wxString *arg2 = 0 ;
38943 void *argp1 = 0 ;
38944 int res1 = 0 ;
38945 bool temp2 = false ;
38946 PyObject * obj0 = 0 ;
38947 PyObject * obj1 = 0 ;
38948 char * kwnames[] = {
38949 (char *) "self",(char *) "translator", NULL
38950 };
38951
38952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38954 if (!SWIG_IsOK(res1)) {
38955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38956 }
38957 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38958 {
38959 arg2 = wxString_in_helper(obj1);
38960 if (arg2 == NULL) SWIG_fail;
38961 temp2 = true;
38962 }
38963 {
38964 PyThreadState* __tstate = wxPyBeginAllowThreads();
38965 (arg1)->AddTranslator((wxString const &)*arg2);
38966 wxPyEndAllowThreads(__tstate);
38967 if (PyErr_Occurred()) SWIG_fail;
38968 }
38969 resultobj = SWIG_Py_Void();
38970 {
38971 if (temp2)
38972 delete arg2;
38973 }
38974 return resultobj;
38975 fail:
38976 {
38977 if (temp2)
38978 delete arg2;
38979 }
38980 return NULL;
38981 }
38982
38983
38984 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38985 PyObject *resultobj = 0;
38986 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38987 bool result;
38988 void *argp1 = 0 ;
38989 int res1 = 0 ;
38990 PyObject *swig_obj[1] ;
38991
38992 if (!args) SWIG_fail;
38993 swig_obj[0] = args;
38994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38995 if (!SWIG_IsOK(res1)) {
38996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38997 }
38998 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38999 {
39000 PyThreadState* __tstate = wxPyBeginAllowThreads();
39001 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39002 wxPyEndAllowThreads(__tstate);
39003 if (PyErr_Occurred()) SWIG_fail;
39004 }
39005 {
39006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39007 }
39008 return resultobj;
39009 fail:
39010 return NULL;
39011 }
39012
39013
39014 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39015 PyObject *resultobj = 0;
39016 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39017 wxArrayString *result = 0 ;
39018 void *argp1 = 0 ;
39019 int res1 = 0 ;
39020 PyObject *swig_obj[1] ;
39021
39022 if (!args) SWIG_fail;
39023 swig_obj[0] = args;
39024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39025 if (!SWIG_IsOK(res1)) {
39026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39027 }
39028 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39029 {
39030 PyThreadState* __tstate = wxPyBeginAllowThreads();
39031 {
39032 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39033 result = (wxArrayString *) &_result_ref;
39034 }
39035 wxPyEndAllowThreads(__tstate);
39036 if (PyErr_Occurred()) SWIG_fail;
39037 }
39038 {
39039 resultobj = wxArrayString2PyList_helper(*result);
39040 }
39041 return resultobj;
39042 fail:
39043 return NULL;
39044 }
39045
39046
39047 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39048 PyObject *resultobj = 0;
39049 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39050 bool result;
39051 void *argp1 = 0 ;
39052 int res1 = 0 ;
39053 PyObject *swig_obj[1] ;
39054
39055 if (!args) SWIG_fail;
39056 swig_obj[0] = args;
39057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39058 if (!SWIG_IsOK(res1)) {
39059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39060 }
39061 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39062 {
39063 PyThreadState* __tstate = wxPyBeginAllowThreads();
39064 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39065 wxPyEndAllowThreads(__tstate);
39066 if (PyErr_Occurred()) SWIG_fail;
39067 }
39068 {
39069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39070 }
39071 return resultobj;
39072 fail:
39073 return NULL;
39074 }
39075
39076
39077 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39078 PyObject *resultobj = 0;
39079 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39080 wxString result;
39081 void *argp1 = 0 ;
39082 int res1 = 0 ;
39083 PyObject *swig_obj[1] ;
39084
39085 if (!args) SWIG_fail;
39086 swig_obj[0] = args;
39087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39088 if (!SWIG_IsOK(res1)) {
39089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39090 }
39091 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39092 {
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 {
39099 #if wxUSE_UNICODE
39100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39101 #else
39102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39103 #endif
39104 }
39105 return resultobj;
39106 fail:
39107 return NULL;
39108 }
39109
39110
39111 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39112 PyObject *obj;
39113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39114 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39115 return SWIG_Py_Void();
39116 }
39117
39118 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39119 return SWIG_Python_InitShadowInstance(args);
39120 }
39121
39122 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39123 PyObject *resultobj = 0;
39124 wxAboutDialogInfo *arg1 = 0 ;
39125 void *argp1 = 0 ;
39126 int res1 = 0 ;
39127 PyObject * obj0 = 0 ;
39128 char * kwnames[] = {
39129 (char *) "info", NULL
39130 };
39131
39132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39133 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39134 if (!SWIG_IsOK(res1)) {
39135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39136 }
39137 if (!argp1) {
39138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39139 }
39140 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39141 {
39142 PyThreadState* __tstate = wxPyBeginAllowThreads();
39143 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39144 wxPyEndAllowThreads(__tstate);
39145 if (PyErr_Occurred()) SWIG_fail;
39146 }
39147 resultobj = SWIG_Py_Void();
39148 return resultobj;
39149 fail:
39150 return NULL;
39151 }
39152
39153
39154 static PyMethodDef SwigMethods[] = {
39155 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39156 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39157 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39158 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39159 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39160 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39161 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39162 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39163 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39164 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39165 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39166 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39167 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39168 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39169 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39170 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39171 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39172 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39173 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39174 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39175 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39176 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39178 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39179 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39180 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39181 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39182 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39183 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39184 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39185 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39186 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39187 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39188 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39189 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39190 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39196 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39197 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39198 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39199 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39200 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39201 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39202 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39203 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39204 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39205 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39206 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39207 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39208 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39209 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39210 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39215 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39216 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39217 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39218 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39219 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39220 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39221 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39222 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39223 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39224 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39225 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39226 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39228 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39229 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39230 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39236 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39237 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39238 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39239 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39240 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39241 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39242 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39243 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39244 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39245 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39246 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39247 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39250 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39251 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39252 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39253 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39256 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39257 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39258 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39259 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39260 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39261 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39262 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39263 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39264 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39265 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39266 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39267 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39268 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39269 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39271 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39272 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39274 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39275 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39276 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39277 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39278 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39279 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39280 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39281 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39282 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39283 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39284 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39285 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39286 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39291 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39292 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39293 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39295 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39296 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39297 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39298 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39299 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39300 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39302 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39303 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39304 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39305 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39306 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39307 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39308 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39309 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39310 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39312 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39313 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39314 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39315 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39316 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39318 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39319 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39320 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39321 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39324 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39326 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39327 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39328 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39329 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39330 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39331 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39333 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39334 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39335 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39336 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39337 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39338 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39339 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39340 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39341 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39342 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39343 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39345 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39346 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39347 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39348 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39349 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39350 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39351 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39352 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39353 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39354 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39355 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39356 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39357 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39358 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39363 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39365 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39366 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39367 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39368 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39369 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39370 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39371 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39372 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39373 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39375 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39376 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39377 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39379 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39381 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39383 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39384 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39385 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39386 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39387 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39388 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39389 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39390 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39391 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39392 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39393 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39395 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39396 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39397 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39398 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39399 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39401 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39402 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39403 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39404 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39405 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39408 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39409 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39410 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39411 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39412 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39413 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39415 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39416 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39418 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39419 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39420 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39421 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39422 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39423 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39425 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39426 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39427 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39428 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39429 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39430 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39431 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39432 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39433 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39434 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39435 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39436 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39437 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39438 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39439 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39440 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39441 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39442 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39443 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39445 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39446 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39447 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39449 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39450 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39454 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39455 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39456 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39457 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39458 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39459 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39460 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39461 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39462 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39467 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39468 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39469 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39470 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39472 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39473 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39474 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39475 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39476 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39477 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39478 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39479 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39480 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39481 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39482 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39483 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39484 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39485 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39487 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39488 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39489 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39491 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39492 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39493 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39494 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39495 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39496 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39497 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39498 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39499 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39500 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39501 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39502 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39503 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39504 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39506 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39507 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39508 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39509 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39510 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39511 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39512 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39513 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39515 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39516 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39517 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39518 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39519 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39520 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39521 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39522 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39523 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39524 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39525 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39526 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39527 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39528 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39529 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39530 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39531 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39532 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39533 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39534 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39535 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39536 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39537 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39538 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39539 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39540 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39541 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39542 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39543 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39544 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39545 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39546 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39547 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39548 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39549 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39550 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39551 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39552 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39553 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39554 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39555 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39556 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39557 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39559 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39560 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39561 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39562 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39563 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39564 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39565 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39566 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39567 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39572 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39573 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39574 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39575 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39576 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39577 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39578 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39579 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39580 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39581 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39583 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39584 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39585 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39586 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39589 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39590 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39591 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39594 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39595 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39598 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39599 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39600 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39601 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39602 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39603 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39604 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39605 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39606 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39607 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39608 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39610 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39611 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39612 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39613 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39614 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39615 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39616 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39622 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39624 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39625 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39627 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39628 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39629 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39632 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39633 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39634 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39636 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39638 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39639 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39640 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39641 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39642 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39643 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39644 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39645 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39646 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39651 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39652 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39653 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39654 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39657 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39658 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39660 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39661 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39663 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39684 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39686 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39688 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39690 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39691 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39695 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39696 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39698 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39699 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39700 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39702 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39703 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39704 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39706 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39707 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39708 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39709 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39712 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39723 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39727 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39728 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39729 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39730 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39736 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39737 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39742 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39766 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39767 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39768 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39769 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39770 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39782 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39783 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39809 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39810 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39811 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39812 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39825 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39826 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39827 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39828 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39829 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39830 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39832 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39834 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39836 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39838 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39840 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39842 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39844 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39848 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39849 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39853 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39864 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39865 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39866 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39870 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39871 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39872 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39873 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39874 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39875 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39877 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39878 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39880 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39882 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39884 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39886 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39888 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39893 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39894 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39895 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39896 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39897 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39900 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39904 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39912 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39913 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39914 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39915 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39916 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39917 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39919 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39920 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39921 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39922 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39924 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39925 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39927 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39928 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39929 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39935 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39937 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39939 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39941 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39942 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39944 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39945 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39948 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39949 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39950 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39952 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39953 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39954 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39955 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39956 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39957 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39959 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39960 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39963 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39964 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39965 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39966 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39968 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39969 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39970 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39972 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39973 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39974 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39975 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39976 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39977 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39978 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39979 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39980 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39981 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39982 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39983 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39984 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39986 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39988 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39989 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39990 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
39992 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39993 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39994 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39995 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39996 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39998 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39999 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40000 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40003 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40004 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40005 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40007 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40008 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40009 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40010 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40012 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40013 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40015 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40016 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40017 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40018 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40019 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40020 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40023 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40024 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40025 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40027 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40028 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40029 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40030 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40032 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40034 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40035 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40036 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40037 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40038 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40039 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40040 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40041 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40042 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40043 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40044 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40048 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40049 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40050 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40051 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40052 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40053 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40054 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40055 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40056 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40057 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40058 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40059 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40060 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40061 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40062 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40063 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40064 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40065 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40066 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40069 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40070 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40071 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40072 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40073 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40074 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40075 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40076 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40077 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40078 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40080 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40081 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40082 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40083 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40084 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40085 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40086 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40087 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40088 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40090 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40091 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40092 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40093 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40094 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40095 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40096 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40097 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40098 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40099 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40100 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40101 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40102 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40103 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40105 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40106 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40107 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40108 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40109 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40110 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40111 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40112 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40113 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40114 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40115 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40116 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40117 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40118 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40119 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40120 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40121 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40122 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40123 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40124 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40125 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40126 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40127 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40128 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40129 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40130 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40131 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40132 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40133 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40134 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40135 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40136 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40137 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40138 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40139 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40140 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40141 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40142 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40143 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40144 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40145 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40146 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40147 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40148 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40149 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40150 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40151 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40152 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40153 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40154 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40155 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40156 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40157 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40158 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40159 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40160 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40161 { NULL, NULL, 0, NULL }
40162 };
40163
40164
40165 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40166
40167 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40168 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40169 }
40170 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40171 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40172 }
40173 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40174 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40175 }
40176 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40177 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40178 }
40179 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40180 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40181 }
40182 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40183 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40184 }
40185 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40186 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40187 }
40188 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40189 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40190 }
40191 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40192 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40193 }
40194 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40195 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40196 }
40197 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40198 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40199 }
40200 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40201 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40202 }
40203 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40204 return (void *)((wxEvent *) ((wxPyEvent *) x));
40205 }
40206 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40207 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40208 }
40209 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40210 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40211 }
40212 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40213 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40214 }
40215 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40216 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40217 }
40218 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40219 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40220 }
40221 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40222 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40223 }
40224 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40225 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40226 }
40227 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40228 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40229 }
40230 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40231 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40232 }
40233 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40234 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40235 }
40236 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40237 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40238 }
40239 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40240 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40241 }
40242 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40243 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40244 }
40245 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40246 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40247 }
40248 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40249 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40250 }
40251 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40252 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40253 }
40254 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40255 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40256 }
40257 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40258 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40259 }
40260 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40261 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40262 }
40263 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40264 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40265 }
40266 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40267 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40268 }
40269 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40270 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40271 }
40272 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40273 return (void *)((wxEvent *) ((wxShowEvent *) x));
40274 }
40275 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40276 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40277 }
40278 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40280 }
40281 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40282 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40283 }
40284 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40285 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40286 }
40287 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40288 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40289 }
40290 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40291 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40292 }
40293 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40294 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40295 }
40296 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40297 return (void *)((wxConfigBase *) ((wxConfig *) x));
40298 }
40299 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40300 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40301 }
40302 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40303 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40304 }
40305 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40306 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40307 }
40308 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40309 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40310 }
40311 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40312 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40313 }
40314 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40315 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40316 }
40317 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40318 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40319 }
40320 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40321 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40322 }
40323 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40324 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40325 }
40326 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40327 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40328 }
40329 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40330 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40331 }
40332 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40333 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40334 }
40335 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40336 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40337 }
40338 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40339 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40340 }
40341 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40342 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40343 }
40344 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40345 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40346 }
40347 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40348 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40349 }
40350 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40351 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40352 }
40353 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40354 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40355 }
40356 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40357 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40358 }
40359 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40360 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40361 }
40362 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40363 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40364 }
40365 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40366 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40367 }
40368 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40369 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40370 }
40371 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40372 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40373 }
40374 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40375 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40376 }
40377 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40378 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40379 }
40380 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40381 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40382 }
40383 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40384 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40385 }
40386 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40387 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40388 }
40389 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40390 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40391 }
40392 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40393 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40394 }
40395 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40396 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40397 }
40398 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40399 return (void *)((wxObject *) ((wxSizerItem *) x));
40400 }
40401 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40402 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40403 }
40404 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40405 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40406 }
40407 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40408 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40409 }
40410 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40411 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40412 }
40413 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40414 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40415 }
40416 static void *_p_wxSizerTo_p_wxObject(void *x) {
40417 return (void *)((wxObject *) ((wxSizer *) x));
40418 }
40419 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40420 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40421 }
40422 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40423 return (void *)((wxObject *) ((wxFileHistory *) x));
40424 }
40425 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40426 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40427 }
40428 static void *_p_wxEventTo_p_wxObject(void *x) {
40429 return (void *)((wxObject *) ((wxEvent *) x));
40430 }
40431 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40432 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40433 }
40434 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40435 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40436 }
40437 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40438 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40439 }
40440 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40441 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40442 }
40443 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40444 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40445 }
40446 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40447 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40448 }
40449 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40450 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40451 }
40452 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40453 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40454 }
40455 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40456 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40457 }
40458 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40459 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40460 }
40461 static void *_p_wxControlTo_p_wxObject(void *x) {
40462 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40463 }
40464 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40465 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40466 }
40467 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40468 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40469 }
40470 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40471 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40472 }
40473 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40474 return (void *)((wxObject *) ((wxFSFile *) x));
40475 }
40476 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40477 return (void *)((wxObject *) ((wxClipboard *) x));
40478 }
40479 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40480 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40481 }
40482 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40483 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40484 }
40485 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40486 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40487 }
40488 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40489 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40490 }
40491 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40492 return (void *)((wxObject *) ((wxToolTip *) x));
40493 }
40494 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40495 return (void *)((wxObject *) ((wxMenuItem *) x));
40496 }
40497 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40498 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40499 }
40500 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40501 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40502 }
40503 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40504 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40505 }
40506 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40507 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40508 }
40509 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40510 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40511 }
40512 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40513 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40514 }
40515 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40516 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40517 }
40518 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40519 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40520 }
40521 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40522 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40523 }
40524 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40525 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40526 }
40527 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40528 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40529 }
40530 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40531 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40532 }
40533 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40534 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40535 }
40536 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40537 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40538 }
40539 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40540 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40541 }
40542 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40543 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40544 }
40545 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40546 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40547 }
40548 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40549 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40550 }
40551 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40552 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40553 }
40554 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40555 return (void *)((wxObject *) ((wxImageHandler *) x));
40556 }
40557 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40558 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40559 }
40560 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40561 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40562 }
40563 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40564 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40565 }
40566 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40567 return (void *)((wxObject *) ((wxEvtHandler *) x));
40568 }
40569 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40570 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40571 }
40572 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40573 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40574 }
40575 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40576 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40577 }
40578 static void *_p_wxImageTo_p_wxObject(void *x) {
40579 return (void *)((wxObject *) ((wxImage *) x));
40580 }
40581 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40582 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40583 }
40584 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40585 return (void *)((wxObject *) ((wxSystemOptions *) x));
40586 }
40587 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40588 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40589 }
40590 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40591 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40592 }
40593 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40594 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40595 }
40596 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40597 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40598 }
40599 static void *_p_wxWindowTo_p_wxObject(void *x) {
40600 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40601 }
40602 static void *_p_wxMenuTo_p_wxObject(void *x) {
40603 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40604 }
40605 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40606 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40607 }
40608 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40609 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40610 }
40611 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40612 return (void *)((wxObject *) ((wxFileSystem *) x));
40613 }
40614 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40615 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40616 }
40617 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40618 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40619 }
40620 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40621 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40622 }
40623 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40624 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40625 }
40626 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40627 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40628 }
40629 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40630 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40631 }
40632 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40633 return (void *)((wxObject *) ((wxBusyInfo *) x));
40634 }
40635 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40636 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40637 }
40638 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40639 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40640 }
40641 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40642 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40643 }
40644 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40645 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40646 }
40647 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40648 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40649 }
40650 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40651 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40652 }
40653 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40654 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40655 }
40656 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40657 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40658 }
40659 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40660 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40661 }
40662 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40663 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40664 }
40665 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40666 return (void *)((wxLog *) ((wxLogBuffer *) x));
40667 }
40668 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40669 return (void *)((wxLog *) ((wxLogStderr *) x));
40670 }
40671 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40672 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40673 }
40674 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40675 return (void *)((wxLog *) ((wxLogWindow *) x));
40676 }
40677 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40678 return (void *)((wxLog *) ((wxLogChain *) x));
40679 }
40680 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40681 return (void *)((wxLog *) ((wxLogGui *) x));
40682 }
40683 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40684 return (void *)((wxLog *) ((wxPyLog *) x));
40685 }
40686 static void *_p_wxControlTo_p_wxWindow(void *x) {
40687 return (void *)((wxWindow *) ((wxControl *) x));
40688 }
40689 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40690 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40691 }
40692 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40693 return (void *)((wxWindow *) ((wxMenuBar *) x));
40694 }
40695 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40696 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40697 }
40698 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40699 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40700 }
40701 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40702 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
40703 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40704 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40705 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40706 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40707 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40708 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40709 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40710 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40711 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40712 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40713 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40714 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40715 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40716 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40717 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40736 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40737 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40738 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40739 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40740 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40741 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40742 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40743 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40754 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40773 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40775 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40776 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40777 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40778 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40779 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40780 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40809 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40810 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40811 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40812 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40813 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40814 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40817 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40818 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40825 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40828 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40832 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40833 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40835 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40836 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40837 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40838 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40839 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40840 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40841 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40842 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40843 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40850 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40851 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40852 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40853 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40854 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40855 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40856 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40857 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40858 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40859 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40860 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40861 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40862 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40863 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40866 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40867 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40868 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40870 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40871 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40875 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40876
40877 static swig_type_info *swig_type_initial[] = {
40878 &_swigt__p_char,
40879 &_swigt__p_form_ops_t,
40880 &_swigt__p_int,
40881 &_swigt__p_unsigned_char,
40882 &_swigt__p_unsigned_int,
40883 &_swigt__p_unsigned_long,
40884 &_swigt__p_void,
40885 &_swigt__p_wxANIHandler,
40886 &_swigt__p_wxAboutDialogInfo,
40887 &_swigt__p_wxAcceleratorTable,
40888 &_swigt__p_wxActivateEvent,
40889 &_swigt__p_wxArrayString,
40890 &_swigt__p_wxBMPHandler,
40891 &_swigt__p_wxBitmap,
40892 &_swigt__p_wxBitmapDataObject,
40893 &_swigt__p_wxBoxSizer,
40894 &_swigt__p_wxBusyCursor,
40895 &_swigt__p_wxBusyInfo,
40896 &_swigt__p_wxCURHandler,
40897 &_swigt__p_wxCaret,
40898 &_swigt__p_wxChar,
40899 &_swigt__p_wxChildFocusEvent,
40900 &_swigt__p_wxClipboard,
40901 &_swigt__p_wxClipboardLocker,
40902 &_swigt__p_wxClipboardTextEvent,
40903 &_swigt__p_wxCloseEvent,
40904 &_swigt__p_wxColour,
40905 &_swigt__p_wxCommandEvent,
40906 &_swigt__p_wxConfig,
40907 &_swigt__p_wxConfigBase,
40908 &_swigt__p_wxConfigPathChanger,
40909 &_swigt__p_wxContextMenuEvent,
40910 &_swigt__p_wxControl,
40911 &_swigt__p_wxControlWithItems,
40912 &_swigt__p_wxCursor,
40913 &_swigt__p_wxCustomDataObject,
40914 &_swigt__p_wxDC,
40915 &_swigt__p_wxDataFormat,
40916 &_swigt__p_wxDataObject,
40917 &_swigt__p_wxDataObjectComposite,
40918 &_swigt__p_wxDataObjectSimple,
40919 &_swigt__p_wxDateEvent,
40920 &_swigt__p_wxDateSpan,
40921 &_swigt__p_wxDateTime,
40922 &_swigt__p_wxDateTime__TimeZone,
40923 &_swigt__p_wxDisplay,
40924 &_swigt__p_wxDisplayChangedEvent,
40925 &_swigt__p_wxDropFilesEvent,
40926 &_swigt__p_wxDuplexMode,
40927 &_swigt__p_wxEraseEvent,
40928 &_swigt__p_wxEvent,
40929 &_swigt__p_wxEvtHandler,
40930 &_swigt__p_wxFSFile,
40931 &_swigt__p_wxFileConfig,
40932 &_swigt__p_wxFileDataObject,
40933 &_swigt__p_wxFileHistory,
40934 &_swigt__p_wxFileSystem,
40935 &_swigt__p_wxFileType,
40936 &_swigt__p_wxFileTypeInfo,
40937 &_swigt__p_wxFlexGridSizer,
40938 &_swigt__p_wxFocusEvent,
40939 &_swigt__p_wxFont,
40940 &_swigt__p_wxFrame,
40941 &_swigt__p_wxGBSizerItem,
40942 &_swigt__p_wxGIFHandler,
40943 &_swigt__p_wxGridBagSizer,
40944 &_swigt__p_wxGridSizer,
40945 &_swigt__p_wxICOHandler,
40946 &_swigt__p_wxIcon,
40947 &_swigt__p_wxIconizeEvent,
40948 &_swigt__p_wxIdleEvent,
40949 &_swigt__p_wxImage,
40950 &_swigt__p_wxImageHandler,
40951 &_swigt__p_wxIndividualLayoutConstraint,
40952 &_swigt__p_wxInitDialogEvent,
40953 &_swigt__p_wxJPEGHandler,
40954 &_swigt__p_wxJoystick,
40955 &_swigt__p_wxJoystickEvent,
40956 &_swigt__p_wxKeyEvent,
40957 &_swigt__p_wxKillError,
40958 &_swigt__p_wxLayoutConstraints,
40959 &_swigt__p_wxLog,
40960 &_swigt__p_wxLogBuffer,
40961 &_swigt__p_wxLogChain,
40962 &_swigt__p_wxLogGui,
40963 &_swigt__p_wxLogNull,
40964 &_swigt__p_wxLogStderr,
40965 &_swigt__p_wxLogTextCtrl,
40966 &_swigt__p_wxLogWindow,
40967 &_swigt__p_wxMaximizeEvent,
40968 &_swigt__p_wxMenu,
40969 &_swigt__p_wxMenuBar,
40970 &_swigt__p_wxMenuEvent,
40971 &_swigt__p_wxMenuItem,
40972 &_swigt__p_wxMetafile,
40973 &_swigt__p_wxMetafileDataObject,
40974 &_swigt__p_wxMimeTypesManager,
40975 &_swigt__p_wxMouseCaptureChangedEvent,
40976 &_swigt__p_wxMouseCaptureLostEvent,
40977 &_swigt__p_wxMouseEvent,
40978 &_swigt__p_wxMouseState,
40979 &_swigt__p_wxMoveEvent,
40980 &_swigt__p_wxMutexGuiLocker,
40981 &_swigt__p_wxNavigationKeyEvent,
40982 &_swigt__p_wxNcPaintEvent,
40983 &_swigt__p_wxNotifyEvent,
40984 &_swigt__p_wxObject,
40985 &_swigt__p_wxOutputStream,
40986 &_swigt__p_wxPCXHandler,
40987 &_swigt__p_wxPNGHandler,
40988 &_swigt__p_wxPNMHandler,
40989 &_swigt__p_wxPaintEvent,
40990 &_swigt__p_wxPaletteChangedEvent,
40991 &_swigt__p_wxPaperSize,
40992 &_swigt__p_wxPlatformInfo,
40993 &_swigt__p_wxPoint,
40994 &_swigt__p_wxPowerEvent,
40995 &_swigt__p_wxProcessEvent,
40996 &_swigt__p_wxPyApp,
40997 &_swigt__p_wxPyArtProvider,
40998 &_swigt__p_wxPyBitmapDataObject,
40999 &_swigt__p_wxPyCommandEvent,
41000 &_swigt__p_wxPyDataObjectSimple,
41001 &_swigt__p_wxPyDropSource,
41002 &_swigt__p_wxPyDropTarget,
41003 &_swigt__p_wxPyEvent,
41004 &_swigt__p_wxPyFileDropTarget,
41005 &_swigt__p_wxPyImageHandler,
41006 &_swigt__p_wxPyLog,
41007 &_swigt__p_wxPyProcess,
41008 &_swigt__p_wxPySizer,
41009 &_swigt__p_wxPyTextDataObject,
41010 &_swigt__p_wxPyTextDropTarget,
41011 &_swigt__p_wxPyTimer,
41012 &_swigt__p_wxPyTipProvider,
41013 &_swigt__p_wxPyValidator,
41014 &_swigt__p_wxQueryNewPaletteEvent,
41015 &_swigt__p_wxRect,
41016 &_swigt__p_wxScrollEvent,
41017 &_swigt__p_wxScrollWinEvent,
41018 &_swigt__p_wxSetCursorEvent,
41019 &_swigt__p_wxShowEvent,
41020 &_swigt__p_wxSingleInstanceChecker,
41021 &_swigt__p_wxSize,
41022 &_swigt__p_wxSizeEvent,
41023 &_swigt__p_wxSizer,
41024 &_swigt__p_wxSizerItem,
41025 &_swigt__p_wxSound,
41026 &_swigt__p_wxStandardPaths,
41027 &_swigt__p_wxStaticBoxSizer,
41028 &_swigt__p_wxStdDialogButtonSizer,
41029 &_swigt__p_wxStopWatch,
41030 &_swigt__p_wxString,
41031 &_swigt__p_wxSysColourChangedEvent,
41032 &_swigt__p_wxSystemOptions,
41033 &_swigt__p_wxSystemSettings,
41034 &_swigt__p_wxTGAHandler,
41035 &_swigt__p_wxTIFFHandler,
41036 &_swigt__p_wxTextCtrl,
41037 &_swigt__p_wxTextDataObject,
41038 &_swigt__p_wxTimeSpan,
41039 &_swigt__p_wxTimer,
41040 &_swigt__p_wxTimerEvent,
41041 &_swigt__p_wxTimerRunner,
41042 &_swigt__p_wxTipProvider,
41043 &_swigt__p_wxToolTip,
41044 &_swigt__p_wxURLDataObject,
41045 &_swigt__p_wxUpdateUIEvent,
41046 &_swigt__p_wxValidator,
41047 &_swigt__p_wxVideoMode,
41048 &_swigt__p_wxWindow,
41049 &_swigt__p_wxWindowCreateEvent,
41050 &_swigt__p_wxWindowDestroyEvent,
41051 &_swigt__p_wxWindowDisabler,
41052 &_swigt__p_wxXPMHandler,
41053 };
41054
41055 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41061 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxBitmapDataObject[] = { {&_swigt__p_wxBitmapDataObject, 0, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41073 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_wxConfigBase[] = { {&_swigt__p_wxFileConfig, _p_wxFileConfigTo_p_wxConfigBase, 0, 0}, {&_swigt__p_wxConfigBase, 0, 0, 0}, {&_swigt__p_wxConfig, _p_wxConfigTo_p_wxConfigBase, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxDataObject[] = { {&_swigt__p_wxDataObjectSimple, _p_wxDataObjectSimpleTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyDataObjectSimple, _p_wxPyDataObjectSimpleTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxDataObjectComposite, _p_wxDataObjectCompositeTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxDataObject, 0, 0, 0}, {&_swigt__p_wxTextDataObject, _p_wxTextDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxBitmapDataObject, _p_wxBitmapDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxFileDataObject, _p_wxFileDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxCustomDataObject, _p_wxCustomDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxMetafileDataObject, _p_wxMetafileDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxURLDataObject, _p_wxURLDataObjectTo_p_wxDataObject, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxDataObjectSimple[] = { {&_swigt__p_wxDataObjectSimple, 0, 0, 0}, {&_swigt__p_wxPyDataObjectSimple, _p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxTextDataObject, _p_wxTextDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxBitmapDataObject, _p_wxBitmapDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxFileDataObject, _p_wxFileDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxCustomDataObject, _p_wxCustomDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxMetafileDataObject, _p_wxMetafileDataObjectTo_p_wxDataObjectSimple, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxLog[] = { {&_swigt__p_wxLogBuffer, _p_wxLogBufferTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogStderr, _p_wxLogStderrTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogTextCtrl, _p_wxLogTextCtrlTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogWindow, _p_wxLogWindowTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogChain, _p_wxLogChainTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogGui, _p_wxLogGuiTo_p_wxLog, 0, 0}, {&_swigt__p_wxPyLog, _p_wxPyLogTo_p_wxLog, 0, 0}, {&_swigt__p_wxLog, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0}, {&_swigt__p_wxPyTextDropTarget, _p_wxPyTextDropTargetTo_p_wxPyDropTarget, 0, 0}, {&_swigt__p_wxPyFileDropTarget, _p_wxPyFileDropTargetTo_p_wxPyDropTarget, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41219 static swig_cast_info _swigc__p_wxTextDataObject[] = { {&_swigt__p_wxTextDataObject, 0, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxTextDataObject, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxTipProvider[] = { {&_swigt__p_wxTipProvider, 0, 0, 0}, {&_swigt__p_wxPyTipProvider, _p_wxPyTipProviderTo_p_wxTipProvider, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41230
41231 static swig_cast_info *swig_cast_initial[] = {
41232 _swigc__p_char,
41233 _swigc__p_form_ops_t,
41234 _swigc__p_int,
41235 _swigc__p_unsigned_char,
41236 _swigc__p_unsigned_int,
41237 _swigc__p_unsigned_long,
41238 _swigc__p_void,
41239 _swigc__p_wxANIHandler,
41240 _swigc__p_wxAboutDialogInfo,
41241 _swigc__p_wxAcceleratorTable,
41242 _swigc__p_wxActivateEvent,
41243 _swigc__p_wxArrayString,
41244 _swigc__p_wxBMPHandler,
41245 _swigc__p_wxBitmap,
41246 _swigc__p_wxBitmapDataObject,
41247 _swigc__p_wxBoxSizer,
41248 _swigc__p_wxBusyCursor,
41249 _swigc__p_wxBusyInfo,
41250 _swigc__p_wxCURHandler,
41251 _swigc__p_wxCaret,
41252 _swigc__p_wxChar,
41253 _swigc__p_wxChildFocusEvent,
41254 _swigc__p_wxClipboard,
41255 _swigc__p_wxClipboardLocker,
41256 _swigc__p_wxClipboardTextEvent,
41257 _swigc__p_wxCloseEvent,
41258 _swigc__p_wxColour,
41259 _swigc__p_wxCommandEvent,
41260 _swigc__p_wxConfig,
41261 _swigc__p_wxConfigBase,
41262 _swigc__p_wxConfigPathChanger,
41263 _swigc__p_wxContextMenuEvent,
41264 _swigc__p_wxControl,
41265 _swigc__p_wxControlWithItems,
41266 _swigc__p_wxCursor,
41267 _swigc__p_wxCustomDataObject,
41268 _swigc__p_wxDC,
41269 _swigc__p_wxDataFormat,
41270 _swigc__p_wxDataObject,
41271 _swigc__p_wxDataObjectComposite,
41272 _swigc__p_wxDataObjectSimple,
41273 _swigc__p_wxDateEvent,
41274 _swigc__p_wxDateSpan,
41275 _swigc__p_wxDateTime,
41276 _swigc__p_wxDateTime__TimeZone,
41277 _swigc__p_wxDisplay,
41278 _swigc__p_wxDisplayChangedEvent,
41279 _swigc__p_wxDropFilesEvent,
41280 _swigc__p_wxDuplexMode,
41281 _swigc__p_wxEraseEvent,
41282 _swigc__p_wxEvent,
41283 _swigc__p_wxEvtHandler,
41284 _swigc__p_wxFSFile,
41285 _swigc__p_wxFileConfig,
41286 _swigc__p_wxFileDataObject,
41287 _swigc__p_wxFileHistory,
41288 _swigc__p_wxFileSystem,
41289 _swigc__p_wxFileType,
41290 _swigc__p_wxFileTypeInfo,
41291 _swigc__p_wxFlexGridSizer,
41292 _swigc__p_wxFocusEvent,
41293 _swigc__p_wxFont,
41294 _swigc__p_wxFrame,
41295 _swigc__p_wxGBSizerItem,
41296 _swigc__p_wxGIFHandler,
41297 _swigc__p_wxGridBagSizer,
41298 _swigc__p_wxGridSizer,
41299 _swigc__p_wxICOHandler,
41300 _swigc__p_wxIcon,
41301 _swigc__p_wxIconizeEvent,
41302 _swigc__p_wxIdleEvent,
41303 _swigc__p_wxImage,
41304 _swigc__p_wxImageHandler,
41305 _swigc__p_wxIndividualLayoutConstraint,
41306 _swigc__p_wxInitDialogEvent,
41307 _swigc__p_wxJPEGHandler,
41308 _swigc__p_wxJoystick,
41309 _swigc__p_wxJoystickEvent,
41310 _swigc__p_wxKeyEvent,
41311 _swigc__p_wxKillError,
41312 _swigc__p_wxLayoutConstraints,
41313 _swigc__p_wxLog,
41314 _swigc__p_wxLogBuffer,
41315 _swigc__p_wxLogChain,
41316 _swigc__p_wxLogGui,
41317 _swigc__p_wxLogNull,
41318 _swigc__p_wxLogStderr,
41319 _swigc__p_wxLogTextCtrl,
41320 _swigc__p_wxLogWindow,
41321 _swigc__p_wxMaximizeEvent,
41322 _swigc__p_wxMenu,
41323 _swigc__p_wxMenuBar,
41324 _swigc__p_wxMenuEvent,
41325 _swigc__p_wxMenuItem,
41326 _swigc__p_wxMetafile,
41327 _swigc__p_wxMetafileDataObject,
41328 _swigc__p_wxMimeTypesManager,
41329 _swigc__p_wxMouseCaptureChangedEvent,
41330 _swigc__p_wxMouseCaptureLostEvent,
41331 _swigc__p_wxMouseEvent,
41332 _swigc__p_wxMouseState,
41333 _swigc__p_wxMoveEvent,
41334 _swigc__p_wxMutexGuiLocker,
41335 _swigc__p_wxNavigationKeyEvent,
41336 _swigc__p_wxNcPaintEvent,
41337 _swigc__p_wxNotifyEvent,
41338 _swigc__p_wxObject,
41339 _swigc__p_wxOutputStream,
41340 _swigc__p_wxPCXHandler,
41341 _swigc__p_wxPNGHandler,
41342 _swigc__p_wxPNMHandler,
41343 _swigc__p_wxPaintEvent,
41344 _swigc__p_wxPaletteChangedEvent,
41345 _swigc__p_wxPaperSize,
41346 _swigc__p_wxPlatformInfo,
41347 _swigc__p_wxPoint,
41348 _swigc__p_wxPowerEvent,
41349 _swigc__p_wxProcessEvent,
41350 _swigc__p_wxPyApp,
41351 _swigc__p_wxPyArtProvider,
41352 _swigc__p_wxPyBitmapDataObject,
41353 _swigc__p_wxPyCommandEvent,
41354 _swigc__p_wxPyDataObjectSimple,
41355 _swigc__p_wxPyDropSource,
41356 _swigc__p_wxPyDropTarget,
41357 _swigc__p_wxPyEvent,
41358 _swigc__p_wxPyFileDropTarget,
41359 _swigc__p_wxPyImageHandler,
41360 _swigc__p_wxPyLog,
41361 _swigc__p_wxPyProcess,
41362 _swigc__p_wxPySizer,
41363 _swigc__p_wxPyTextDataObject,
41364 _swigc__p_wxPyTextDropTarget,
41365 _swigc__p_wxPyTimer,
41366 _swigc__p_wxPyTipProvider,
41367 _swigc__p_wxPyValidator,
41368 _swigc__p_wxQueryNewPaletteEvent,
41369 _swigc__p_wxRect,
41370 _swigc__p_wxScrollEvent,
41371 _swigc__p_wxScrollWinEvent,
41372 _swigc__p_wxSetCursorEvent,
41373 _swigc__p_wxShowEvent,
41374 _swigc__p_wxSingleInstanceChecker,
41375 _swigc__p_wxSize,
41376 _swigc__p_wxSizeEvent,
41377 _swigc__p_wxSizer,
41378 _swigc__p_wxSizerItem,
41379 _swigc__p_wxSound,
41380 _swigc__p_wxStandardPaths,
41381 _swigc__p_wxStaticBoxSizer,
41382 _swigc__p_wxStdDialogButtonSizer,
41383 _swigc__p_wxStopWatch,
41384 _swigc__p_wxString,
41385 _swigc__p_wxSysColourChangedEvent,
41386 _swigc__p_wxSystemOptions,
41387 _swigc__p_wxSystemSettings,
41388 _swigc__p_wxTGAHandler,
41389 _swigc__p_wxTIFFHandler,
41390 _swigc__p_wxTextCtrl,
41391 _swigc__p_wxTextDataObject,
41392 _swigc__p_wxTimeSpan,
41393 _swigc__p_wxTimer,
41394 _swigc__p_wxTimerEvent,
41395 _swigc__p_wxTimerRunner,
41396 _swigc__p_wxTipProvider,
41397 _swigc__p_wxToolTip,
41398 _swigc__p_wxURLDataObject,
41399 _swigc__p_wxUpdateUIEvent,
41400 _swigc__p_wxValidator,
41401 _swigc__p_wxVideoMode,
41402 _swigc__p_wxWindow,
41403 _swigc__p_wxWindowCreateEvent,
41404 _swigc__p_wxWindowDestroyEvent,
41405 _swigc__p_wxWindowDisabler,
41406 _swigc__p_wxXPMHandler,
41407 };
41408
41409
41410 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41411
41412 static swig_const_info swig_const_table[] = {
41413 {0, 0, 0, 0.0, 0, 0}};
41414
41415 #ifdef __cplusplus
41416 }
41417 #endif
41418 /* -----------------------------------------------------------------------------
41419 * Type initialization:
41420 * This problem is tough by the requirement that no dynamic
41421 * memory is used. Also, since swig_type_info structures store pointers to
41422 * swig_cast_info structures and swig_cast_info structures store pointers back
41423 * to swig_type_info structures, we need some lookup code at initialization.
41424 * The idea is that swig generates all the structures that are needed.
41425 * The runtime then collects these partially filled structures.
41426 * The SWIG_InitializeModule function takes these initial arrays out of
41427 * swig_module, and does all the lookup, filling in the swig_module.types
41428 * array with the correct data and linking the correct swig_cast_info
41429 * structures together.
41430 *
41431 * The generated swig_type_info structures are assigned staticly to an initial
41432 * array. We just loop though that array, and handle each type individually.
41433 * First we lookup if this type has been already loaded, and if so, use the
41434 * loaded structure instead of the generated one. Then we have to fill in the
41435 * cast linked list. The cast data is initially stored in something like a
41436 * two-dimensional array. Each row corresponds to a type (there are the same
41437 * number of rows as there are in the swig_type_initial array). Each entry in
41438 * a column is one of the swig_cast_info structures for that type.
41439 * The cast_initial array is actually an array of arrays, because each row has
41440 * a variable number of columns. So to actually build the cast linked list,
41441 * we find the array of casts associated with the type, and loop through it
41442 * adding the casts to the list. The one last trick we need to do is making
41443 * sure the type pointer in the swig_cast_info struct is correct.
41444 *
41445 * First off, we lookup the cast->type name to see if it is already loaded.
41446 * There are three cases to handle:
41447 * 1) If the cast->type has already been loaded AND the type we are adding
41448 * casting info to has not been loaded (it is in this module), THEN we
41449 * replace the cast->type pointer with the type pointer that has already
41450 * been loaded.
41451 * 2) If BOTH types (the one we are adding casting info to, and the
41452 * cast->type) are loaded, THEN the cast info has already been loaded by
41453 * the previous module so we just ignore it.
41454 * 3) Finally, if cast->type has not already been loaded, then we add that
41455 * swig_cast_info to the linked list (because the cast->type) pointer will
41456 * be correct.
41457 * ----------------------------------------------------------------------------- */
41458
41459 #ifdef __cplusplus
41460 extern "C" {
41461 #if 0
41462 } /* c-mode */
41463 #endif
41464 #endif
41465
41466 #if 0
41467 #define SWIGRUNTIME_DEBUG
41468 #endif
41469
41470 SWIGRUNTIME void
41471 SWIG_InitializeModule(void *clientdata) {
41472 size_t i;
41473 swig_module_info *module_head;
41474 static int init_run = 0;
41475
41476 clientdata = clientdata;
41477
41478 if (init_run) return;
41479 init_run = 1;
41480
41481 /* Initialize the swig_module */
41482 swig_module.type_initial = swig_type_initial;
41483 swig_module.cast_initial = swig_cast_initial;
41484
41485 /* Try and load any already created modules */
41486 module_head = SWIG_GetModule(clientdata);
41487 if (module_head) {
41488 swig_module.next = module_head->next;
41489 module_head->next = &swig_module;
41490 } else {
41491 /* This is the first module loaded */
41492 swig_module.next = &swig_module;
41493 SWIG_SetModule(clientdata, &swig_module);
41494 }
41495
41496 /* Now work on filling in swig_module.types */
41497 #ifdef SWIGRUNTIME_DEBUG
41498 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41499 #endif
41500 for (i = 0; i < swig_module.size; ++i) {
41501 swig_type_info *type = 0;
41502 swig_type_info *ret;
41503 swig_cast_info *cast;
41504
41505 #ifdef SWIGRUNTIME_DEBUG
41506 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41507 #endif
41508
41509 /* if there is another module already loaded */
41510 if (swig_module.next != &swig_module) {
41511 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41512 }
41513 if (type) {
41514 /* Overwrite clientdata field */
41515 #ifdef SWIGRUNTIME_DEBUG
41516 printf("SWIG_InitializeModule: found type %s\n", type->name);
41517 #endif
41518 if (swig_module.type_initial[i]->clientdata) {
41519 type->clientdata = swig_module.type_initial[i]->clientdata;
41520 #ifdef SWIGRUNTIME_DEBUG
41521 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41522 #endif
41523 }
41524 } else {
41525 type = swig_module.type_initial[i];
41526 }
41527
41528 /* Insert casting types */
41529 cast = swig_module.cast_initial[i];
41530 while (cast->type) {
41531 /* Don't need to add information already in the list */
41532 ret = 0;
41533 #ifdef SWIGRUNTIME_DEBUG
41534 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41535 #endif
41536 if (swig_module.next != &swig_module) {
41537 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41538 #ifdef SWIGRUNTIME_DEBUG
41539 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41540 #endif
41541 }
41542 if (ret) {
41543 if (type == swig_module.type_initial[i]) {
41544 #ifdef SWIGRUNTIME_DEBUG
41545 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41546 #endif
41547 cast->type = ret;
41548 ret = 0;
41549 } else {
41550 /* Check for casting already in the list */
41551 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41552 #ifdef SWIGRUNTIME_DEBUG
41553 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41554 #endif
41555 if (!ocast) ret = 0;
41556 }
41557 }
41558
41559 if (!ret) {
41560 #ifdef SWIGRUNTIME_DEBUG
41561 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41562 #endif
41563 if (type->cast) {
41564 type->cast->prev = cast;
41565 cast->next = type->cast;
41566 }
41567 type->cast = cast;
41568 }
41569 cast++;
41570 }
41571 /* Set entry in modules->types array equal to the type */
41572 swig_module.types[i] = type;
41573 }
41574 swig_module.types[i] = 0;
41575
41576 #ifdef SWIGRUNTIME_DEBUG
41577 printf("**** SWIG_InitializeModule: Cast List ******\n");
41578 for (i = 0; i < swig_module.size; ++i) {
41579 int j = 0;
41580 swig_cast_info *cast = swig_module.cast_initial[i];
41581 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41582 while (cast->type) {
41583 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41584 cast++;
41585 ++j;
41586 }
41587 printf("---- Total casts: %d\n",j);
41588 }
41589 printf("**** SWIG_InitializeModule: Cast List ******\n");
41590 #endif
41591 }
41592
41593 /* This function will propagate the clientdata field of type to
41594 * any new swig_type_info structures that have been added into the list
41595 * of equivalent types. It is like calling
41596 * SWIG_TypeClientData(type, clientdata) a second time.
41597 */
41598 SWIGRUNTIME void
41599 SWIG_PropagateClientData(void) {
41600 size_t i;
41601 swig_cast_info *equiv;
41602 static int init_run = 0;
41603
41604 if (init_run) return;
41605 init_run = 1;
41606
41607 for (i = 0; i < swig_module.size; i++) {
41608 if (swig_module.types[i]->clientdata) {
41609 equiv = swig_module.types[i]->cast;
41610 while (equiv) {
41611 if (!equiv->converter) {
41612 if (equiv->type && !equiv->type->clientdata)
41613 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41614 }
41615 equiv = equiv->next;
41616 }
41617 }
41618 }
41619 }
41620
41621 #ifdef __cplusplus
41622 #if 0
41623 {
41624 /* c-mode */
41625 #endif
41626 }
41627 #endif
41628
41629
41630
41631 #ifdef __cplusplus
41632 extern "C" {
41633 #endif
41634
41635 /* Python-specific SWIG API */
41636 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41637 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41638 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41639
41640 /* -----------------------------------------------------------------------------
41641 * global variable support code.
41642 * ----------------------------------------------------------------------------- */
41643
41644 typedef struct swig_globalvar {
41645 char *name; /* Name of global variable */
41646 PyObject *(*get_attr)(void); /* Return the current value */
41647 int (*set_attr)(PyObject *); /* Set the value */
41648 struct swig_globalvar *next;
41649 } swig_globalvar;
41650
41651 typedef struct swig_varlinkobject {
41652 PyObject_HEAD
41653 swig_globalvar *vars;
41654 } swig_varlinkobject;
41655
41656 SWIGINTERN PyObject *
41657 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41658 return PyString_FromString("<Swig global variables>");
41659 }
41660
41661 SWIGINTERN PyObject *
41662 swig_varlink_str(swig_varlinkobject *v) {
41663 PyObject *str = PyString_FromString("(");
41664 swig_globalvar *var;
41665 for (var = v->vars; var; var=var->next) {
41666 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41667 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41668 }
41669 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41670 return str;
41671 }
41672
41673 SWIGINTERN int
41674 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41675 PyObject *str = swig_varlink_str(v);
41676 fprintf(fp,"Swig global variables ");
41677 fprintf(fp,"%s\n", PyString_AsString(str));
41678 Py_DECREF(str);
41679 return 0;
41680 }
41681
41682 SWIGINTERN void
41683 swig_varlink_dealloc(swig_varlinkobject *v) {
41684 swig_globalvar *var = v->vars;
41685 while (var) {
41686 swig_globalvar *n = var->next;
41687 free(var->name);
41688 free(var);
41689 var = n;
41690 }
41691 }
41692
41693 SWIGINTERN PyObject *
41694 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41695 PyObject *res = NULL;
41696 swig_globalvar *var = v->vars;
41697 while (var) {
41698 if (strcmp(var->name,n) == 0) {
41699 res = (*var->get_attr)();
41700 break;
41701 }
41702 var = var->next;
41703 }
41704 if (res == NULL && !PyErr_Occurred()) {
41705 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41706 }
41707 return res;
41708 }
41709
41710 SWIGINTERN int
41711 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41712 int res = 1;
41713 swig_globalvar *var = v->vars;
41714 while (var) {
41715 if (strcmp(var->name,n) == 0) {
41716 res = (*var->set_attr)(p);
41717 break;
41718 }
41719 var = var->next;
41720 }
41721 if (res == 1 && !PyErr_Occurred()) {
41722 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41723 }
41724 return res;
41725 }
41726
41727 SWIGINTERN PyTypeObject*
41728 swig_varlink_type(void) {
41729 static char varlink__doc__[] = "Swig var link object";
41730 static PyTypeObject varlink_type;
41731 static int type_init = 0;
41732 if (!type_init) {
41733 const PyTypeObject tmp
41734 = {
41735 PyObject_HEAD_INIT(NULL)
41736 0, /* Number of items in variable part (ob_size) */
41737 (char *)"swigvarlink", /* Type name (tp_name) */
41738 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41739 0, /* Itemsize (tp_itemsize) */
41740 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41741 (printfunc) swig_varlink_print, /* Print (tp_print) */
41742 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41743 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41744 0, /* tp_compare */
41745 (reprfunc) swig_varlink_repr, /* tp_repr */
41746 0, /* tp_as_number */
41747 0, /* tp_as_sequence */
41748 0, /* tp_as_mapping */
41749 0, /* tp_hash */
41750 0, /* tp_call */
41751 (reprfunc)swig_varlink_str, /* tp_str */
41752 0, /* tp_getattro */
41753 0, /* tp_setattro */
41754 0, /* tp_as_buffer */
41755 0, /* tp_flags */
41756 varlink__doc__, /* tp_doc */
41757 0, /* tp_traverse */
41758 0, /* tp_clear */
41759 0, /* tp_richcompare */
41760 0, /* tp_weaklistoffset */
41761 #if PY_VERSION_HEX >= 0x02020000
41762 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41763 #endif
41764 #if PY_VERSION_HEX >= 0x02030000
41765 0, /* tp_del */
41766 #endif
41767 #ifdef COUNT_ALLOCS
41768 0,0,0,0 /* tp_alloc -> tp_next */
41769 #endif
41770 };
41771 varlink_type = tmp;
41772 varlink_type.ob_type = &PyType_Type;
41773 type_init = 1;
41774 }
41775 return &varlink_type;
41776 }
41777
41778 /* Create a variable linking object for use later */
41779 SWIGINTERN PyObject *
41780 SWIG_Python_newvarlink(void) {
41781 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41782 if (result) {
41783 result->vars = 0;
41784 }
41785 return ((PyObject*) result);
41786 }
41787
41788 SWIGINTERN void
41789 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41790 swig_varlinkobject *v = (swig_varlinkobject *) p;
41791 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41792 if (gv) {
41793 size_t size = strlen(name)+1;
41794 gv->name = (char *)malloc(size);
41795 if (gv->name) {
41796 strncpy(gv->name,name,size);
41797 gv->get_attr = get_attr;
41798 gv->set_attr = set_attr;
41799 gv->next = v->vars;
41800 }
41801 }
41802 v->vars = gv;
41803 }
41804
41805 SWIGINTERN PyObject *
41806 SWIG_globals() {
41807 static PyObject *_SWIG_globals = 0;
41808 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41809 return _SWIG_globals;
41810 }
41811
41812 /* -----------------------------------------------------------------------------
41813 * constants/methods manipulation
41814 * ----------------------------------------------------------------------------- */
41815
41816 /* Install Constants */
41817 SWIGINTERN void
41818 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41819 PyObject *obj = 0;
41820 size_t i;
41821 for (i = 0; constants[i].type; ++i) {
41822 switch(constants[i].type) {
41823 case SWIG_PY_POINTER:
41824 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41825 break;
41826 case SWIG_PY_BINARY:
41827 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41828 break;
41829 default:
41830 obj = 0;
41831 break;
41832 }
41833 if (obj) {
41834 PyDict_SetItemString(d, constants[i].name, obj);
41835 Py_DECREF(obj);
41836 }
41837 }
41838 }
41839
41840 /* -----------------------------------------------------------------------------*/
41841 /* Fix SwigMethods to carry the callback ptrs when needed */
41842 /* -----------------------------------------------------------------------------*/
41843
41844 SWIGINTERN void
41845 SWIG_Python_FixMethods(PyMethodDef *methods,
41846 swig_const_info *const_table,
41847 swig_type_info **types,
41848 swig_type_info **types_initial) {
41849 size_t i;
41850 for (i = 0; methods[i].ml_name; ++i) {
41851 const char *c = methods[i].ml_doc;
41852 if (c && (c = strstr(c, "swig_ptr: "))) {
41853 int j;
41854 swig_const_info *ci = 0;
41855 const char *name = c + 10;
41856 for (j = 0; const_table[j].type; ++j) {
41857 if (strncmp(const_table[j].name, name,
41858 strlen(const_table[j].name)) == 0) {
41859 ci = &(const_table[j]);
41860 break;
41861 }
41862 }
41863 if (ci) {
41864 size_t shift = (ci->ptype) - types;
41865 swig_type_info *ty = types_initial[shift];
41866 size_t ldoc = (c - methods[i].ml_doc);
41867 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41868 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41869 if (ndoc) {
41870 char *buff = ndoc;
41871 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41872 if (ptr) {
41873 strncpy(buff, methods[i].ml_doc, ldoc);
41874 buff += ldoc;
41875 strncpy(buff, "swig_ptr: ", 10);
41876 buff += 10;
41877 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41878 methods[i].ml_doc = ndoc;
41879 }
41880 }
41881 }
41882 }
41883 }
41884 }
41885
41886 #ifdef __cplusplus
41887 }
41888 #endif
41889
41890 /* -----------------------------------------------------------------------------*
41891 * Partial Init method
41892 * -----------------------------------------------------------------------------*/
41893
41894 #ifdef __cplusplus
41895 extern "C"
41896 #endif
41897 SWIGEXPORT void SWIG_init(void) {
41898 PyObject *m, *d;
41899
41900 /* Fix SwigMethods to carry the callback ptrs when needed */
41901 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41902
41903 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41904 d = PyModule_GetDict(m);
41905
41906 SWIG_InitializeModule(0);
41907 SWIG_InstallConstants(d,swig_const_table);
41908
41909
41910 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41911 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41912 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41913 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41914 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41915 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41916 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41917 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41918 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41919 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41920 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41921 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41922 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41923 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41924 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41925 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41926 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41927 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41928 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41929 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41930 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41931 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41932 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41933 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41934 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41935 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41936 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41937 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41938 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41939 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41940 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41941 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41942 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41943 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41944 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41945 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41946 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41947 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41948 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41949 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41950 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41951 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41952 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41953 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41954 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41955 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41956 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41957 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41958 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41959 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41960 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41961 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41962 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41963 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41964 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41965 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41966 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41967 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41968 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41969 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41970 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41971 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41972 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41973 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41974 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41975 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41976 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41977 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41978 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41979 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41980 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41981 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41982 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41983 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41984 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41985 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41986 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41987 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41988 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41989 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41990 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41991 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41992 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41993 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41994 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41995 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41996 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41997 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41998 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41999 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42000 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42001 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42002 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42003 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42004 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42005 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42006 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42007 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42008 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42009 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42010 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42011 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42012 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42013 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42014 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42015 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42016 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42017 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42018 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42019 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42020 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42021 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42022 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42023 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42024 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42025 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42026 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42027 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42028 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42029 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42030 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42031 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42032 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42033 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42034 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42035 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42036 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42037 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42038 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42039 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42040 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42041 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42042 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42043 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42044 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42045 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42046 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42047 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42048 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42049 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42050 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42051 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42052 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42053 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42054 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42055 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42056 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42057 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42058
42059 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42060
42061 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42062 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42063 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42064 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42065 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42066 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42067 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42068 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42069 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42070 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42071 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42072 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42073 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42074 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42075 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42076 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42077 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42078 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42079 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42080 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42081 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42082 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42083 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42084 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42085 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42086 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42087 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42088 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42089 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42090 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42091 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42092 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42093 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42094 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42095 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42096 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42097 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42098 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42099 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42100 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42101 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42102 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42103 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42104 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42105 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42106 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42107 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42108 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42109 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42110 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42111 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42112 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42113 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42114
42115 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42116
42117 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42118 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42119 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42120 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42121 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42122 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42123 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42124 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42125 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42126 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42127 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42128 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42129 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42130 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42131 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42132 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42133 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42134 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42135 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42136 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42193
42194 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42195
42196 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42197 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42198 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42199 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42200 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42201 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42202 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42203 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42204 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42205 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42206 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42207 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42208 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42209 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42210 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42211 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42212 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42213 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42214 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42215 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42216 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42217 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42218 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42219 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42220 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42221 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42222 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42223 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42224 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42225 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42226 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42227 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42228 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42229 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42230 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42231 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42232 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42233 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42234 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42235 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42236 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42237 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42238 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42239 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42240 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42241 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42242 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42243 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42244 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42245 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42246 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42247 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42248 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42249 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42250 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42251 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42252 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42253 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42254 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42255 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42256 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42257 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42258 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42259 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42260 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42261 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42262 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42263 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42264 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42265 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42266 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42267 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42268 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42269 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42270 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42271 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42272 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42273 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42274 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42275 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42276 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42277 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42278 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42279 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42280 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42281 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42282 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42283 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42284 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42285 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42286 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42287 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42288 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42289 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42290 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42291 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42292 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42293 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42294 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42295 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42296 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42297 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42298 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42299 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42300 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42301 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42302 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42303 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42304 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42305 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42306 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42307 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42308 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42309 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42310 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42311 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42312 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42313 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42314 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42315 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42316 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42317 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42318 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42319 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42320 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42321 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42322 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42323 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42324 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42325 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42326 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42327 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42328 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42329 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42330 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42331 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42332 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42333 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42334 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42335 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42336 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42337 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42338 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42339 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42340 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42341 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42342 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42343 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42344 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42345 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42346 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42347 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42348 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42349 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42350 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42351 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42352 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42353 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42354 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42355 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42356 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42357 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42358 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42359 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42360 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42361 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42362 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42363 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42364 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42365 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42366 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42367 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42368 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42369 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42370 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42371 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42372 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42373 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42374 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42375 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42376 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42377 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42378 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42379 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42380 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42381 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42382 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42383 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42384 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42385 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42386 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42387 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42388 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42389 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42390 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42391 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42392 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42393 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42394 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42395 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42396 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42397 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42398 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42399
42400 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42401 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42402 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42403 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42404
42405 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42406 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42407 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42408 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42409 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42410 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42411 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42412 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42413 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42414 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42415 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42416 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42417 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42418 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42419 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42420 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42421 }
42422
wxWidgets (Impactor)