]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
merge from 2.8 branch
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTGAHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTIFFHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTextCtrl swig_types[157]
2624 #define SWIGTYPE_p_wxTextDataObject swig_types[158]
2625 #define SWIGTYPE_p_wxTimeSpan swig_types[159]
2626 #define SWIGTYPE_p_wxTimer swig_types[160]
2627 #define SWIGTYPE_p_wxTimerEvent swig_types[161]
2628 #define SWIGTYPE_p_wxTimerRunner swig_types[162]
2629 #define SWIGTYPE_p_wxTipProvider swig_types[163]
2630 #define SWIGTYPE_p_wxToolTip swig_types[164]
2631 #define SWIGTYPE_p_wxURLDataObject swig_types[165]
2632 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[166]
2633 #define SWIGTYPE_p_wxValidator swig_types[167]
2634 #define SWIGTYPE_p_wxVideoMode swig_types[168]
2635 #define SWIGTYPE_p_wxWindow swig_types[169]
2636 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDisabler swig_types[172]
2639 #define SWIGTYPE_p_wxXPMHandler swig_types[173]
2640 static swig_type_info *swig_types[175];
2641 static swig_module_info swig_module = {swig_types, 174, 0, 0, 0, 0};
2642 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2643 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2644
2645 /* -------- TYPES TABLE (END) -------- */
2646
2647 #if (PY_VERSION_HEX <= 0x02000000)
2648 # if !defined(SWIG_PYTHON_CLASSIC)
2649 # error "This python version requires to use swig with the '-classic' option"
2650 # endif
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodern' option"
2654 #endif
2655 #if (PY_VERSION_HEX <= 0x02020000)
2656 # error "This python version requires to use swig with the '-nomodernargs' option"
2657 #endif
2658 #ifndef METH_O
2659 # error "This python version requires to use swig with the '-nofastunpack' option"
2660 #endif
2661
2662 /*-----------------------------------------------
2663 @(target):= _misc_.so
2664 ------------------------------------------------*/
2665 #define SWIG_init init_misc_
2666
2667 #define SWIG_name "_misc_"
2668
2669 #define SWIGVERSION 0x010329
2670
2671
2672 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2673 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2674
2675
2676 #include <stdexcept>
2677
2678
2679 namespace swig {
2680 class PyObject_ptr {
2681 protected:
2682 PyObject *_obj;
2683
2684 public:
2685 PyObject_ptr() :_obj(0)
2686 {
2687 }
2688
2689 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2690 {
2691 Py_XINCREF(_obj);
2692 }
2693
2694 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2695 {
2696 if (initial_ref) Py_XINCREF(_obj);
2697 }
2698
2699 PyObject_ptr & operator=(const PyObject_ptr& item)
2700 {
2701 Py_XINCREF(item._obj);
2702 Py_XDECREF(_obj);
2703 _obj = item._obj;
2704 return *this;
2705 }
2706
2707 ~PyObject_ptr()
2708 {
2709 Py_XDECREF(_obj);
2710 }
2711
2712 operator PyObject *() const
2713 {
2714 return _obj;
2715 }
2716
2717 PyObject *operator->() const
2718 {
2719 return _obj;
2720 }
2721 };
2722 }
2723
2724
2725 namespace swig {
2726 struct PyObject_var : PyObject_ptr {
2727 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2728
2729 PyObject_var & operator = (PyObject* obj)
2730 {
2731 Py_XDECREF(_obj);
2732 _obj = obj;
2733 return *this;
2734 }
2735 };
2736 }
2737
2738
2739 #include "wx/wxPython/wxPython.h"
2740 #include "wx/wxPython/pyclasses.h"
2741 #include "wx/wxPython/pyistream.h"
2742
2743 static const wxString wxPyEmptyString(wxEmptyString);
2744
2745
2746
2747 #define SWIG_From_long PyInt_FromLong
2748
2749
2750 SWIGINTERNINLINE PyObject *
2751 SWIG_From_int (int value)
2752 {
2753 return SWIG_From_long (value);
2754 }
2755
2756
2757 #include <limits.h>
2758 #ifndef LLONG_MIN
2759 # define LLONG_MIN LONG_LONG_MIN
2760 #endif
2761 #ifndef LLONG_MAX
2762 # define LLONG_MAX LONG_LONG_MAX
2763 #endif
2764 #ifndef ULLONG_MAX
2765 # define ULLONG_MAX ULONG_LONG_MAX
2766 #endif
2767
2768
2769 SWIGINTERN int
2770 SWIG_AsVal_long (PyObject* obj, long* val)
2771 {
2772 if (PyNumber_Check(obj)) {
2773 if (val) *val = PyInt_AsLong(obj);
2774 return SWIG_OK;
2775 }
2776 return SWIG_TypeError;
2777 }
2778
2779
2780 SWIGINTERN int
2781 SWIG_AsVal_int (PyObject * obj, int *val)
2782 {
2783 long v;
2784 int res = SWIG_AsVal_long (obj, &v);
2785 if (SWIG_IsOK(res)) {
2786 if ((v < INT_MIN || v > INT_MAX)) {
2787 return SWIG_OverflowError;
2788 } else {
2789 if (val) *val = static_cast< int >(v);
2790 }
2791 }
2792 return res;
2793 }
2794
2795 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2796
2797 #include <wx/stockitem.h>
2798
2799 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2800 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2801 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2802
2803 SWIGINTERN int
2804 SWIG_AsVal_bool (PyObject *obj, bool *val)
2805 {
2806 if (obj == Py_True) {
2807 if (val) *val = true;
2808 return SWIG_OK;
2809 } else if (obj == Py_False) {
2810 if (val) *val = false;
2811 return SWIG_OK;
2812 } else {
2813 long v = 0;
2814 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2815 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2816 return res;
2817 }
2818 }
2819
2820
2821 wxMemorySize wxGetFreeMemory()
2822 { wxPyRaiseNotImplemented(); return 0; }
2823
2824
2825 SWIGINTERN int
2826 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2827 {
2828 long v = 0;
2829 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2830 return SWIG_TypeError;
2831 }
2832 else if (val)
2833 *val = (unsigned long)v;
2834 return SWIG_OK;
2835 }
2836
2837
2838 SWIGINTERNINLINE PyObject*
2839 SWIG_From_unsigned_SS_long (unsigned long value)
2840 {
2841 return (value > LONG_MAX) ?
2842 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2843 }
2844
2845
2846 void* wxGetXDisplay()
2847 {
2848 #ifdef __WXGTK__
2849 return wxGetDisplay();
2850 #else
2851 return NULL;
2852 #endif
2853 }
2854
2855
2856 wxWindow* FindWindowAtPointer() {
2857 wxPoint unused;
2858 return wxFindWindowAtPointer(unused);
2859 }
2860
2861
2862 void wxWakeUpMainThread() {}
2863
2864
2865 bool wxThread_IsMain() {
2866 #ifdef WXP_WITH_THREAD
2867 return wxThread::IsMain();
2868 #else
2869 return true;
2870 #endif
2871 }
2872
2873 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2874 delete self;
2875 }
2876
2877 #include <wx/snglinst.h>
2878
2879
2880 #ifdef __WXMSW__
2881 #include <wx/msw/private.h>
2882 #include <wx/dynload.h>
2883 #endif
2884
2885
2886
2887 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2888 #if 0
2889 , int method
2890 #endif
2891 )
2892 {
2893 #ifdef __WXMSW__
2894 #if 0
2895 switch (method)
2896 {
2897 case 1:
2898 // This one only partially works. Appears to be an undocumented
2899 // "standard" convention that not all widgets adhear to. For
2900 // example, for some widgets backgrounds or non-client areas may
2901 // not be painted.
2902 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2903 break;
2904
2905 case 2:
2906 #endif
2907 // This one works much better, nearly all widgets and their
2908 // children are captured correctly[**]. Prior to the big
2909 // background erase changes that Vadim did in 2004-2005 this
2910 // method failed badly on XP with Themes activated, most native
2911 // widgets draw only partially, if at all. Without themes it
2912 // worked just like on Win2k. After those changes this method
2913 // works very well.
2914 //
2915 // ** For example the radio buttons in a wxRadioBox are not its
2916 // children by default, but you can capture it via the panel
2917 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2918 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2919 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2920 PRF_ERASEBKGND | PRF_OWNED );
2921 return true;
2922 #if 0
2923 break;
2924
2925 case 3:
2926 // This one is only defined in the latest SDK and is only
2927 // available on XP. MSDN says it is similar to sending WM_PRINT
2928 // so I expect that it will work similar to the above. Since it
2929 // is avaialble only on XP, it can't be compiled like this and
2930 // will have to be loaded dynamically.
2931 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2932
2933 // fall through
2934
2935 case 4:
2936 // Use PrintWindow if available, or fallback to WM_PRINT
2937 // otherwise. Unfortunately using PrintWindow is even worse than
2938 // WM_PRINT. For most native widgets nothing is drawn to the dc
2939 // at all, with or without Themes.
2940 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2941 static bool s_triedToLoad = false;
2942 static PrintWindow_t pfnPrintWindow = NULL;
2943 if ( !s_triedToLoad )
2944 {
2945
2946 s_triedToLoad = true;
2947 wxDynamicLibrary dllUser32(_T("user32.dll"));
2948 if ( dllUser32.IsLoaded() )
2949 {
2950 wxLogNull nolog; // Don't report errors here
2951 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2952 }
2953 }
2954 if (pfnPrintWindow)
2955 {
2956 //printf("Using PrintWindow\n");
2957 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2958 }
2959 else
2960 {
2961 //printf("Using WM_PRINT\n");
2962 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2963 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2964 PRF_ERASEBKGND | PRF_OWNED );
2965 }
2966 }
2967 #endif // 0
2968 #else
2969 return false;
2970 #endif // __WXMSW__
2971 }
2972
2973
2974
2975 #include <wx/tipdlg.h>
2976
2977
2978 SWIGINTERNINLINE PyObject *
2979 SWIG_From_size_t (size_t value)
2980 {
2981 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2982 }
2983
2984
2985 class wxPyTipProvider : public wxTipProvider {
2986 public:
2987 wxPyTipProvider(size_t currentTip)
2988 : wxTipProvider(currentTip) {}
2989
2990 DEC_PYCALLBACK_STRING__pure(GetTip);
2991 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2992 PYPRIVATE;
2993 };
2994
2995 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2996 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2997
2998
2999 SWIGINTERNINLINE int
3000 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3001 {
3002 unsigned long v;
3003 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3004 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3005 return res;
3006 }
3007
3008
3009 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3010
3011 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3012
3013 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3014 : wxTimer(owner, id)
3015 {
3016 if (owner == NULL)
3017 SetOwner(this);
3018 }
3019
3020 wxPyTimer::~wxPyTimer()
3021 {
3022 // printf("-=* ~wxPyTimer\n");
3023 }
3024
3025
3026
3027 SWIGINTERN swig_type_info*
3028 SWIG_pchar_descriptor()
3029 {
3030 static int init = 0;
3031 static swig_type_info* info = 0;
3032 if (!init) {
3033 info = SWIG_TypeQuery("_p_char");
3034 init = 1;
3035 }
3036 return info;
3037 }
3038
3039
3040 SWIGINTERNINLINE PyObject *
3041 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3042 {
3043 if (carray) {
3044 if (size > INT_MAX) {
3045 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3046 return pchar_descriptor ?
3047 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3048 } else {
3049 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3050 }
3051 } else {
3052 return SWIG_Py_Void();
3053 }
3054 }
3055
3056
3057 SWIGINTERNINLINE PyObject *
3058 SWIG_FromCharPtr(const char *cptr)
3059 {
3060 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3061 }
3062
3063
3064 SWIGINTERN int
3065 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3066 {
3067 unsigned long v;
3068 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3069 if (SWIG_IsOK(res)) {
3070 if ((v > UINT_MAX)) {
3071 return SWIG_OverflowError;
3072 } else {
3073 if (val) *val = static_cast< unsigned int >(v);
3074 }
3075 }
3076 return res;
3077 }
3078
3079 SWIGINTERN wxString wxLog_TimeStamp(){
3080 wxString msg;
3081 wxLog::TimeStamp(&msg);
3082 return msg;
3083 }
3084 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3085 // Make some wrappers that double any % signs so they are 'escaped'
3086 void wxPyLogFatalError(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogFatalError(m);
3091 }
3092
3093 void wxPyLogError(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogError(m);
3098 }
3099
3100 void wxPyLogWarning(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogWarning(m);
3105 }
3106
3107 void wxPyLogMessage(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogMessage(m);
3112 }
3113
3114 void wxPyLogInfo(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogInfo(m);
3119 }
3120
3121 void wxPyLogDebug(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogDebug(m);
3126 }
3127
3128 void wxPyLogVerbose(const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogVerbose(m);
3133 }
3134
3135 void wxPyLogStatus(const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogStatus(m);
3140 }
3141
3142 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogStatus(pFrame, m);
3147 }
3148
3149 void wxPyLogSysError(const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogSysError(m);
3154 }
3155
3156 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogGeneric(level, m);
3161 }
3162
3163 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3164 {
3165 wxString m(msg);
3166 m.Replace(wxT("%"), wxT("%%"));
3167 wxLogTrace(mask, m);
3168 }
3169
3170 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3171 {
3172 wxString m(msg);
3173 m.Replace(wxT("%"), wxT("%%"));
3174 wxLogTrace(mask, m);
3175 }
3176
3177
3178
3179 // A wxLog class that can be derived from in wxPython
3180 class wxPyLog : public wxLog {
3181 public:
3182 wxPyLog() : wxLog() {}
3183
3184 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3185 bool found;
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3188 PyObject* s = wx2PyString(szString);
3189 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3190 Py_DECREF(s);
3191 }
3192 wxPyEndBlockThreads(blocked);
3193 if (! found)
3194 wxLog::DoLog(level, szString, t);
3195 }
3196
3197 virtual void DoLogString(const wxChar *szString, time_t t) {
3198 bool found;
3199 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3200 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3201 PyObject* s = wx2PyString(szString);
3202 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3203 Py_DECREF(s);
3204 }
3205 wxPyEndBlockThreads(blocked);
3206 if (! found)
3207 wxLog::DoLogString(szString, t);
3208 }
3209
3210 DEC_PYCALLBACK_VOID_(Flush);
3211 PYPRIVATE;
3212 };
3213 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3214
3215
3216
3217
3218 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3219
3220
3221 #include <wx/joystick.h>
3222
3223
3224 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3225 // A C++ stub class for wxJoystick for platforms that don't have it.
3226 class wxJoystick : public wxObject {
3227 public:
3228 wxJoystick(int joystick = wxJOYSTICK1) {
3229 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3230 PyErr_SetString(PyExc_NotImplementedError,
3231 "wxJoystick is not available on this platform.");
3232 wxPyEndBlockThreads(blocked);
3233 }
3234 wxPoint GetPosition() { return wxPoint(-1,-1); }
3235 int GetZPosition() { return -1; }
3236 int GetButtonState() { return -1; }
3237 int GetPOVPosition() { return -1; }
3238 int GetPOVCTSPosition() { return -1; }
3239 int GetRudderPosition() { return -1; }
3240 int GetUPosition() { return -1; }
3241 int GetVPosition() { return -1; }
3242 int GetMovementThreshold() { return -1; }
3243 void SetMovementThreshold(int threshold) {}
3244
3245 bool IsOk(void) { return false; }
3246 int GetNumberJoysticks() { return -1; }
3247 int GetManufacturerId() { return -1; }
3248 int GetProductId() { return -1; }
3249 wxString GetProductName() { return wxEmptyString; }
3250 int GetXMin() { return -1; }
3251 int GetYMin() { return -1; }
3252 int GetZMin() { return -1; }
3253 int GetXMax() { return -1; }
3254 int GetYMax() { return -1; }
3255 int GetZMax() { return -1; }
3256 int GetNumberButtons() { return -1; }
3257 int GetNumberAxes() { return -1; }
3258 int GetMaxButtons() { return -1; }
3259 int GetMaxAxes() { return -1; }
3260 int GetPollingMin() { return -1; }
3261 int GetPollingMax() { return -1; }
3262 int GetRudderMin() { return -1; }
3263 int GetRudderMax() { return -1; }
3264 int GetUMin() { return -1; }
3265 int GetUMax() { return -1; }
3266 int GetVMin() { return -1; }
3267 int GetVMax() { return -1; }
3268
3269 bool HasRudder() { return false; }
3270 bool HasZ() { return false; }
3271 bool HasU() { return false; }
3272 bool HasV() { return false; }
3273 bool HasPOV() { return false; }
3274 bool HasPOV4Dir() { return false; }
3275 bool HasPOVCTS() { return false; }
3276
3277 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3278 bool ReleaseCapture() { return false; }
3279 };
3280 #endif
3281
3282
3283 #include <wx/sound.h>
3284
3285
3286 #if !wxUSE_SOUND
3287 // A C++ stub class for wxWave for platforms that don't have it.
3288 class wxSound : public wxObject
3289 {
3290 public:
3291 wxSound() {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297 wxSound(const wxString&/*, bool*/) {
3298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3299 PyErr_SetString(PyExc_NotImplementedError,
3300 "wxSound is not available on this platform.");
3301 wxPyEndBlockThreads(blocked);
3302 }
3303 wxSound(int, const wxByte*) {
3304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3305 PyErr_SetString(PyExc_NotImplementedError,
3306 "wxSound is not available on this platform.");
3307 wxPyEndBlockThreads(blocked);
3308 }
3309
3310 ~wxSound() {};
3311
3312 bool Create(const wxString&/*, bool*/) { return false; }
3313 bool Create(int, const wxByte*) { return false; };
3314 bool IsOk() { return false; };
3315 bool Play(unsigned) const { return false; }
3316 static bool Play(const wxString&, unsigned) { return false; }
3317 static void Stop() {}
3318 };
3319
3320 #endif
3321
3322 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3323 if (fileName.Length() == 0)
3324 return new wxSound;
3325 else
3326 return new wxSound(fileName);
3327 }
3328 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3329 unsigned char* buffer; int size;
3330 wxSound *sound = NULL;
3331
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (!PyArg_Parse(data, "t#", &buffer, &size))
3334 goto done;
3335 sound = new wxSound(size, buffer);
3336 done:
3337 wxPyEndBlockThreads(blocked);
3338 return sound;
3339 }
3340 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3341 #ifndef __WXMAC__
3342 unsigned char* buffer;
3343 int size;
3344 bool rv = false;
3345
3346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3347 if (!PyArg_Parse(data, "t#", &buffer, &size))
3348 goto done;
3349 rv = self->Create(size, buffer);
3350 done:
3351 wxPyEndBlockThreads(blocked);
3352 return rv;
3353 #else
3354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3355 PyErr_SetString(PyExc_NotImplementedError,
3356 "Create from data is not available on this platform.");
3357 wxPyEndBlockThreads(blocked);
3358 return false;
3359 #endif
3360 }
3361
3362 #include <wx/mimetype.h>
3363
3364 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3365 wxString str;
3366 if (self->GetMimeType(&str))
3367 return wx2PyString(str);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3372 wxArrayString arr;
3373 if (self->GetMimeTypes(arr))
3374 return wxArrayString2PyList_helper(arr);
3375 else
3376 RETURN_NONE();
3377 }
3378 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3379 wxArrayString arr;
3380 if (self->GetExtensions(arr))
3381 return wxArrayString2PyList_helper(arr);
3382 else
3383 RETURN_NONE();
3384 }
3385 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3386 wxIconLocation loc;
3387 if (self->GetIcon(&loc))
3388 return new wxIcon(loc);
3389 else
3390 return NULL;
3391 }
3392 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3393 wxIconLocation loc;
3394 if (self->GetIcon(&loc)) {
3395 wxString iconFile = loc.GetFileName();
3396 int iconIndex = -1;
3397
3398
3399
3400 // Make a tuple and put the values in it
3401 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3402 PyObject* tuple = PyTuple_New(3);
3403 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3404 wxT("wxIcon"), true));
3405 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3406 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3407 wxPyEndBlockThreads(blocked);
3408 return tuple;
3409 }
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3414 wxString str;
3415 if (self->GetDescription(&str))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxString str;
3422 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3423 return wx2PyString(str);
3424 else
3425 RETURN_NONE();
3426 }
3427 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3428 wxString str;
3429 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3430 return wx2PyString(str);
3431 else
3432 RETURN_NONE();
3433 }
3434 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3435 wxArrayString verbs;
3436 wxArrayString commands;
3437 if (self->GetAllCommands(&verbs, &commands,
3438 wxFileType::MessageParameters(filename, mimetype))) {
3439 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3440 PyObject* tuple = PyTuple_New(2);
3441 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3442 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3443 wxPyEndBlockThreads(blocked);
3444 return tuple;
3445 }
3446 else
3447 RETURN_NONE();
3448 }
3449 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3450 return wxFileType::ExpandCommand(command,
3451 wxFileType::MessageParameters(filename, mimetype));
3452 }
3453 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3454 wxArrayString arr;
3455 self->EnumAllFileTypes(arr);
3456 return wxArrayString2PyList_helper(arr);
3457 }
3458
3459 #include <wx/artprov.h>
3460
3461 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3462 static const wxString wxPyART_MENU(wxART_MENU);
3463 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3464 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3465 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3466 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3467 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3468 static const wxString wxPyART_OTHER(wxART_OTHER);
3469 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3470 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3471 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3472 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3473 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3474 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3475 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3476 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3477 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3478 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3479 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3480 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3481 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3482 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3483 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3484 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3485 static const wxString wxPyART_PRINT(wxART_PRINT);
3486 static const wxString wxPyART_HELP(wxART_HELP);
3487 static const wxString wxPyART_TIP(wxART_TIP);
3488 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3489 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3490 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3491 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3492 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3493 static const wxString wxPyART_CDROM(wxART_CDROM);
3494 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3495 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3496 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3497 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3498 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3499 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3500 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3501 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3502 static const wxString wxPyART_ERROR(wxART_ERROR);
3503 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3504 static const wxString wxPyART_WARNING(wxART_WARNING);
3505 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3506 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3507 static const wxString wxPyART_COPY(wxART_COPY);
3508 static const wxString wxPyART_CUT(wxART_CUT);
3509 static const wxString wxPyART_PASTE(wxART_PASTE);
3510 static const wxString wxPyART_DELETE(wxART_DELETE);
3511 static const wxString wxPyART_NEW(wxART_NEW);
3512 static const wxString wxPyART_UNDO(wxART_UNDO);
3513 static const wxString wxPyART_REDO(wxART_REDO);
3514 static const wxString wxPyART_QUIT(wxART_QUIT);
3515 static const wxString wxPyART_FIND(wxART_FIND);
3516 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3517 // Python aware wxArtProvider
3518 class wxPyArtProvider : public wxArtProvider {
3519 public:
3520
3521 virtual wxBitmap CreateBitmap(const wxArtID& id,
3522 const wxArtClient& client,
3523 const wxSize& size) {
3524 wxBitmap rval = wxNullBitmap;
3525 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3526 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3527 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3528 PyObject* ro;
3529 wxBitmap* ptr;
3530 PyObject* s1, *s2;
3531 s1 = wx2PyString(id);
3532 s2 = wx2PyString(client);
3533 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3534 Py_DECREF(so);
3535 Py_DECREF(s1);
3536 Py_DECREF(s2);
3537 if (ro) {
3538 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3539 rval = *ptr;
3540 Py_DECREF(ro);
3541 }
3542 }
3543 wxPyEndBlockThreads(blocked);
3544 return rval;
3545 }
3546
3547 PYPRIVATE;
3548 };
3549
3550 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3551
3552
3553
3554 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3555 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3556 PyObject* ret = PyTuple_New(3);
3557 if (ret) {
3558 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3559 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3560 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3561 }
3562 wxPyEndBlockThreads(blocked);
3563 return ret;
3564 }
3565
3566 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3567 bool cont;
3568 long index = 0;
3569 wxString value;
3570
3571 cont = self->GetFirstGroup(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3575 bool cont;
3576 wxString value;
3577
3578 cont = self->GetNextGroup(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3582 bool cont;
3583 long index = 0;
3584 wxString value;
3585
3586 cont = self->GetFirstEntry(value, index);
3587 return __EnumerationHelper(cont, value, index);
3588 }
3589 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3590 bool cont;
3591 wxString value;
3592
3593 cont = self->GetNextEntry(value, index);
3594 return __EnumerationHelper(cont, value, index);
3595 }
3596 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3597 long rv;
3598 self->Read(key, &rv, defaultVal);
3599 return rv;
3600 }
3601
3602 SWIGINTERN int
3603 SWIG_AsVal_double (PyObject *obj, double* val)
3604 {
3605 if (PyNumber_Check(obj)) {
3606 if (val) *val = PyFloat_AsDouble(obj);
3607 return SWIG_OK;
3608 }
3609 return SWIG_TypeError;
3610 }
3611
3612 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3613 double rv;
3614 self->Read(key, &rv, defaultVal);
3615 return rv;
3616 }
3617
3618 #define SWIG_From_double PyFloat_FromDouble
3619
3620 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3621 bool rv;
3622 self->Read(key, &rv, defaultVal);
3623 return rv;
3624 }
3625
3626 #include <wx/datetime.h>
3627
3628 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3629 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3630
3631 #define LOCAL_TZ wxDateTime::Local
3632
3633 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3634 wxString am;
3635 wxString pm;
3636 wxDateTime::GetAmPmStrings(&am, &pm);
3637 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3638 PyObject* tup = PyTuple_New(2);
3639 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3640 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3641 wxPyEndBlockThreads(blocked);
3642 return tup;
3643 }
3644
3645 SWIGINTERNINLINE PyObject *
3646 SWIG_From_unsigned_SS_int (unsigned int value)
3647 {
3648 return SWIG_From_unsigned_SS_long (value);
3649 }
3650
3651 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3652 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3653 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3654 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3655 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3656 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3658 return (*self < *other);
3659 }
3660 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3662 return (*self <= *other);
3663 }
3664 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3665 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3666 return (*self > *other);
3667 }
3668 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3669 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3670 return (*self >= *other);
3671 }
3672 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3673 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3674 return (*self == *other);
3675 }
3676 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3677 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3678 return (*self != *other);
3679 }
3680 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3681 const wxChar* rv;
3682 const wxChar* _date = date;
3683 rv = self->ParseRfc822Date(_date);
3684 if (rv == NULL) return -1;
3685 return rv - _date;
3686 }
3687 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3688 const wxChar* rv;
3689 const wxChar* _date = date;
3690 rv = self->ParseFormat(_date, format, dateDef);
3691 if (rv == NULL) return -1;
3692 return rv - _date;
3693 }
3694 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3695 const wxChar* rv;
3696 const wxChar* _datetime = datetime;
3697 rv = self->ParseDateTime(_datetime);
3698 if (rv == NULL) return -1;
3699 return rv - _datetime;
3700 }
3701 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3702 const wxChar* rv;
3703 const wxChar* _date = date;
3704 rv = self->ParseDate(_date);
3705 if (rv == NULL) return -1;
3706 return rv - _date;
3707 }
3708 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3709 const wxChar* rv;
3710 const wxChar* _time = time;
3711 rv = self->ParseTime(_time);
3712 if (rv == NULL) return -1;
3713 return rv - _time;
3714 }
3715 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3716 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3717 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3718 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3719 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3720 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3721 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3722 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3723 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3724 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3725 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3726 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3727 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3728 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3729 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3730 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3731
3732 #include <wx/dataobj.h>
3733
3734 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3735 size_t count = self->GetFormatCount(dir);
3736 wxDataFormat* formats = new wxDataFormat[count];
3737 self->GetAllFormats(formats, dir);
3738
3739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3740 PyObject* list = PyList_New(count);
3741 for (size_t i=0; i<count; i++) {
3742 wxDataFormat* format = new wxDataFormat(formats[i]);
3743 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3744 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3745 }
3746 wxPyEndBlockThreads(blocked);
3747 delete [] formats;
3748 return list;
3749 }
3750 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3751 PyObject* rval = NULL;
3752 size_t size = self->GetDataSize(format);
3753 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3754 if (size) {
3755 char* buf = new char[size];
3756 if (self->GetDataHere(format, buf))
3757 rval = PyString_FromStringAndSize(buf, size);
3758 delete [] buf;
3759 }
3760 if (! rval) {
3761 rval = Py_None;
3762 Py_INCREF(rval);
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return rval;
3766 }
3767 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3768 bool rval;
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 if (PyString_Check(data)) {
3771 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3772 }
3773 else {
3774 // raise a TypeError if not a string
3775 PyErr_SetString(PyExc_TypeError, "String expected.");
3776 rval = false;
3777 }
3778 wxPyEndBlockThreads(blocked);
3779 return rval;
3780 }
3781 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3782 PyObject* rval = NULL;
3783 size_t size = self->GetDataSize();
3784 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3785 if (size) {
3786 char* buf = new char[size];
3787 if (self->GetDataHere(buf))
3788 rval = PyString_FromStringAndSize(buf, size);
3789 delete [] buf;
3790 }
3791 if (! rval) {
3792 rval = Py_None;
3793 Py_INCREF(rval);
3794 }
3795 wxPyEndBlockThreads(blocked);
3796 return rval;
3797 }
3798 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3799 bool rval;
3800 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3801 if (PyString_Check(data)) {
3802 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3803 }
3804 else {
3805 // raise a TypeError if not a string
3806 PyErr_SetString(PyExc_TypeError, "String expected.");
3807 rval = false;
3808 }
3809 wxPyEndBlockThreads(blocked);
3810 return rval;
3811 }
3812 // Create a new class for wxPython to use
3813 class wxPyDataObjectSimple : public wxDataObjectSimple {
3814 public:
3815 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3816 : wxDataObjectSimple(format) {}
3817
3818 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3819 bool GetDataHere(void *buf) const;
3820 bool SetData(size_t len, const void *buf);
3821 PYPRIVATE;
3822 };
3823
3824 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3825
3826 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3827 // We need to get the data for this object and write it to buf. I think
3828 // the best way to do this for wxPython is to have the Python method
3829 // return either a string or None and then act appropriately with the
3830 // C++ version.
3831
3832 bool rval = false;
3833 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3834 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3835 PyObject* ro;
3836 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3837 if (ro) {
3838 rval = (ro != Py_None && PyString_Check(ro));
3839 if (rval)
3840 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3841 Py_DECREF(ro);
3842 }
3843 }
3844 wxPyEndBlockThreads(blocked);
3845 return rval;
3846 }
3847
3848 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3849 // For this one we simply need to make a string from buf and len
3850 // and send it to the Python method.
3851 bool rval = false;
3852 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3853 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3854 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3855 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3856 Py_DECREF(data);
3857 }
3858 wxPyEndBlockThreads(blocked);
3859 return rval;
3860 }
3861
3862 // Create a new class for wxPython to use
3863 class wxPyTextDataObject : public wxTextDataObject {
3864 public:
3865 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3866 : wxTextDataObject(text) {}
3867
3868 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3869 DEC_PYCALLBACK_STRING__const(GetText);
3870 DEC_PYCALLBACK__STRING(SetText);
3871 PYPRIVATE;
3872 };
3873
3874 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3875 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3876 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3877
3878
3879 // Create a new class for wxPython to use
3880 class wxPyBitmapDataObject : public wxBitmapDataObject {
3881 public:
3882 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3883 : wxBitmapDataObject(bitmap) {}
3884
3885 wxBitmap GetBitmap() const;
3886 void SetBitmap(const wxBitmap& bitmap);
3887 PYPRIVATE;
3888 };
3889
3890 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3891 wxBitmap* rval = &wxNullBitmap;
3892 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3893 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3894 PyObject* ro;
3895 wxBitmap* ptr;
3896 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3897 if (ro) {
3898 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3899 rval = ptr;
3900 Py_DECREF(ro);
3901 }
3902 }
3903 wxPyEndBlockThreads(blocked);
3904 return *rval;
3905 }
3906
3907 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3909 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3910 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3911 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3912 Py_DECREF(bo);
3913 }
3914 wxPyEndBlockThreads(blocked);
3915 }
3916
3917 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3918 return new wxCustomDataObject(wxDataFormat(formatName));
3919 }
3920 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3921 bool rval;
3922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3923 if (PyString_Check(data)) {
3924 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3925 }
3926 else {
3927 // raise a TypeError if not a string
3928 PyErr_SetString(PyExc_TypeError, "String expected.");
3929 rval = false;
3930 }
3931 wxPyEndBlockThreads(blocked);
3932 return rval;
3933 }
3934 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3935 PyObject* obj;
3936 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3937 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3938 wxPyEndBlockThreads(blocked);
3939 return obj;
3940 }
3941
3942 class wxMetafileDataObject : public wxDataObjectSimple
3943 {
3944 public:
3945 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3946 };
3947
3948
3949 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3950
3951
3952 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3953 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3954 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3955 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3956 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3957
3958
3959 class wxPyTextDropTarget : public wxTextDropTarget {
3960 public:
3961 wxPyTextDropTarget() {}
3962
3963 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3964
3965 DEC_PYCALLBACK__(OnLeave);
3966 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3967 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3968 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3969 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3970
3971 PYPRIVATE;
3972 };
3973
3974 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3975 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3976 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3977 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3978 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3979 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3980
3981
3982
3983 class wxPyFileDropTarget : public wxFileDropTarget {
3984 public:
3985 wxPyFileDropTarget() {}
3986
3987 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3988
3989 DEC_PYCALLBACK__(OnLeave);
3990 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3991 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3992 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3993 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3994
3995 PYPRIVATE;
3996 };
3997
3998 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3999 const wxArrayString& filenames) {
4000 bool rval = false;
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
4003 PyObject* list = wxArrayString2PyList_helper(filenames);
4004 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
4005 Py_DECREF(list);
4006 }
4007 wxPyEndBlockThreads(blocked);
4008 return rval;
4009 }
4010
4011
4012
4013 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4014 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4015 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4016 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4017 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4018
4019
4020
4021
4022 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4023
4024 #include <wx/display.h>
4025 #include <wx/vidmode.h>
4026
4027 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4028 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4029
4030 #if !wxUSE_DISPLAY
4031 const wxVideoMode wxDefaultVideoMode;
4032 #endif
4033
4034 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4035 #if wxUSE_DISPLAY
4036 PyObject* pyList = NULL;
4037 wxArrayVideoModes arr = self->GetModes(mode);
4038 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4039 pyList = PyList_New(0);
4040 for (size_t i=0; i < arr.GetCount(); i++)
4041 {
4042 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4043 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4044 PyList_Append(pyList, pyObj);
4045 Py_DECREF(pyObj);
4046 }
4047 wxPyEndBlockThreads(blocked);
4048 return pyList;
4049 #else
4050 wxPyRaiseNotImplemented();
4051 return NULL;
4052 #endif
4053 }
4054 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4055 #if wxUSE_DISPLAY
4056 return self->GetCurrentMode();
4057 #else
4058 wxPyRaiseNotImplemented();
4059 return wxDefaultVideoMode;
4060 #endif
4061 }
4062 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4063 #if wxUSE_DISPLAY
4064 return self->ChangeMode(mode);
4065 #else
4066 wxPyRaiseNotImplemented();
4067 return false;
4068 #endif
4069 }
4070 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4071 #if wxUSE_DISPLAY
4072 self->ResetMode();
4073 #else
4074 wxPyRaiseNotImplemented();
4075 #endif
4076 }
4077
4078 #include <wx/stdpaths.h>
4079
4080 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4081 return (wxStandardPaths*) &wxStandardPaths::Get();
4082 }
4083
4084 #ifndef wxHAS_POWER_EVENTS
4085 // Dummy class and other definitions for platforms that don't have them
4086
4087 // See wxPython_int.h for wxPowerEvent
4088
4089 enum {
4090 wxEVT_POWER_SUSPENDING,
4091 wxEVT_POWER_SUSPENDED,
4092 wxEVT_POWER_SUSPEND_CANCEL,
4093 wxEVT_POWER_RESUME,
4094 };
4095
4096 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4097 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4098
4099 #endif
4100
4101
4102 #include <wx/aboutdlg.h>
4103
4104 #ifdef __cplusplus
4105 extern "C" {
4106 #endif
4107 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4108 PyObject *resultobj = 0;
4109 wxSystemColour arg1 ;
4110 wxColour result;
4111 int val1 ;
4112 int ecode1 = 0 ;
4113 PyObject * obj0 = 0 ;
4114 char * kwnames[] = {
4115 (char *) "index", NULL
4116 };
4117
4118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4119 ecode1 = SWIG_AsVal_int(obj0, &val1);
4120 if (!SWIG_IsOK(ecode1)) {
4121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4122 }
4123 arg1 = static_cast< wxSystemColour >(val1);
4124 {
4125 if (!wxPyCheckForApp()) SWIG_fail;
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 result = wxSystemSettings::GetColour(arg1);
4128 wxPyEndAllowThreads(__tstate);
4129 if (PyErr_Occurred()) SWIG_fail;
4130 }
4131 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4132 return resultobj;
4133 fail:
4134 return NULL;
4135 }
4136
4137
4138 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4139 PyObject *resultobj = 0;
4140 wxSystemFont arg1 ;
4141 wxFont result;
4142 int val1 ;
4143 int ecode1 = 0 ;
4144 PyObject * obj0 = 0 ;
4145 char * kwnames[] = {
4146 (char *) "index", NULL
4147 };
4148
4149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4150 ecode1 = SWIG_AsVal_int(obj0, &val1);
4151 if (!SWIG_IsOK(ecode1)) {
4152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4153 }
4154 arg1 = static_cast< wxSystemFont >(val1);
4155 {
4156 if (!wxPyCheckForApp()) SWIG_fail;
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = wxSystemSettings::GetFont(arg1);
4159 wxPyEndAllowThreads(__tstate);
4160 if (PyErr_Occurred()) SWIG_fail;
4161 }
4162 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4163 return resultobj;
4164 fail:
4165 return NULL;
4166 }
4167
4168
4169 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4170 PyObject *resultobj = 0;
4171 wxSystemMetric arg1 ;
4172 wxWindow *arg2 = (wxWindow *) NULL ;
4173 int result;
4174 int val1 ;
4175 int ecode1 = 0 ;
4176 void *argp2 = 0 ;
4177 int res2 = 0 ;
4178 PyObject * obj0 = 0 ;
4179 PyObject * obj1 = 0 ;
4180 char * kwnames[] = {
4181 (char *) "index",(char *) "win", NULL
4182 };
4183
4184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4185 ecode1 = SWIG_AsVal_int(obj0, &val1);
4186 if (!SWIG_IsOK(ecode1)) {
4187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4188 }
4189 arg1 = static_cast< wxSystemMetric >(val1);
4190 if (obj1) {
4191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4192 if (!SWIG_IsOK(res2)) {
4193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4194 }
4195 arg2 = reinterpret_cast< wxWindow * >(argp2);
4196 }
4197 {
4198 if (!wxPyCheckForApp()) SWIG_fail;
4199 PyThreadState* __tstate = wxPyBeginAllowThreads();
4200 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4201 wxPyEndAllowThreads(__tstate);
4202 if (PyErr_Occurred()) SWIG_fail;
4203 }
4204 resultobj = SWIG_From_int(static_cast< int >(result));
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj = 0;
4213 wxSystemFeature arg1 ;
4214 bool result;
4215 int val1 ;
4216 int ecode1 = 0 ;
4217 PyObject * obj0 = 0 ;
4218 char * kwnames[] = {
4219 (char *) "index", NULL
4220 };
4221
4222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4223 ecode1 = SWIG_AsVal_int(obj0, &val1);
4224 if (!SWIG_IsOK(ecode1)) {
4225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4226 }
4227 arg1 = static_cast< wxSystemFeature >(val1);
4228 {
4229 if (!wxPyCheckForApp()) SWIG_fail;
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = (bool)wxSystemSettings::HasFeature(arg1);
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 {
4236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4237 }
4238 return resultobj;
4239 fail:
4240 return NULL;
4241 }
4242
4243
4244 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4245 PyObject *resultobj = 0;
4246 wxSystemScreenType result;
4247
4248 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4249 {
4250 if (!wxPyCheckForApp()) SWIG_fail;
4251 PyThreadState* __tstate = wxPyBeginAllowThreads();
4252 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 resultobj = SWIG_From_int(static_cast< int >(result));
4257 return resultobj;
4258 fail:
4259 return NULL;
4260 }
4261
4262
4263 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4264 PyObject *resultobj = 0;
4265 wxSystemScreenType arg1 ;
4266 int val1 ;
4267 int ecode1 = 0 ;
4268 PyObject * obj0 = 0 ;
4269 char * kwnames[] = {
4270 (char *) "screen", NULL
4271 };
4272
4273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4274 ecode1 = SWIG_AsVal_int(obj0, &val1);
4275 if (!SWIG_IsOK(ecode1)) {
4276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4277 }
4278 arg1 = static_cast< wxSystemScreenType >(val1);
4279 {
4280 if (!wxPyCheckForApp()) SWIG_fail;
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 wxSystemSettings::SetScreenType(arg1);
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 resultobj = SWIG_Py_Void();
4287 return resultobj;
4288 fail:
4289 return NULL;
4290 }
4291
4292
4293 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4294 PyObject *obj;
4295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4296 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4297 return SWIG_Py_Void();
4298 }
4299
4300 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4301 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4302 return 1;
4303 }
4304
4305
4306 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4307 PyObject *pyobj = 0;
4308
4309 {
4310 #if wxUSE_UNICODE
4311 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4312 #else
4313 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4314 #endif
4315 }
4316 return pyobj;
4317 }
4318
4319
4320 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4321 PyObject *resultobj = 0;
4322 wxSystemOptions *result = 0 ;
4323
4324 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4325 {
4326 PyThreadState* __tstate = wxPyBeginAllowThreads();
4327 result = (wxSystemOptions *)new wxSystemOptions();
4328 wxPyEndAllowThreads(__tstate);
4329 if (PyErr_Occurred()) SWIG_fail;
4330 }
4331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj = 0;
4340 wxString *arg1 = 0 ;
4341 wxString *arg2 = 0 ;
4342 bool temp1 = false ;
4343 bool temp2 = false ;
4344 PyObject * obj0 = 0 ;
4345 PyObject * obj1 = 0 ;
4346 char * kwnames[] = {
4347 (char *) "name",(char *) "value", NULL
4348 };
4349
4350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4351 {
4352 arg1 = wxString_in_helper(obj0);
4353 if (arg1 == NULL) SWIG_fail;
4354 temp1 = true;
4355 }
4356 {
4357 arg2 = wxString_in_helper(obj1);
4358 if (arg2 == NULL) SWIG_fail;
4359 temp2 = true;
4360 }
4361 {
4362 PyThreadState* __tstate = wxPyBeginAllowThreads();
4363 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4364 wxPyEndAllowThreads(__tstate);
4365 if (PyErr_Occurred()) SWIG_fail;
4366 }
4367 resultobj = SWIG_Py_Void();
4368 {
4369 if (temp1)
4370 delete arg1;
4371 }
4372 {
4373 if (temp2)
4374 delete arg2;
4375 }
4376 return resultobj;
4377 fail:
4378 {
4379 if (temp1)
4380 delete arg1;
4381 }
4382 {
4383 if (temp2)
4384 delete arg2;
4385 }
4386 return NULL;
4387 }
4388
4389
4390 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4391 PyObject *resultobj = 0;
4392 wxString *arg1 = 0 ;
4393 int arg2 ;
4394 bool temp1 = false ;
4395 int val2 ;
4396 int ecode2 = 0 ;
4397 PyObject * obj0 = 0 ;
4398 PyObject * obj1 = 0 ;
4399 char * kwnames[] = {
4400 (char *) "name",(char *) "value", NULL
4401 };
4402
4403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4404 {
4405 arg1 = wxString_in_helper(obj0);
4406 if (arg1 == NULL) SWIG_fail;
4407 temp1 = true;
4408 }
4409 ecode2 = SWIG_AsVal_int(obj1, &val2);
4410 if (!SWIG_IsOK(ecode2)) {
4411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4412 }
4413 arg2 = static_cast< int >(val2);
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 resultobj = SWIG_Py_Void();
4421 {
4422 if (temp1)
4423 delete arg1;
4424 }
4425 return resultobj;
4426 fail:
4427 {
4428 if (temp1)
4429 delete arg1;
4430 }
4431 return NULL;
4432 }
4433
4434
4435 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj = 0;
4437 wxString *arg1 = 0 ;
4438 wxString result;
4439 bool temp1 = false ;
4440 PyObject * obj0 = 0 ;
4441 char * kwnames[] = {
4442 (char *) "name", NULL
4443 };
4444
4445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4446 {
4447 arg1 = wxString_in_helper(obj0);
4448 if (arg1 == NULL) SWIG_fail;
4449 temp1 = true;
4450 }
4451 {
4452 PyThreadState* __tstate = wxPyBeginAllowThreads();
4453 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4454 wxPyEndAllowThreads(__tstate);
4455 if (PyErr_Occurred()) SWIG_fail;
4456 }
4457 {
4458 #if wxUSE_UNICODE
4459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4460 #else
4461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4462 #endif
4463 }
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return resultobj;
4469 fail:
4470 {
4471 if (temp1)
4472 delete arg1;
4473 }
4474 return NULL;
4475 }
4476
4477
4478 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4479 PyObject *resultobj = 0;
4480 wxString *arg1 = 0 ;
4481 int result;
4482 bool temp1 = false ;
4483 PyObject * obj0 = 0 ;
4484 char * kwnames[] = {
4485 (char *) "name", NULL
4486 };
4487
4488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4489 {
4490 arg1 = wxString_in_helper(obj0);
4491 if (arg1 == NULL) SWIG_fail;
4492 temp1 = true;
4493 }
4494 {
4495 PyThreadState* __tstate = wxPyBeginAllowThreads();
4496 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4497 wxPyEndAllowThreads(__tstate);
4498 if (PyErr_Occurred()) SWIG_fail;
4499 }
4500 resultobj = SWIG_From_int(static_cast< int >(result));
4501 {
4502 if (temp1)
4503 delete arg1;
4504 }
4505 return resultobj;
4506 fail:
4507 {
4508 if (temp1)
4509 delete arg1;
4510 }
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4516 PyObject *resultobj = 0;
4517 wxString *arg1 = 0 ;
4518 bool result;
4519 bool temp1 = false ;
4520 PyObject * obj0 = 0 ;
4521 char * kwnames[] = {
4522 (char *) "name", NULL
4523 };
4524
4525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4526 {
4527 arg1 = wxString_in_helper(obj0);
4528 if (arg1 == NULL) SWIG_fail;
4529 temp1 = true;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4539 }
4540 {
4541 if (temp1)
4542 delete arg1;
4543 }
4544 return resultobj;
4545 fail:
4546 {
4547 if (temp1)
4548 delete arg1;
4549 }
4550 return NULL;
4551 }
4552
4553
4554 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4555 PyObject *resultobj = 0;
4556 wxString *arg1 = 0 ;
4557 bool result;
4558 bool temp1 = false ;
4559 PyObject * obj0 = 0 ;
4560 char * kwnames[] = {
4561 (char *) "name", NULL
4562 };
4563
4564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4565 {
4566 arg1 = wxString_in_helper(obj0);
4567 if (arg1 == NULL) SWIG_fail;
4568 temp1 = true;
4569 }
4570 {
4571 PyThreadState* __tstate = wxPyBeginAllowThreads();
4572 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4573 wxPyEndAllowThreads(__tstate);
4574 if (PyErr_Occurred()) SWIG_fail;
4575 }
4576 {
4577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4578 }
4579 {
4580 if (temp1)
4581 delete arg1;
4582 }
4583 return resultobj;
4584 fail:
4585 {
4586 if (temp1)
4587 delete arg1;
4588 }
4589 return NULL;
4590 }
4591
4592
4593 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4594 PyObject *obj;
4595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4596 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4597 return SWIG_Py_Void();
4598 }
4599
4600 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4601 return SWIG_Python_InitShadowInstance(args);
4602 }
4603
4604 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4605 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4606 return 1;
4607 }
4608
4609
4610 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4611 PyObject *pyobj = 0;
4612
4613 {
4614 #if wxUSE_UNICODE
4615 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4616 #else
4617 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4618 #endif
4619 }
4620 return pyobj;
4621 }
4622
4623
4624 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4625 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4626 return 1;
4627 }
4628
4629
4630 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4631 PyObject *pyobj = 0;
4632
4633 {
4634 #if wxUSE_UNICODE
4635 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4636 #else
4637 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4638 #endif
4639 }
4640 return pyobj;
4641 }
4642
4643
4644 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4645 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4646 return 1;
4647 }
4648
4649
4650 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4651 PyObject *pyobj = 0;
4652
4653 {
4654 #if wxUSE_UNICODE
4655 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4656 #else
4657 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4658 #endif
4659 }
4660 return pyobj;
4661 }
4662
4663
4664 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4665 PyObject *resultobj = 0;
4666 long result;
4667
4668 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4669 {
4670 PyThreadState* __tstate = wxPyBeginAllowThreads();
4671 result = (long)wxNewId();
4672 wxPyEndAllowThreads(__tstate);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 resultobj = SWIG_From_long(static_cast< long >(result));
4676 return resultobj;
4677 fail:
4678 return NULL;
4679 }
4680
4681
4682 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4683 PyObject *resultobj = 0;
4684 long arg1 ;
4685 long val1 ;
4686 int ecode1 = 0 ;
4687 PyObject * obj0 = 0 ;
4688 char * kwnames[] = {
4689 (char *) "id", NULL
4690 };
4691
4692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4693 ecode1 = SWIG_AsVal_long(obj0, &val1);
4694 if (!SWIG_IsOK(ecode1)) {
4695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4696 }
4697 arg1 = static_cast< long >(val1);
4698 {
4699 PyThreadState* __tstate = wxPyBeginAllowThreads();
4700 wxRegisterId(arg1);
4701 wxPyEndAllowThreads(__tstate);
4702 if (PyErr_Occurred()) SWIG_fail;
4703 }
4704 resultobj = SWIG_Py_Void();
4705 return resultobj;
4706 fail:
4707 return NULL;
4708 }
4709
4710
4711 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4712 PyObject *resultobj = 0;
4713 long result;
4714
4715 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = (long)wxGetCurrentId();
4719 wxPyEndAllowThreads(__tstate);
4720 if (PyErr_Occurred()) SWIG_fail;
4721 }
4722 resultobj = SWIG_From_long(static_cast< long >(result));
4723 return resultobj;
4724 fail:
4725 return NULL;
4726 }
4727
4728
4729 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4730 PyObject *resultobj = 0;
4731 int arg1 ;
4732 bool result;
4733 int val1 ;
4734 int ecode1 = 0 ;
4735 PyObject * obj0 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "id", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4741 ecode1 = SWIG_AsVal_int(obj0, &val1);
4742 if (!SWIG_IsOK(ecode1)) {
4743 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4744 }
4745 arg1 = static_cast< int >(val1);
4746 {
4747 PyThreadState* __tstate = wxPyBeginAllowThreads();
4748 result = (bool)wxIsStockID(arg1);
4749 wxPyEndAllowThreads(__tstate);
4750 if (PyErr_Occurred()) SWIG_fail;
4751 }
4752 {
4753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4754 }
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 int arg1 ;
4764 wxString *arg2 = 0 ;
4765 bool result;
4766 int val1 ;
4767 int ecode1 = 0 ;
4768 bool temp2 = false ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "id",(char *) "label", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4776 ecode1 = SWIG_AsVal_int(obj0, &val1);
4777 if (!SWIG_IsOK(ecode1)) {
4778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4779 }
4780 arg1 = static_cast< int >(val1);
4781 {
4782 arg2 = wxString_in_helper(obj1);
4783 if (arg2 == NULL) SWIG_fail;
4784 temp2 = true;
4785 }
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 {
4793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4794 }
4795 {
4796 if (temp2)
4797 delete arg2;
4798 }
4799 return resultobj;
4800 fail:
4801 {
4802 if (temp2)
4803 delete arg2;
4804 }
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 int arg1 ;
4812 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4813 wxString result;
4814 int val1 ;
4815 int ecode1 = 0 ;
4816 long val2 ;
4817 int ecode2 = 0 ;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char * kwnames[] = {
4821 (char *) "id",(char *) "flags", NULL
4822 };
4823
4824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4825 ecode1 = SWIG_AsVal_int(obj0, &val1);
4826 if (!SWIG_IsOK(ecode1)) {
4827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4828 }
4829 arg1 = static_cast< int >(val1);
4830 if (obj1) {
4831 ecode2 = SWIG_AsVal_long(obj1, &val2);
4832 if (!SWIG_IsOK(ecode2)) {
4833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4834 }
4835 arg2 = static_cast< long >(val2);
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 result = wxGetStockLabel(arg1,arg2);
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 {
4844 #if wxUSE_UNICODE
4845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4846 #else
4847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4848 #endif
4849 }
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj = 0;
4858 int arg1 ;
4859 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4860 wxString result;
4861 int val1 ;
4862 int ecode1 = 0 ;
4863 int val2 ;
4864 int ecode2 = 0 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 char * kwnames[] = {
4868 (char *) "id",(char *) "client", NULL
4869 };
4870
4871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4872 ecode1 = SWIG_AsVal_int(obj0, &val1);
4873 if (!SWIG_IsOK(ecode1)) {
4874 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4875 }
4876 arg1 = static_cast< int >(val1);
4877 if (obj1) {
4878 ecode2 = SWIG_AsVal_int(obj1, &val2);
4879 if (!SWIG_IsOK(ecode2)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4881 }
4882 arg2 = static_cast< wxStockHelpStringClient >(val2);
4883 }
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 result = wxGetStockHelpString(arg1,arg2);
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 {
4891 #if wxUSE_UNICODE
4892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4893 #else
4894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4895 #endif
4896 }
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4904 PyObject *resultobj = 0;
4905
4906 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4907 {
4908 if (!wxPyCheckForApp()) SWIG_fail;
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 wxBell();
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_Py_Void();
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4922 PyObject *resultobj = 0;
4923
4924 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4925 {
4926 if (!wxPyCheckForApp()) SWIG_fail;
4927 PyThreadState* __tstate = wxPyBeginAllowThreads();
4928 wxEndBusyCursor();
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 resultobj = SWIG_Py_Void();
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj = 0;
4941 bool arg1 = (bool) true ;
4942 long result;
4943 bool val1 ;
4944 int ecode1 = 0 ;
4945 PyObject * obj0 = 0 ;
4946 char * kwnames[] = {
4947 (char *) "resetTimer", NULL
4948 };
4949
4950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4951 if (obj0) {
4952 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4953 if (!SWIG_IsOK(ecode1)) {
4954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4955 }
4956 arg1 = static_cast< bool >(val1);
4957 }
4958 {
4959 PyThreadState* __tstate = wxPyBeginAllowThreads();
4960 result = (long)wxGetElapsedTime(arg1);
4961 wxPyEndAllowThreads(__tstate);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 resultobj = SWIG_From_long(static_cast< long >(result));
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4972 PyObject *resultobj = 0;
4973 bool result;
4974
4975 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (bool)wxIsBusy();
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4984 }
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4992 PyObject *resultobj = 0;
4993 wxString result;
4994
4995 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4996 {
4997 PyThreadState* __tstate = wxPyBeginAllowThreads();
4998 result = wxNow();
4999 wxPyEndAllowThreads(__tstate);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 {
5003 #if wxUSE_UNICODE
5004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5005 #else
5006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5007 #endif
5008 }
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5016 PyObject *resultobj = 0;
5017 wxString const &arg1_defvalue = wxPyEmptyString ;
5018 wxString *arg1 = (wxString *) &arg1_defvalue ;
5019 bool result;
5020 bool temp1 = false ;
5021 PyObject * obj0 = 0 ;
5022 char * kwnames[] = {
5023 (char *) "command", NULL
5024 };
5025
5026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5027 if (obj0) {
5028 {
5029 arg1 = wxString_in_helper(obj0);
5030 if (arg1 == NULL) SWIG_fail;
5031 temp1 = true;
5032 }
5033 }
5034 {
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (bool)wxShell((wxString const &)*arg1);
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 {
5041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5042 }
5043 {
5044 if (temp1)
5045 delete arg1;
5046 }
5047 return resultobj;
5048 fail:
5049 {
5050 if (temp1)
5051 delete arg1;
5052 }
5053 return NULL;
5054 }
5055
5056
5057 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5058 PyObject *resultobj = 0;
5059
5060 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5061 {
5062 PyThreadState* __tstate = wxPyBeginAllowThreads();
5063 wxStartTimer();
5064 wxPyEndAllowThreads(__tstate);
5065 if (PyErr_Occurred()) SWIG_fail;
5066 }
5067 resultobj = SWIG_Py_Void();
5068 return resultobj;
5069 fail:
5070 return NULL;
5071 }
5072
5073
5074 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5075 PyObject *resultobj = 0;
5076 int *arg1 = (int *) 0 ;
5077 int *arg2 = (int *) 0 ;
5078 int result;
5079 int temp1 ;
5080 int res1 = SWIG_TMPOBJ ;
5081 int temp2 ;
5082 int res2 = SWIG_TMPOBJ ;
5083
5084 arg1 = &temp1;
5085 arg2 = &temp2;
5086 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5087 {
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 result = (int)wxGetOsVersion(arg1,arg2);
5090 wxPyEndAllowThreads(__tstate);
5091 if (PyErr_Occurred()) SWIG_fail;
5092 }
5093 resultobj = SWIG_From_int(static_cast< int >(result));
5094 if (SWIG_IsTmpObj(res1)) {
5095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5096 } else {
5097 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5099 }
5100 if (SWIG_IsTmpObj(res2)) {
5101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5102 } else {
5103 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5105 }
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5113 PyObject *resultobj = 0;
5114 wxString result;
5115
5116 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5117 {
5118 PyThreadState* __tstate = wxPyBeginAllowThreads();
5119 result = wxGetOsDescription();
5120 wxPyEndAllowThreads(__tstate);
5121 if (PyErr_Occurred()) SWIG_fail;
5122 }
5123 {
5124 #if wxUSE_UNICODE
5125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5126 #else
5127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5128 #endif
5129 }
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 bool result;
5139
5140 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 result = (bool)wxIsPlatformLittleEndian();
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 {
5148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5149 }
5150 return resultobj;
5151 fail:
5152 return NULL;
5153 }
5154
5155
5156 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5157 PyObject *resultobj = 0;
5158 bool result;
5159
5160 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (bool)wxIsPlatform64Bit();
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5169 }
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxMemorySize result;
5179
5180 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = wxGetFreeMemory();
5184 wxPyEndAllowThreads(__tstate);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 {
5188 #if wxUSE_LONGLONG
5189 resultobj = PyLong_FromLongLong((&result)->GetValue());
5190 #else
5191 resultobj = PyInt_FromLong(result);
5192 #endif
5193 }
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj = 0;
5202 wxShutdownFlags arg1 ;
5203 bool result;
5204 int val1 ;
5205 int ecode1 = 0 ;
5206 PyObject * obj0 = 0 ;
5207 char * kwnames[] = {
5208 (char *) "wFlags", NULL
5209 };
5210
5211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5212 ecode1 = SWIG_AsVal_int(obj0, &val1);
5213 if (!SWIG_IsOK(ecode1)) {
5214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5215 }
5216 arg1 = static_cast< wxShutdownFlags >(val1);
5217 {
5218 if (!wxPyCheckForApp()) SWIG_fail;
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = (bool)wxShutdown(arg1);
5221 wxPyEndAllowThreads(__tstate);
5222 if (PyErr_Occurred()) SWIG_fail;
5223 }
5224 {
5225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5226 }
5227 return resultobj;
5228 fail:
5229 return NULL;
5230 }
5231
5232
5233 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5234 PyObject *resultobj = 0;
5235 int arg1 ;
5236 int val1 ;
5237 int ecode1 = 0 ;
5238 PyObject * obj0 = 0 ;
5239 char * kwnames[] = {
5240 (char *) "secs", NULL
5241 };
5242
5243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5244 ecode1 = SWIG_AsVal_int(obj0, &val1);
5245 if (!SWIG_IsOK(ecode1)) {
5246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5247 }
5248 arg1 = static_cast< int >(val1);
5249 {
5250 PyThreadState* __tstate = wxPyBeginAllowThreads();
5251 wxSleep(arg1);
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 resultobj = SWIG_Py_Void();
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj = 0;
5264 unsigned long arg1 ;
5265 unsigned long val1 ;
5266 int ecode1 = 0 ;
5267 PyObject * obj0 = 0 ;
5268 char * kwnames[] = {
5269 (char *) "milliseconds", NULL
5270 };
5271
5272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5273 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5274 if (!SWIG_IsOK(ecode1)) {
5275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5276 }
5277 arg1 = static_cast< unsigned long >(val1);
5278 {
5279 PyThreadState* __tstate = wxPyBeginAllowThreads();
5280 wxMilliSleep(arg1);
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 resultobj = SWIG_Py_Void();
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 unsigned long arg1 ;
5294 unsigned long val1 ;
5295 int ecode1 = 0 ;
5296 PyObject * obj0 = 0 ;
5297 char * kwnames[] = {
5298 (char *) "microseconds", NULL
5299 };
5300
5301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5302 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5303 if (!SWIG_IsOK(ecode1)) {
5304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5305 }
5306 arg1 = static_cast< unsigned long >(val1);
5307 {
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 wxMicroSleep(arg1);
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 resultobj = SWIG_Py_Void();
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5321 PyObject *resultobj = 0;
5322 bool arg1 ;
5323 bool val1 ;
5324 int ecode1 = 0 ;
5325 PyObject * obj0 = 0 ;
5326 char * kwnames[] = {
5327 (char *) "enable", NULL
5328 };
5329
5330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5331 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5332 if (!SWIG_IsOK(ecode1)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5334 }
5335 arg1 = static_cast< bool >(val1);
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 wxEnableTopLevelWindows(arg1);
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 resultobj = SWIG_Py_Void();
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5350 PyObject *resultobj = 0;
5351 wxString *arg1 = 0 ;
5352 wxString result;
5353 bool temp1 = false ;
5354 PyObject * obj0 = 0 ;
5355 char * kwnames[] = {
5356 (char *) "in", NULL
5357 };
5358
5359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5360 {
5361 arg1 = wxString_in_helper(obj0);
5362 if (arg1 == NULL) SWIG_fail;
5363 temp1 = true;
5364 }
5365 {
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 result = wxStripMenuCodes((wxString const &)*arg1);
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 #if wxUSE_UNICODE
5373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5374 #else
5375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5376 #endif
5377 }
5378 {
5379 if (temp1)
5380 delete arg1;
5381 }
5382 return resultobj;
5383 fail:
5384 {
5385 if (temp1)
5386 delete arg1;
5387 }
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 wxString result;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = wxGetEmailAddress();
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 {
5404 #if wxUSE_UNICODE
5405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5406 #else
5407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5408 #endif
5409 }
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxString result;
5419
5420 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = wxGetHostName();
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 #if wxUSE_UNICODE
5429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5430 #else
5431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5432 #endif
5433 }
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5441 PyObject *resultobj = 0;
5442 wxString result;
5443
5444 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 result = wxGetFullHostName();
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 {
5452 #if wxUSE_UNICODE
5453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5454 #else
5455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5456 #endif
5457 }
5458 return resultobj;
5459 fail:
5460 return NULL;
5461 }
5462
5463
5464 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5465 PyObject *resultobj = 0;
5466 wxString result;
5467
5468 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = wxGetUserId();
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 {
5476 #if wxUSE_UNICODE
5477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5478 #else
5479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5480 #endif
5481 }
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5489 PyObject *resultobj = 0;
5490 wxString result;
5491
5492 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = wxGetUserName();
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 {
5500 #if wxUSE_UNICODE
5501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5502 #else
5503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5504 #endif
5505 }
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5513 PyObject *resultobj = 0;
5514 wxString result;
5515
5516 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5517 {
5518 PyThreadState* __tstate = wxPyBeginAllowThreads();
5519 result = wxGetHomeDir();
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 #if wxUSE_UNICODE
5525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5526 #else
5527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5528 #endif
5529 }
5530 return resultobj;
5531 fail:
5532 return NULL;
5533 }
5534
5535
5536 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5537 PyObject *resultobj = 0;
5538 wxString const &arg1_defvalue = wxPyEmptyString ;
5539 wxString *arg1 = (wxString *) &arg1_defvalue ;
5540 wxString result;
5541 bool temp1 = false ;
5542 PyObject * obj0 = 0 ;
5543 char * kwnames[] = {
5544 (char *) "user", NULL
5545 };
5546
5547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5548 if (obj0) {
5549 {
5550 arg1 = wxString_in_helper(obj0);
5551 if (arg1 == NULL) SWIG_fail;
5552 temp1 = true;
5553 }
5554 }
5555 {
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 result = wxGetUserHome((wxString const &)*arg1);
5558 wxPyEndAllowThreads(__tstate);
5559 if (PyErr_Occurred()) SWIG_fail;
5560 }
5561 {
5562 #if wxUSE_UNICODE
5563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5564 #else
5565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5566 #endif
5567 }
5568 {
5569 if (temp1)
5570 delete arg1;
5571 }
5572 return resultobj;
5573 fail:
5574 {
5575 if (temp1)
5576 delete arg1;
5577 }
5578 return NULL;
5579 }
5580
5581
5582 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5583 PyObject *resultobj = 0;
5584 unsigned long result;
5585
5586 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5587 {
5588 PyThreadState* __tstate = wxPyBeginAllowThreads();
5589 result = (unsigned long)wxGetProcessId();
5590 wxPyEndAllowThreads(__tstate);
5591 if (PyErr_Occurred()) SWIG_fail;
5592 }
5593 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 PyObject *resultobj = 0;
5602
5603 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5604 {
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 wxTrap();
5607 wxPyEndAllowThreads(__tstate);
5608 if (PyErr_Occurred()) SWIG_fail;
5609 }
5610 resultobj = SWIG_Py_Void();
5611 return resultobj;
5612 fail:
5613 return NULL;
5614 }
5615
5616
5617 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5618 PyObject *resultobj = 0;
5619 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5620 wxString *arg1 = (wxString *) &arg1_defvalue ;
5621 wxString const &arg2_defvalue = wxPyEmptyString ;
5622 wxString *arg2 = (wxString *) &arg2_defvalue ;
5623 wxString const &arg3_defvalue = wxPyEmptyString ;
5624 wxString *arg3 = (wxString *) &arg3_defvalue ;
5625 wxString const &arg4_defvalue = wxPyEmptyString ;
5626 wxString *arg4 = (wxString *) &arg4_defvalue ;
5627 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5628 wxString *arg5 = (wxString *) &arg5_defvalue ;
5629 int arg6 = (int) 0 ;
5630 wxWindow *arg7 = (wxWindow *) NULL ;
5631 int arg8 = (int) -1 ;
5632 int arg9 = (int) -1 ;
5633 wxString result;
5634 bool temp1 = false ;
5635 bool temp2 = false ;
5636 bool temp3 = false ;
5637 bool temp4 = false ;
5638 bool temp5 = false ;
5639 int val6 ;
5640 int ecode6 = 0 ;
5641 void *argp7 = 0 ;
5642 int res7 = 0 ;
5643 int val8 ;
5644 int ecode8 = 0 ;
5645 int val9 ;
5646 int ecode9 = 0 ;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 PyObject * obj2 = 0 ;
5650 PyObject * obj3 = 0 ;
5651 PyObject * obj4 = 0 ;
5652 PyObject * obj5 = 0 ;
5653 PyObject * obj6 = 0 ;
5654 PyObject * obj7 = 0 ;
5655 PyObject * obj8 = 0 ;
5656 char * kwnames[] = {
5657 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5658 };
5659
5660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5661 if (obj0) {
5662 {
5663 arg1 = wxString_in_helper(obj0);
5664 if (arg1 == NULL) SWIG_fail;
5665 temp1 = true;
5666 }
5667 }
5668 if (obj1) {
5669 {
5670 arg2 = wxString_in_helper(obj1);
5671 if (arg2 == NULL) SWIG_fail;
5672 temp2 = true;
5673 }
5674 }
5675 if (obj2) {
5676 {
5677 arg3 = wxString_in_helper(obj2);
5678 if (arg3 == NULL) SWIG_fail;
5679 temp3 = true;
5680 }
5681 }
5682 if (obj3) {
5683 {
5684 arg4 = wxString_in_helper(obj3);
5685 if (arg4 == NULL) SWIG_fail;
5686 temp4 = true;
5687 }
5688 }
5689 if (obj4) {
5690 {
5691 arg5 = wxString_in_helper(obj4);
5692 if (arg5 == NULL) SWIG_fail;
5693 temp5 = true;
5694 }
5695 }
5696 if (obj5) {
5697 ecode6 = SWIG_AsVal_int(obj5, &val6);
5698 if (!SWIG_IsOK(ecode6)) {
5699 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5700 }
5701 arg6 = static_cast< int >(val6);
5702 }
5703 if (obj6) {
5704 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5705 if (!SWIG_IsOK(res7)) {
5706 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5707 }
5708 arg7 = reinterpret_cast< wxWindow * >(argp7);
5709 }
5710 if (obj7) {
5711 ecode8 = SWIG_AsVal_int(obj7, &val8);
5712 if (!SWIG_IsOK(ecode8)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5714 }
5715 arg8 = static_cast< int >(val8);
5716 }
5717 if (obj8) {
5718 ecode9 = SWIG_AsVal_int(obj8, &val9);
5719 if (!SWIG_IsOK(ecode9)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5721 }
5722 arg9 = static_cast< int >(val9);
5723 }
5724 {
5725 if (!wxPyCheckForApp()) SWIG_fail;
5726 PyThreadState* __tstate = wxPyBeginAllowThreads();
5727 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5728 wxPyEndAllowThreads(__tstate);
5729 if (PyErr_Occurred()) SWIG_fail;
5730 }
5731 {
5732 #if wxUSE_UNICODE
5733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5734 #else
5735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5736 #endif
5737 }
5738 {
5739 if (temp1)
5740 delete arg1;
5741 }
5742 {
5743 if (temp2)
5744 delete arg2;
5745 }
5746 {
5747 if (temp3)
5748 delete arg3;
5749 }
5750 {
5751 if (temp4)
5752 delete arg4;
5753 }
5754 {
5755 if (temp5)
5756 delete arg5;
5757 }
5758 return resultobj;
5759 fail:
5760 {
5761 if (temp1)
5762 delete arg1;
5763 }
5764 {
5765 if (temp2)
5766 delete arg2;
5767 }
5768 {
5769 if (temp3)
5770 delete arg3;
5771 }
5772 {
5773 if (temp4)
5774 delete arg4;
5775 }
5776 {
5777 if (temp5)
5778 delete arg5;
5779 }
5780 return NULL;
5781 }
5782
5783
5784 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj = 0;
5786 wxString *arg1 = 0 ;
5787 wxString *arg2 = 0 ;
5788 wxString const &arg3_defvalue = wxPyEmptyString ;
5789 wxString *arg3 = (wxString *) &arg3_defvalue ;
5790 wxWindow *arg4 = (wxWindow *) NULL ;
5791 wxString result;
5792 bool temp1 = false ;
5793 bool temp2 = false ;
5794 bool temp3 = false ;
5795 void *argp4 = 0 ;
5796 int res4 = 0 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 PyObject * obj2 = 0 ;
5800 PyObject * obj3 = 0 ;
5801 char * kwnames[] = {
5802 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5803 };
5804
5805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5806 {
5807 arg1 = wxString_in_helper(obj0);
5808 if (arg1 == NULL) SWIG_fail;
5809 temp1 = true;
5810 }
5811 {
5812 arg2 = wxString_in_helper(obj1);
5813 if (arg2 == NULL) SWIG_fail;
5814 temp2 = true;
5815 }
5816 if (obj2) {
5817 {
5818 arg3 = wxString_in_helper(obj2);
5819 if (arg3 == NULL) SWIG_fail;
5820 temp3 = true;
5821 }
5822 }
5823 if (obj3) {
5824 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5825 if (!SWIG_IsOK(res4)) {
5826 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5827 }
5828 arg4 = reinterpret_cast< wxWindow * >(argp4);
5829 }
5830 {
5831 if (!wxPyCheckForApp()) SWIG_fail;
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 #if wxUSE_UNICODE
5839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5840 #else
5841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5842 #endif
5843 }
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 resultobj;
5857 fail:
5858 {
5859 if (temp1)
5860 delete arg1;
5861 }
5862 {
5863 if (temp2)
5864 delete arg2;
5865 }
5866 {
5867 if (temp3)
5868 delete arg3;
5869 }
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj = 0;
5876 wxString *arg1 = 0 ;
5877 wxString *arg2 = 0 ;
5878 wxString const &arg3_defvalue = wxPyEmptyString ;
5879 wxString *arg3 = (wxString *) &arg3_defvalue ;
5880 wxWindow *arg4 = (wxWindow *) NULL ;
5881 wxString result;
5882 bool temp1 = false ;
5883 bool temp2 = false ;
5884 bool temp3 = false ;
5885 void *argp4 = 0 ;
5886 int res4 = 0 ;
5887 PyObject * obj0 = 0 ;
5888 PyObject * obj1 = 0 ;
5889 PyObject * obj2 = 0 ;
5890 PyObject * obj3 = 0 ;
5891 char * kwnames[] = {
5892 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5893 };
5894
5895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5896 {
5897 arg1 = wxString_in_helper(obj0);
5898 if (arg1 == NULL) SWIG_fail;
5899 temp1 = true;
5900 }
5901 {
5902 arg2 = wxString_in_helper(obj1);
5903 if (arg2 == NULL) SWIG_fail;
5904 temp2 = true;
5905 }
5906 if (obj2) {
5907 {
5908 arg3 = wxString_in_helper(obj2);
5909 if (arg3 == NULL) SWIG_fail;
5910 temp3 = true;
5911 }
5912 }
5913 if (obj3) {
5914 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5915 if (!SWIG_IsOK(res4)) {
5916 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5917 }
5918 arg4 = reinterpret_cast< wxWindow * >(argp4);
5919 }
5920 {
5921 if (!wxPyCheckForApp()) SWIG_fail;
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5924 wxPyEndAllowThreads(__tstate);
5925 if (PyErr_Occurred()) SWIG_fail;
5926 }
5927 {
5928 #if wxUSE_UNICODE
5929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5930 #else
5931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5932 #endif
5933 }
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 resultobj;
5947 fail:
5948 {
5949 if (temp1)
5950 delete arg1;
5951 }
5952 {
5953 if (temp2)
5954 delete arg2;
5955 }
5956 {
5957 if (temp3)
5958 delete arg3;
5959 }
5960 return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = 0;
5966 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5967 wxString *arg1 = (wxString *) &arg1_defvalue ;
5968 wxString const &arg2_defvalue = wxPyEmptyString ;
5969 wxString *arg2 = (wxString *) &arg2_defvalue ;
5970 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5971 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5972 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5973 wxWindow *arg5 = (wxWindow *) NULL ;
5974 wxString result;
5975 bool temp1 = false ;
5976 bool temp2 = false ;
5977 long val3 ;
5978 int ecode3 = 0 ;
5979 wxPoint temp4 ;
5980 void *argp5 = 0 ;
5981 int res5 = 0 ;
5982 PyObject * obj0 = 0 ;
5983 PyObject * obj1 = 0 ;
5984 PyObject * obj2 = 0 ;
5985 PyObject * obj3 = 0 ;
5986 PyObject * obj4 = 0 ;
5987 char * kwnames[] = {
5988 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5989 };
5990
5991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5992 if (obj0) {
5993 {
5994 arg1 = wxString_in_helper(obj0);
5995 if (arg1 == NULL) SWIG_fail;
5996 temp1 = true;
5997 }
5998 }
5999 if (obj1) {
6000 {
6001 arg2 = wxString_in_helper(obj1);
6002 if (arg2 == NULL) SWIG_fail;
6003 temp2 = true;
6004 }
6005 }
6006 if (obj2) {
6007 ecode3 = SWIG_AsVal_long(obj2, &val3);
6008 if (!SWIG_IsOK(ecode3)) {
6009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6010 }
6011 arg3 = static_cast< long >(val3);
6012 }
6013 if (obj3) {
6014 {
6015 arg4 = &temp4;
6016 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6017 }
6018 }
6019 if (obj4) {
6020 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6021 if (!SWIG_IsOK(res5)) {
6022 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6023 }
6024 arg5 = reinterpret_cast< wxWindow * >(argp5);
6025 }
6026 {
6027 if (!wxPyCheckForApp()) SWIG_fail;
6028 PyThreadState* __tstate = wxPyBeginAllowThreads();
6029 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 #if wxUSE_UNICODE
6035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6036 #else
6037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6038 #endif
6039 }
6040 {
6041 if (temp1)
6042 delete arg1;
6043 }
6044 {
6045 if (temp2)
6046 delete arg2;
6047 }
6048 return resultobj;
6049 fail:
6050 {
6051 if (temp1)
6052 delete arg1;
6053 }
6054 {
6055 if (temp2)
6056 delete arg2;
6057 }
6058 return NULL;
6059 }
6060
6061
6062 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6063 PyObject *resultobj = 0;
6064 wxString *arg1 = 0 ;
6065 wxString const &arg2_defvalue = wxPyEmptyString ;
6066 wxString *arg2 = (wxString *) &arg2_defvalue ;
6067 wxString const &arg3_defvalue = wxPyEmptyString ;
6068 wxString *arg3 = (wxString *) &arg3_defvalue ;
6069 wxWindow *arg4 = (wxWindow *) NULL ;
6070 int arg5 = (int) -1 ;
6071 int arg6 = (int) -1 ;
6072 bool arg7 = (bool) true ;
6073 wxString result;
6074 bool temp1 = false ;
6075 bool temp2 = false ;
6076 bool temp3 = false ;
6077 void *argp4 = 0 ;
6078 int res4 = 0 ;
6079 int val5 ;
6080 int ecode5 = 0 ;
6081 int val6 ;
6082 int ecode6 = 0 ;
6083 bool val7 ;
6084 int ecode7 = 0 ;
6085 PyObject * obj0 = 0 ;
6086 PyObject * obj1 = 0 ;
6087 PyObject * obj2 = 0 ;
6088 PyObject * obj3 = 0 ;
6089 PyObject * obj4 = 0 ;
6090 PyObject * obj5 = 0 ;
6091 PyObject * obj6 = 0 ;
6092 char * kwnames[] = {
6093 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6094 };
6095
6096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6097 {
6098 arg1 = wxString_in_helper(obj0);
6099 if (arg1 == NULL) SWIG_fail;
6100 temp1 = true;
6101 }
6102 if (obj1) {
6103 {
6104 arg2 = wxString_in_helper(obj1);
6105 if (arg2 == NULL) SWIG_fail;
6106 temp2 = true;
6107 }
6108 }
6109 if (obj2) {
6110 {
6111 arg3 = wxString_in_helper(obj2);
6112 if (arg3 == NULL) SWIG_fail;
6113 temp3 = true;
6114 }
6115 }
6116 if (obj3) {
6117 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6118 if (!SWIG_IsOK(res4)) {
6119 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6120 }
6121 arg4 = reinterpret_cast< wxWindow * >(argp4);
6122 }
6123 if (obj4) {
6124 ecode5 = SWIG_AsVal_int(obj4, &val5);
6125 if (!SWIG_IsOK(ecode5)) {
6126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6127 }
6128 arg5 = static_cast< int >(val5);
6129 }
6130 if (obj5) {
6131 ecode6 = SWIG_AsVal_int(obj5, &val6);
6132 if (!SWIG_IsOK(ecode6)) {
6133 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6134 }
6135 arg6 = static_cast< int >(val6);
6136 }
6137 if (obj6) {
6138 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6139 if (!SWIG_IsOK(ecode7)) {
6140 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6141 }
6142 arg7 = static_cast< bool >(val7);
6143 }
6144 {
6145 if (!wxPyCheckForApp()) SWIG_fail;
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 {
6152 #if wxUSE_UNICODE
6153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6154 #else
6155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6156 #endif
6157 }
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 resultobj;
6171 fail:
6172 {
6173 if (temp1)
6174 delete arg1;
6175 }
6176 {
6177 if (temp2)
6178 delete arg2;
6179 }
6180 {
6181 if (temp3)
6182 delete arg3;
6183 }
6184 return NULL;
6185 }
6186
6187
6188 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6189 PyObject *resultobj = 0;
6190 wxString *arg1 = 0 ;
6191 wxString const &arg2_defvalue = wxPyEmptyString ;
6192 wxString *arg2 = (wxString *) &arg2_defvalue ;
6193 wxString const &arg3_defvalue = wxPyEmptyString ;
6194 wxString *arg3 = (wxString *) &arg3_defvalue ;
6195 wxWindow *arg4 = (wxWindow *) NULL ;
6196 wxString result;
6197 bool temp1 = false ;
6198 bool temp2 = false ;
6199 bool temp3 = false ;
6200 void *argp4 = 0 ;
6201 int res4 = 0 ;
6202 PyObject * obj0 = 0 ;
6203 PyObject * obj1 = 0 ;
6204 PyObject * obj2 = 0 ;
6205 PyObject * obj3 = 0 ;
6206 char * kwnames[] = {
6207 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6208 };
6209
6210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6211 {
6212 arg1 = wxString_in_helper(obj0);
6213 if (arg1 == NULL) SWIG_fail;
6214 temp1 = true;
6215 }
6216 if (obj1) {
6217 {
6218 arg2 = wxString_in_helper(obj1);
6219 if (arg2 == NULL) SWIG_fail;
6220 temp2 = true;
6221 }
6222 }
6223 if (obj2) {
6224 {
6225 arg3 = wxString_in_helper(obj2);
6226 if (arg3 == NULL) SWIG_fail;
6227 temp3 = true;
6228 }
6229 }
6230 if (obj3) {
6231 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6232 if (!SWIG_IsOK(res4)) {
6233 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6234 }
6235 arg4 = reinterpret_cast< wxWindow * >(argp4);
6236 }
6237 {
6238 if (!wxPyCheckForApp()) SWIG_fail;
6239 PyThreadState* __tstate = wxPyBeginAllowThreads();
6240 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6241 wxPyEndAllowThreads(__tstate);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 {
6245 #if wxUSE_UNICODE
6246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6247 #else
6248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6249 #endif
6250 }
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 resultobj;
6264 fail:
6265 {
6266 if (temp1)
6267 delete arg1;
6268 }
6269 {
6270 if (temp2)
6271 delete arg2;
6272 }
6273 {
6274 if (temp3)
6275 delete arg3;
6276 }
6277 return NULL;
6278 }
6279
6280
6281 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj = 0;
6283 wxString *arg1 = 0 ;
6284 wxString *arg2 = 0 ;
6285 int arg3 ;
6286 wxString *arg4 = (wxString *) 0 ;
6287 wxWindow *arg5 = (wxWindow *) NULL ;
6288 int arg6 = (int) -1 ;
6289 int arg7 = (int) -1 ;
6290 bool arg8 = (bool) true ;
6291 int arg9 = (int) 150 ;
6292 int arg10 = (int) 200 ;
6293 wxString result;
6294 bool temp1 = false ;
6295 bool temp2 = false ;
6296 void *argp5 = 0 ;
6297 int res5 = 0 ;
6298 int val6 ;
6299 int ecode6 = 0 ;
6300 int val7 ;
6301 int ecode7 = 0 ;
6302 bool val8 ;
6303 int ecode8 = 0 ;
6304 int val9 ;
6305 int ecode9 = 0 ;
6306 int val10 ;
6307 int ecode10 = 0 ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6310 PyObject * obj2 = 0 ;
6311 PyObject * obj3 = 0 ;
6312 PyObject * obj4 = 0 ;
6313 PyObject * obj5 = 0 ;
6314 PyObject * obj6 = 0 ;
6315 PyObject * obj7 = 0 ;
6316 PyObject * obj8 = 0 ;
6317 char * kwnames[] = {
6318 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6319 };
6320
6321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6322 {
6323 arg1 = wxString_in_helper(obj0);
6324 if (arg1 == NULL) SWIG_fail;
6325 temp1 = true;
6326 }
6327 {
6328 arg2 = wxString_in_helper(obj1);
6329 if (arg2 == NULL) SWIG_fail;
6330 temp2 = true;
6331 }
6332 {
6333 arg3 = PyList_Size(obj2);
6334 arg4 = wxString_LIST_helper(obj2);
6335 if (arg4 == NULL) SWIG_fail;
6336 }
6337 if (obj3) {
6338 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6339 if (!SWIG_IsOK(res5)) {
6340 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6341 }
6342 arg5 = reinterpret_cast< wxWindow * >(argp5);
6343 }
6344 if (obj4) {
6345 ecode6 = SWIG_AsVal_int(obj4, &val6);
6346 if (!SWIG_IsOK(ecode6)) {
6347 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6348 }
6349 arg6 = static_cast< int >(val6);
6350 }
6351 if (obj5) {
6352 ecode7 = SWIG_AsVal_int(obj5, &val7);
6353 if (!SWIG_IsOK(ecode7)) {
6354 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6355 }
6356 arg7 = static_cast< int >(val7);
6357 }
6358 if (obj6) {
6359 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6360 if (!SWIG_IsOK(ecode8)) {
6361 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6362 }
6363 arg8 = static_cast< bool >(val8);
6364 }
6365 if (obj7) {
6366 ecode9 = SWIG_AsVal_int(obj7, &val9);
6367 if (!SWIG_IsOK(ecode9)) {
6368 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6369 }
6370 arg9 = static_cast< int >(val9);
6371 }
6372 if (obj8) {
6373 ecode10 = SWIG_AsVal_int(obj8, &val10);
6374 if (!SWIG_IsOK(ecode10)) {
6375 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6376 }
6377 arg10 = static_cast< int >(val10);
6378 }
6379 {
6380 if (!wxPyCheckForApp()) SWIG_fail;
6381 PyThreadState* __tstate = wxPyBeginAllowThreads();
6382 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6383 wxPyEndAllowThreads(__tstate);
6384 if (PyErr_Occurred()) SWIG_fail;
6385 }
6386 {
6387 #if wxUSE_UNICODE
6388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6389 #else
6390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6391 #endif
6392 }
6393 {
6394 if (temp1)
6395 delete arg1;
6396 }
6397 {
6398 if (temp2)
6399 delete arg2;
6400 }
6401 {
6402 if (arg4) delete [] arg4;
6403 }
6404 return resultobj;
6405 fail:
6406 {
6407 if (temp1)
6408 delete arg1;
6409 }
6410 {
6411 if (temp2)
6412 delete arg2;
6413 }
6414 {
6415 if (arg4) delete [] arg4;
6416 }
6417 return NULL;
6418 }
6419
6420
6421 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj = 0;
6423 wxString *arg1 = 0 ;
6424 wxString *arg2 = 0 ;
6425 int arg3 ;
6426 wxString *arg4 = (wxString *) 0 ;
6427 wxWindow *arg5 = (wxWindow *) NULL ;
6428 int arg6 = (int) -1 ;
6429 int arg7 = (int) -1 ;
6430 bool arg8 = (bool) true ;
6431 int arg9 = (int) 150 ;
6432 int arg10 = (int) 200 ;
6433 int result;
6434 bool temp1 = false ;
6435 bool temp2 = false ;
6436 void *argp5 = 0 ;
6437 int res5 = 0 ;
6438 int val6 ;
6439 int ecode6 = 0 ;
6440 int val7 ;
6441 int ecode7 = 0 ;
6442 bool val8 ;
6443 int ecode8 = 0 ;
6444 int val9 ;
6445 int ecode9 = 0 ;
6446 int val10 ;
6447 int ecode10 = 0 ;
6448 PyObject * obj0 = 0 ;
6449 PyObject * obj1 = 0 ;
6450 PyObject * obj2 = 0 ;
6451 PyObject * obj3 = 0 ;
6452 PyObject * obj4 = 0 ;
6453 PyObject * obj5 = 0 ;
6454 PyObject * obj6 = 0 ;
6455 PyObject * obj7 = 0 ;
6456 PyObject * obj8 = 0 ;
6457 char * kwnames[] = {
6458 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6459 };
6460
6461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6462 {
6463 arg1 = wxString_in_helper(obj0);
6464 if (arg1 == NULL) SWIG_fail;
6465 temp1 = true;
6466 }
6467 {
6468 arg2 = wxString_in_helper(obj1);
6469 if (arg2 == NULL) SWIG_fail;
6470 temp2 = true;
6471 }
6472 {
6473 arg3 = PyList_Size(obj2);
6474 arg4 = wxString_LIST_helper(obj2);
6475 if (arg4 == NULL) SWIG_fail;
6476 }
6477 if (obj3) {
6478 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6479 if (!SWIG_IsOK(res5)) {
6480 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6481 }
6482 arg5 = reinterpret_cast< wxWindow * >(argp5);
6483 }
6484 if (obj4) {
6485 ecode6 = SWIG_AsVal_int(obj4, &val6);
6486 if (!SWIG_IsOK(ecode6)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6488 }
6489 arg6 = static_cast< int >(val6);
6490 }
6491 if (obj5) {
6492 ecode7 = SWIG_AsVal_int(obj5, &val7);
6493 if (!SWIG_IsOK(ecode7)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6495 }
6496 arg7 = static_cast< int >(val7);
6497 }
6498 if (obj6) {
6499 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6500 if (!SWIG_IsOK(ecode8)) {
6501 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6502 }
6503 arg8 = static_cast< bool >(val8);
6504 }
6505 if (obj7) {
6506 ecode9 = SWIG_AsVal_int(obj7, &val9);
6507 if (!SWIG_IsOK(ecode9)) {
6508 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6509 }
6510 arg9 = static_cast< int >(val9);
6511 }
6512 if (obj8) {
6513 ecode10 = SWIG_AsVal_int(obj8, &val10);
6514 if (!SWIG_IsOK(ecode10)) {
6515 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6516 }
6517 arg10 = static_cast< int >(val10);
6518 }
6519 {
6520 if (!wxPyCheckForApp()) SWIG_fail;
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_From_int(static_cast< int >(result));
6527 {
6528 if (temp1)
6529 delete arg1;
6530 }
6531 {
6532 if (temp2)
6533 delete arg2;
6534 }
6535 {
6536 if (arg4) delete [] arg4;
6537 }
6538 return resultobj;
6539 fail:
6540 {
6541 if (temp1)
6542 delete arg1;
6543 }
6544 {
6545 if (temp2)
6546 delete arg2;
6547 }
6548 {
6549 if (arg4) delete [] arg4;
6550 }
6551 return NULL;
6552 }
6553
6554
6555 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj = 0;
6557 wxString *arg1 = 0 ;
6558 wxString const &arg2_defvalue = wxPyEmptyString ;
6559 wxString *arg2 = (wxString *) &arg2_defvalue ;
6560 int arg3 = (int) wxOK|wxCENTRE ;
6561 wxWindow *arg4 = (wxWindow *) NULL ;
6562 int arg5 = (int) -1 ;
6563 int arg6 = (int) -1 ;
6564 int result;
6565 bool temp1 = false ;
6566 bool temp2 = false ;
6567 int val3 ;
6568 int ecode3 = 0 ;
6569 void *argp4 = 0 ;
6570 int res4 = 0 ;
6571 int val5 ;
6572 int ecode5 = 0 ;
6573 int val6 ;
6574 int ecode6 = 0 ;
6575 PyObject * obj0 = 0 ;
6576 PyObject * obj1 = 0 ;
6577 PyObject * obj2 = 0 ;
6578 PyObject * obj3 = 0 ;
6579 PyObject * obj4 = 0 ;
6580 PyObject * obj5 = 0 ;
6581 char * kwnames[] = {
6582 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6583 };
6584
6585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6586 {
6587 arg1 = wxString_in_helper(obj0);
6588 if (arg1 == NULL) SWIG_fail;
6589 temp1 = true;
6590 }
6591 if (obj1) {
6592 {
6593 arg2 = wxString_in_helper(obj1);
6594 if (arg2 == NULL) SWIG_fail;
6595 temp2 = true;
6596 }
6597 }
6598 if (obj2) {
6599 ecode3 = SWIG_AsVal_int(obj2, &val3);
6600 if (!SWIG_IsOK(ecode3)) {
6601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6602 }
6603 arg3 = static_cast< int >(val3);
6604 }
6605 if (obj3) {
6606 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6607 if (!SWIG_IsOK(res4)) {
6608 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6609 }
6610 arg4 = reinterpret_cast< wxWindow * >(argp4);
6611 }
6612 if (obj4) {
6613 ecode5 = SWIG_AsVal_int(obj4, &val5);
6614 if (!SWIG_IsOK(ecode5)) {
6615 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6616 }
6617 arg5 = static_cast< int >(val5);
6618 }
6619 if (obj5) {
6620 ecode6 = SWIG_AsVal_int(obj5, &val6);
6621 if (!SWIG_IsOK(ecode6)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6623 }
6624 arg6 = static_cast< int >(val6);
6625 }
6626 {
6627 if (!wxPyCheckForApp()) SWIG_fail;
6628 PyThreadState* __tstate = wxPyBeginAllowThreads();
6629 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6630 wxPyEndAllowThreads(__tstate);
6631 if (PyErr_Occurred()) SWIG_fail;
6632 }
6633 resultobj = SWIG_From_int(static_cast< int >(result));
6634 {
6635 if (temp1)
6636 delete arg1;
6637 }
6638 {
6639 if (temp2)
6640 delete arg2;
6641 }
6642 return resultobj;
6643 fail:
6644 {
6645 if (temp1)
6646 delete arg1;
6647 }
6648 {
6649 if (temp2)
6650 delete arg2;
6651 }
6652 return NULL;
6653 }
6654
6655
6656 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj = 0;
6658 wxString *arg1 = 0 ;
6659 wxString *arg2 = 0 ;
6660 wxString *arg3 = 0 ;
6661 long arg4 ;
6662 long arg5 = (long) 0 ;
6663 long arg6 = (long) 100 ;
6664 wxWindow *arg7 = (wxWindow *) NULL ;
6665 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6666 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6667 long result;
6668 bool temp1 = false ;
6669 bool temp2 = false ;
6670 bool temp3 = false ;
6671 long val4 ;
6672 int ecode4 = 0 ;
6673 long val5 ;
6674 int ecode5 = 0 ;
6675 long val6 ;
6676 int ecode6 = 0 ;
6677 void *argp7 = 0 ;
6678 int res7 = 0 ;
6679 wxPoint temp8 ;
6680 PyObject * obj0 = 0 ;
6681 PyObject * obj1 = 0 ;
6682 PyObject * obj2 = 0 ;
6683 PyObject * obj3 = 0 ;
6684 PyObject * obj4 = 0 ;
6685 PyObject * obj5 = 0 ;
6686 PyObject * obj6 = 0 ;
6687 PyObject * obj7 = 0 ;
6688 char * kwnames[] = {
6689 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6690 };
6691
6692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6693 {
6694 arg1 = wxString_in_helper(obj0);
6695 if (arg1 == NULL) SWIG_fail;
6696 temp1 = true;
6697 }
6698 {
6699 arg2 = wxString_in_helper(obj1);
6700 if (arg2 == NULL) SWIG_fail;
6701 temp2 = true;
6702 }
6703 {
6704 arg3 = wxString_in_helper(obj2);
6705 if (arg3 == NULL) SWIG_fail;
6706 temp3 = true;
6707 }
6708 ecode4 = SWIG_AsVal_long(obj3, &val4);
6709 if (!SWIG_IsOK(ecode4)) {
6710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6711 }
6712 arg4 = static_cast< long >(val4);
6713 if (obj4) {
6714 ecode5 = SWIG_AsVal_long(obj4, &val5);
6715 if (!SWIG_IsOK(ecode5)) {
6716 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6717 }
6718 arg5 = static_cast< long >(val5);
6719 }
6720 if (obj5) {
6721 ecode6 = SWIG_AsVal_long(obj5, &val6);
6722 if (!SWIG_IsOK(ecode6)) {
6723 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6724 }
6725 arg6 = static_cast< long >(val6);
6726 }
6727 if (obj6) {
6728 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6729 if (!SWIG_IsOK(res7)) {
6730 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6731 }
6732 arg7 = reinterpret_cast< wxWindow * >(argp7);
6733 }
6734 if (obj7) {
6735 {
6736 arg8 = &temp8;
6737 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6738 }
6739 }
6740 {
6741 if (!wxPyCheckForApp()) SWIG_fail;
6742 PyThreadState* __tstate = wxPyBeginAllowThreads();
6743 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 resultobj = SWIG_From_long(static_cast< long >(result));
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 resultobj;
6761 fail:
6762 {
6763 if (temp1)
6764 delete arg1;
6765 }
6766 {
6767 if (temp2)
6768 delete arg2;
6769 }
6770 {
6771 if (temp3)
6772 delete arg3;
6773 }
6774 return NULL;
6775 }
6776
6777
6778 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6779 PyObject *resultobj = 0;
6780 bool result;
6781
6782 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6783 {
6784 if (!wxPyCheckForApp()) SWIG_fail;
6785 PyThreadState* __tstate = wxPyBeginAllowThreads();
6786 result = (bool)wxColourDisplay();
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 {
6791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6792 }
6793 return resultobj;
6794 fail:
6795 return NULL;
6796 }
6797
6798
6799 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6800 PyObject *resultobj = 0;
6801 int result;
6802
6803 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6804 {
6805 if (!wxPyCheckForApp()) SWIG_fail;
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 result = (int)wxDisplayDepth();
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 resultobj = SWIG_From_int(static_cast< int >(result));
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6819 PyObject *resultobj = 0;
6820 int result;
6821
6822 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6823 {
6824 if (!wxPyCheckForApp()) SWIG_fail;
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (int)wxGetDisplayDepth();
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_From_int(static_cast< int >(result));
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 int *arg1 = (int *) 0 ;
6840 int *arg2 = (int *) 0 ;
6841 int temp1 ;
6842 int res1 = SWIG_TMPOBJ ;
6843 int temp2 ;
6844 int res2 = SWIG_TMPOBJ ;
6845
6846 arg1 = &temp1;
6847 arg2 = &temp2;
6848 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6849 {
6850 if (!wxPyCheckForApp()) SWIG_fail;
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 wxDisplaySize(arg1,arg2);
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_Py_Void();
6857 if (SWIG_IsTmpObj(res1)) {
6858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6859 } else {
6860 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6862 }
6863 if (SWIG_IsTmpObj(res2)) {
6864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6865 } else {
6866 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6868 }
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6876 PyObject *resultobj = 0;
6877 wxSize result;
6878
6879 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6880 {
6881 if (!wxPyCheckForApp()) SWIG_fail;
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 result = wxGetDisplaySize();
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6895 PyObject *resultobj = 0;
6896 int *arg1 = (int *) 0 ;
6897 int *arg2 = (int *) 0 ;
6898 int temp1 ;
6899 int res1 = SWIG_TMPOBJ ;
6900 int temp2 ;
6901 int res2 = SWIG_TMPOBJ ;
6902
6903 arg1 = &temp1;
6904 arg2 = &temp2;
6905 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6906 {
6907 if (!wxPyCheckForApp()) SWIG_fail;
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 wxDisplaySizeMM(arg1,arg2);
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_Py_Void();
6914 if (SWIG_IsTmpObj(res1)) {
6915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6916 } else {
6917 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6919 }
6920 if (SWIG_IsTmpObj(res2)) {
6921 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6922 } else {
6923 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6925 }
6926 return resultobj;
6927 fail:
6928 return NULL;
6929 }
6930
6931
6932 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6933 PyObject *resultobj = 0;
6934 wxSize result;
6935
6936 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6937 {
6938 if (!wxPyCheckForApp()) SWIG_fail;
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 result = wxGetDisplaySizeMM();
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6952 PyObject *resultobj = 0;
6953 int *arg1 = (int *) 0 ;
6954 int *arg2 = (int *) 0 ;
6955 int *arg3 = (int *) 0 ;
6956 int *arg4 = (int *) 0 ;
6957 int temp1 ;
6958 int res1 = SWIG_TMPOBJ ;
6959 int temp2 ;
6960 int res2 = SWIG_TMPOBJ ;
6961 int temp3 ;
6962 int res3 = SWIG_TMPOBJ ;
6963 int temp4 ;
6964 int res4 = SWIG_TMPOBJ ;
6965
6966 arg1 = &temp1;
6967 arg2 = &temp2;
6968 arg3 = &temp3;
6969 arg4 = &temp4;
6970 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6971 {
6972 if (!wxPyCheckForApp()) SWIG_fail;
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6975 wxPyEndAllowThreads(__tstate);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_Py_Void();
6979 if (SWIG_IsTmpObj(res1)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6984 }
6985 if (SWIG_IsTmpObj(res2)) {
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6987 } else {
6988 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6990 }
6991 if (SWIG_IsTmpObj(res3)) {
6992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6993 } else {
6994 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6996 }
6997 if (SWIG_IsTmpObj(res4)) {
6998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6999 } else {
7000 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7002 }
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7010 PyObject *resultobj = 0;
7011 wxRect result;
7012
7013 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7014 {
7015 if (!wxPyCheckForApp()) SWIG_fail;
7016 PyThreadState* __tstate = wxPyBeginAllowThreads();
7017 result = wxGetClientDisplayRect();
7018 wxPyEndAllowThreads(__tstate);
7019 if (PyErr_Occurred()) SWIG_fail;
7020 }
7021 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7029 PyObject *resultobj = 0;
7030 wxCursor *arg1 = 0 ;
7031 void *argp1 = 0 ;
7032 int res1 = 0 ;
7033 PyObject * obj0 = 0 ;
7034 char * kwnames[] = {
7035 (char *) "cursor", NULL
7036 };
7037
7038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7039 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7040 if (!SWIG_IsOK(res1)) {
7041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7042 }
7043 if (!argp1) {
7044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7045 }
7046 arg1 = reinterpret_cast< wxCursor * >(argp1);
7047 {
7048 if (!wxPyCheckForApp()) SWIG_fail;
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 wxSetCursor(*arg1);
7051 wxPyEndAllowThreads(__tstate);
7052 if (PyErr_Occurred()) SWIG_fail;
7053 }
7054 resultobj = SWIG_Py_Void();
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062 PyObject *resultobj = 0;
7063 void *result = 0 ;
7064
7065 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7066 {
7067 if (!wxPyCheckForApp()) SWIG_fail;
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (void *)wxGetXDisplay();
7070 wxPyEndAllowThreads(__tstate);
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7074 return resultobj;
7075 fail:
7076 return NULL;
7077 }
7078
7079
7080 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7081 PyObject *resultobj = 0;
7082 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7083 void *argp1 = 0 ;
7084 int res1 = 0 ;
7085 PyObject * obj0 = 0 ;
7086 char * kwnames[] = {
7087 (char *) "cursor", NULL
7088 };
7089
7090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7091 if (obj0) {
7092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7095 }
7096 arg1 = reinterpret_cast< wxCursor * >(argp1);
7097 }
7098 {
7099 if (!wxPyCheckForApp()) SWIG_fail;
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 wxBeginBusyCursor(arg1);
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 resultobj = SWIG_Py_Void();
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7113 PyObject *resultobj = 0;
7114 wxPoint result;
7115
7116 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7117 {
7118 if (!wxPyCheckForApp()) SWIG_fail;
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = wxGetMousePosition();
7121 wxPyEndAllowThreads(__tstate);
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7132 PyObject *resultobj = 0;
7133 wxWindow *result = 0 ;
7134
7135 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7136 {
7137 if (!wxPyCheckForApp()) SWIG_fail;
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 result = (wxWindow *)FindWindowAtPointer();
7140 wxPyEndAllowThreads(__tstate);
7141 if (PyErr_Occurred()) SWIG_fail;
7142 }
7143 {
7144 resultobj = wxPyMake_wxObject(result, 0);
7145 }
7146 return resultobj;
7147 fail:
7148 return NULL;
7149 }
7150
7151
7152 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7153 PyObject *resultobj = 0;
7154 wxWindow *result = 0 ;
7155
7156 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7157 {
7158 if (!wxPyCheckForApp()) SWIG_fail;
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (wxWindow *)wxGetActiveWindow();
7161 wxPyEndAllowThreads(__tstate);
7162 if (PyErr_Occurred()) SWIG_fail;
7163 }
7164 {
7165 resultobj = wxPyMake_wxObject(result, 0);
7166 }
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7174 PyObject *resultobj = 0;
7175 wxPoint *arg1 = 0 ;
7176 wxWindow *result = 0 ;
7177 wxPoint temp1 ;
7178 PyObject * obj0 = 0 ;
7179 char * kwnames[] = {
7180 (char *) "pt", NULL
7181 };
7182
7183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7184 {
7185 arg1 = &temp1;
7186 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7187 }
7188 {
7189 if (!wxPyCheckForApp()) SWIG_fail;
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 {
7196 resultobj = wxPyMake_wxObject(result, 0);
7197 }
7198 return resultobj;
7199 fail:
7200 return NULL;
7201 }
7202
7203
7204 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj = 0;
7206 wxPoint *arg1 = 0 ;
7207 wxWindow *result = 0 ;
7208 wxPoint temp1 ;
7209 PyObject * obj0 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "pt", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7215 {
7216 arg1 = &temp1;
7217 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7218 }
7219 {
7220 if (!wxPyCheckForApp()) SWIG_fail;
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7223 wxPyEndAllowThreads(__tstate);
7224 if (PyErr_Occurred()) SWIG_fail;
7225 }
7226 {
7227 resultobj = wxPyMake_wxObject(result, 0);
7228 }
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxWindow *arg1 = (wxWindow *) 0 ;
7238 wxWindow *result = 0 ;
7239 void *argp1 = 0 ;
7240 int res1 = 0 ;
7241 PyObject * obj0 = 0 ;
7242 char * kwnames[] = {
7243 (char *) "win", NULL
7244 };
7245
7246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7248 if (!SWIG_IsOK(res1)) {
7249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7250 }
7251 arg1 = reinterpret_cast< wxWindow * >(argp1);
7252 {
7253 if (!wxPyCheckForApp()) SWIG_fail;
7254 PyThreadState* __tstate = wxPyBeginAllowThreads();
7255 result = (wxWindow *)wxGetTopLevelParent(arg1);
7256 wxPyEndAllowThreads(__tstate);
7257 if (PyErr_Occurred()) SWIG_fail;
7258 }
7259 {
7260 resultobj = wxPyMake_wxObject(result, 0);
7261 }
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj = 0;
7270 wxString *arg1 = 0 ;
7271 bool result;
7272 bool temp1 = false ;
7273 PyObject * obj0 = 0 ;
7274 char * kwnames[] = {
7275 (char *) "url", NULL
7276 };
7277
7278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7279 {
7280 arg1 = wxString_in_helper(obj0);
7281 if (arg1 == NULL) SWIG_fail;
7282 temp1 = true;
7283 }
7284 {
7285 PyThreadState* __tstate = wxPyBeginAllowThreads();
7286 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7287 wxPyEndAllowThreads(__tstate);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 {
7291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7292 }
7293 {
7294 if (temp1)
7295 delete arg1;
7296 }
7297 return resultobj;
7298 fail:
7299 {
7300 if (temp1)
7301 delete arg1;
7302 }
7303 return NULL;
7304 }
7305
7306
7307 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj = 0;
7309 wxKeyCode arg1 ;
7310 bool result;
7311 int val1 ;
7312 int ecode1 = 0 ;
7313 PyObject * obj0 = 0 ;
7314 char * kwnames[] = {
7315 (char *) "key", NULL
7316 };
7317
7318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7319 ecode1 = SWIG_AsVal_int(obj0, &val1);
7320 if (!SWIG_IsOK(ecode1)) {
7321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7322 }
7323 arg1 = static_cast< wxKeyCode >(val1);
7324 {
7325 if (!wxPyCheckForApp()) SWIG_fail;
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (bool)wxGetKeyState(arg1);
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 {
7332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7333 }
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7341 PyObject *resultobj = 0;
7342 wxMouseState *result = 0 ;
7343
7344 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 result = (wxMouseState *)new wxMouseState();
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7359 PyObject *resultobj = 0;
7360 wxMouseState *arg1 = (wxMouseState *) 0 ;
7361 void *argp1 = 0 ;
7362 int res1 = 0 ;
7363 PyObject *swig_obj[1] ;
7364
7365 if (!args) SWIG_fail;
7366 swig_obj[0] = args;
7367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7370 }
7371 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 delete arg1;
7375
7376 wxPyEndAllowThreads(__tstate);
7377 if (PyErr_Occurred()) SWIG_fail;
7378 }
7379 resultobj = SWIG_Py_Void();
7380 return resultobj;
7381 fail:
7382 return NULL;
7383 }
7384
7385
7386 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7387 PyObject *resultobj = 0;
7388 wxMouseState *arg1 = (wxMouseState *) 0 ;
7389 int result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 PyObject *swig_obj[1] ;
7393
7394 if (!args) SWIG_fail;
7395 swig_obj[0] = args;
7396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7399 }
7400 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 result = (int)(arg1)->GetX();
7404 wxPyEndAllowThreads(__tstate);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 resultobj = SWIG_From_int(static_cast< int >(result));
7408 return resultobj;
7409 fail:
7410 return NULL;
7411 }
7412
7413
7414 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7415 PyObject *resultobj = 0;
7416 wxMouseState *arg1 = (wxMouseState *) 0 ;
7417 int result;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 PyObject *swig_obj[1] ;
7421
7422 if (!args) SWIG_fail;
7423 swig_obj[0] = args;
7424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7425 if (!SWIG_IsOK(res1)) {
7426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7427 }
7428 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7429 {
7430 PyThreadState* __tstate = wxPyBeginAllowThreads();
7431 result = (int)(arg1)->GetY();
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 resultobj = SWIG_From_int(static_cast< int >(result));
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7443 PyObject *resultobj = 0;
7444 wxMouseState *arg1 = (wxMouseState *) 0 ;
7445 bool result;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 PyObject *swig_obj[1] ;
7449
7450 if (!args) SWIG_fail;
7451 swig_obj[0] = args;
7452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7453 if (!SWIG_IsOK(res1)) {
7454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7455 }
7456 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = (bool)(arg1)->LeftDown();
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 {
7464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7465 }
7466 return resultobj;
7467 fail:
7468 return NULL;
7469 }
7470
7471
7472 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7473 PyObject *resultobj = 0;
7474 wxMouseState *arg1 = (wxMouseState *) 0 ;
7475 bool result;
7476 void *argp1 = 0 ;
7477 int res1 = 0 ;
7478 PyObject *swig_obj[1] ;
7479
7480 if (!args) SWIG_fail;
7481 swig_obj[0] = args;
7482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7485 }
7486 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (bool)(arg1)->MiddleDown();
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 {
7494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495 }
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7503 PyObject *resultobj = 0;
7504 wxMouseState *arg1 = (wxMouseState *) 0 ;
7505 bool result;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 PyObject *swig_obj[1] ;
7509
7510 if (!args) SWIG_fail;
7511 swig_obj[0] = args;
7512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7513 if (!SWIG_IsOK(res1)) {
7514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7515 }
7516 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (bool)(arg1)->RightDown();
7520 wxPyEndAllowThreads(__tstate);
7521 if (PyErr_Occurred()) SWIG_fail;
7522 }
7523 {
7524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7525 }
7526 return resultobj;
7527 fail:
7528 return NULL;
7529 }
7530
7531
7532 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7533 PyObject *resultobj = 0;
7534 wxMouseState *arg1 = (wxMouseState *) 0 ;
7535 bool result;
7536 void *argp1 = 0 ;
7537 int res1 = 0 ;
7538 PyObject *swig_obj[1] ;
7539
7540 if (!args) SWIG_fail;
7541 swig_obj[0] = args;
7542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7543 if (!SWIG_IsOK(res1)) {
7544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7545 }
7546 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7547 {
7548 PyThreadState* __tstate = wxPyBeginAllowThreads();
7549 result = (bool)(arg1)->ControlDown();
7550 wxPyEndAllowThreads(__tstate);
7551 if (PyErr_Occurred()) SWIG_fail;
7552 }
7553 {
7554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7555 }
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7563 PyObject *resultobj = 0;
7564 wxMouseState *arg1 = (wxMouseState *) 0 ;
7565 bool result;
7566 void *argp1 = 0 ;
7567 int res1 = 0 ;
7568 PyObject *swig_obj[1] ;
7569
7570 if (!args) SWIG_fail;
7571 swig_obj[0] = args;
7572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7573 if (!SWIG_IsOK(res1)) {
7574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7575 }
7576 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7577 {
7578 PyThreadState* __tstate = wxPyBeginAllowThreads();
7579 result = (bool)(arg1)->ShiftDown();
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7585 }
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7593 PyObject *resultobj = 0;
7594 wxMouseState *arg1 = (wxMouseState *) 0 ;
7595 bool result;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 PyObject *swig_obj[1] ;
7599
7600 if (!args) SWIG_fail;
7601 swig_obj[0] = args;
7602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7603 if (!SWIG_IsOK(res1)) {
7604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7605 }
7606 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)(arg1)->AltDown();
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7623 PyObject *resultobj = 0;
7624 wxMouseState *arg1 = (wxMouseState *) 0 ;
7625 bool result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 PyObject *swig_obj[1] ;
7629
7630 if (!args) SWIG_fail;
7631 swig_obj[0] = args;
7632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7633 if (!SWIG_IsOK(res1)) {
7634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7635 }
7636 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 result = (bool)(arg1)->MetaDown();
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 {
7644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7645 }
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7653 PyObject *resultobj = 0;
7654 wxMouseState *arg1 = (wxMouseState *) 0 ;
7655 bool result;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 PyObject *swig_obj[1] ;
7659
7660 if (!args) SWIG_fail;
7661 swig_obj[0] = args;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7665 }
7666 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 result = (bool)(arg1)->CmdDown();
7670 wxPyEndAllowThreads(__tstate);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 {
7674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7675 }
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj = 0;
7684 wxMouseState *arg1 = (wxMouseState *) 0 ;
7685 int arg2 ;
7686 void *argp1 = 0 ;
7687 int res1 = 0 ;
7688 int val2 ;
7689 int ecode2 = 0 ;
7690 PyObject * obj0 = 0 ;
7691 PyObject * obj1 = 0 ;
7692 char * kwnames[] = {
7693 (char *) "self",(char *) "x", NULL
7694 };
7695
7696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7698 if (!SWIG_IsOK(res1)) {
7699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7700 }
7701 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7702 ecode2 = SWIG_AsVal_int(obj1, &val2);
7703 if (!SWIG_IsOK(ecode2)) {
7704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7705 }
7706 arg2 = static_cast< int >(val2);
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 (arg1)->SetX(arg2);
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 resultobj = SWIG_Py_Void();
7714 return resultobj;
7715 fail:
7716 return NULL;
7717 }
7718
7719
7720 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7721 PyObject *resultobj = 0;
7722 wxMouseState *arg1 = (wxMouseState *) 0 ;
7723 int arg2 ;
7724 void *argp1 = 0 ;
7725 int res1 = 0 ;
7726 int val2 ;
7727 int ecode2 = 0 ;
7728 PyObject * obj0 = 0 ;
7729 PyObject * obj1 = 0 ;
7730 char * kwnames[] = {
7731 (char *) "self",(char *) "y", NULL
7732 };
7733
7734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7736 if (!SWIG_IsOK(res1)) {
7737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7738 }
7739 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7740 ecode2 = SWIG_AsVal_int(obj1, &val2);
7741 if (!SWIG_IsOK(ecode2)) {
7742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7743 }
7744 arg2 = static_cast< int >(val2);
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 (arg1)->SetY(arg2);
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 resultobj = SWIG_Py_Void();
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7759 PyObject *resultobj = 0;
7760 wxMouseState *arg1 = (wxMouseState *) 0 ;
7761 bool arg2 ;
7762 void *argp1 = 0 ;
7763 int res1 = 0 ;
7764 bool val2 ;
7765 int ecode2 = 0 ;
7766 PyObject * obj0 = 0 ;
7767 PyObject * obj1 = 0 ;
7768 char * kwnames[] = {
7769 (char *) "self",(char *) "down", NULL
7770 };
7771
7772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7776 }
7777 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7781 }
7782 arg2 = static_cast< bool >(val2);
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 (arg1)->SetLeftDown(arg2);
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_Py_Void();
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7797 PyObject *resultobj = 0;
7798 wxMouseState *arg1 = (wxMouseState *) 0 ;
7799 bool arg2 ;
7800 void *argp1 = 0 ;
7801 int res1 = 0 ;
7802 bool val2 ;
7803 int ecode2 = 0 ;
7804 PyObject * obj0 = 0 ;
7805 PyObject * obj1 = 0 ;
7806 char * kwnames[] = {
7807 (char *) "self",(char *) "down", NULL
7808 };
7809
7810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7812 if (!SWIG_IsOK(res1)) {
7813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7814 }
7815 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7816 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7817 if (!SWIG_IsOK(ecode2)) {
7818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7819 }
7820 arg2 = static_cast< bool >(val2);
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 (arg1)->SetMiddleDown(arg2);
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 resultobj = SWIG_Py_Void();
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7835 PyObject *resultobj = 0;
7836 wxMouseState *arg1 = (wxMouseState *) 0 ;
7837 bool arg2 ;
7838 void *argp1 = 0 ;
7839 int res1 = 0 ;
7840 bool val2 ;
7841 int ecode2 = 0 ;
7842 PyObject * obj0 = 0 ;
7843 PyObject * obj1 = 0 ;
7844 char * kwnames[] = {
7845 (char *) "self",(char *) "down", NULL
7846 };
7847
7848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7850 if (!SWIG_IsOK(res1)) {
7851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7852 }
7853 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7854 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7855 if (!SWIG_IsOK(ecode2)) {
7856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7857 }
7858 arg2 = static_cast< bool >(val2);
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 (arg1)->SetRightDown(arg2);
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = SWIG_Py_Void();
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj = 0;
7874 wxMouseState *arg1 = (wxMouseState *) 0 ;
7875 bool arg2 ;
7876 void *argp1 = 0 ;
7877 int res1 = 0 ;
7878 bool val2 ;
7879 int ecode2 = 0 ;
7880 PyObject * obj0 = 0 ;
7881 PyObject * obj1 = 0 ;
7882 char * kwnames[] = {
7883 (char *) "self",(char *) "down", NULL
7884 };
7885
7886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7890 }
7891 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7893 if (!SWIG_IsOK(ecode2)) {
7894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7895 }
7896 arg2 = static_cast< bool >(val2);
7897 {
7898 PyThreadState* __tstate = wxPyBeginAllowThreads();
7899 (arg1)->SetControlDown(arg2);
7900 wxPyEndAllowThreads(__tstate);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 resultobj = SWIG_Py_Void();
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7911 PyObject *resultobj = 0;
7912 wxMouseState *arg1 = (wxMouseState *) 0 ;
7913 bool arg2 ;
7914 void *argp1 = 0 ;
7915 int res1 = 0 ;
7916 bool val2 ;
7917 int ecode2 = 0 ;
7918 PyObject * obj0 = 0 ;
7919 PyObject * obj1 = 0 ;
7920 char * kwnames[] = {
7921 (char *) "self",(char *) "down", NULL
7922 };
7923
7924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7926 if (!SWIG_IsOK(res1)) {
7927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7928 }
7929 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7931 if (!SWIG_IsOK(ecode2)) {
7932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7933 }
7934 arg2 = static_cast< bool >(val2);
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 (arg1)->SetShiftDown(arg2);
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = SWIG_Py_Void();
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj = 0;
7950 wxMouseState *arg1 = (wxMouseState *) 0 ;
7951 bool arg2 ;
7952 void *argp1 = 0 ;
7953 int res1 = 0 ;
7954 bool val2 ;
7955 int ecode2 = 0 ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char * kwnames[] = {
7959 (char *) "self",(char *) "down", NULL
7960 };
7961
7962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7964 if (!SWIG_IsOK(res1)) {
7965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7966 }
7967 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7969 if (!SWIG_IsOK(ecode2)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7971 }
7972 arg2 = static_cast< bool >(val2);
7973 {
7974 PyThreadState* __tstate = wxPyBeginAllowThreads();
7975 (arg1)->SetAltDown(arg2);
7976 wxPyEndAllowThreads(__tstate);
7977 if (PyErr_Occurred()) SWIG_fail;
7978 }
7979 resultobj = SWIG_Py_Void();
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj = 0;
7988 wxMouseState *arg1 = (wxMouseState *) 0 ;
7989 bool arg2 ;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 bool val2 ;
7993 int ecode2 = 0 ;
7994 PyObject * obj0 = 0 ;
7995 PyObject * obj1 = 0 ;
7996 char * kwnames[] = {
7997 (char *) "self",(char *) "down", NULL
7998 };
7999
8000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
8001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
8002 if (!SWIG_IsOK(res1)) {
8003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
8004 }
8005 arg1 = reinterpret_cast< wxMouseState * >(argp1);
8006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
8007 if (!SWIG_IsOK(ecode2)) {
8008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8009 }
8010 arg2 = static_cast< bool >(val2);
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 (arg1)->SetMetaDown(arg2);
8014 wxPyEndAllowThreads(__tstate);
8015 if (PyErr_Occurred()) SWIG_fail;
8016 }
8017 resultobj = SWIG_Py_Void();
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 PyObject *obj;
8026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8027 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8028 return SWIG_Py_Void();
8029 }
8030
8031 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8032 return SWIG_Python_InitShadowInstance(args);
8033 }
8034
8035 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8036 PyObject *resultobj = 0;
8037 wxMouseState result;
8038
8039 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8040 {
8041 PyThreadState* __tstate = wxPyBeginAllowThreads();
8042 result = wxGetMouseState();
8043 wxPyEndAllowThreads(__tstate);
8044 if (PyErr_Occurred()) SWIG_fail;
8045 }
8046 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055
8056 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8057 {
8058 if (!wxPyCheckForApp()) SWIG_fail;
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 wxWakeUpMainThread();
8061 wxPyEndAllowThreads(__tstate);
8062 if (PyErr_Occurred()) SWIG_fail;
8063 }
8064 resultobj = SWIG_Py_Void();
8065 return resultobj;
8066 fail:
8067 return NULL;
8068 }
8069
8070
8071 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8072 PyObject *resultobj = 0;
8073
8074 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8075 {
8076 if (!wxPyCheckForApp()) SWIG_fail;
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 wxMutexGuiEnter();
8079 wxPyEndAllowThreads(__tstate);
8080 if (PyErr_Occurred()) SWIG_fail;
8081 }
8082 resultobj = SWIG_Py_Void();
8083 return resultobj;
8084 fail:
8085 return NULL;
8086 }
8087
8088
8089 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8090 PyObject *resultobj = 0;
8091
8092 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8093 {
8094 if (!wxPyCheckForApp()) SWIG_fail;
8095 PyThreadState* __tstate = wxPyBeginAllowThreads();
8096 wxMutexGuiLeave();
8097 wxPyEndAllowThreads(__tstate);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 resultobj = SWIG_Py_Void();
8101 return resultobj;
8102 fail:
8103 return NULL;
8104 }
8105
8106
8107 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8108 PyObject *resultobj = 0;
8109 wxMutexGuiLocker *result = 0 ;
8110
8111 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8112 {
8113 if (!wxPyCheckForApp()) SWIG_fail;
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8127 PyObject *resultobj = 0;
8128 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8129 void *argp1 = 0 ;
8130 int res1 = 0 ;
8131 PyObject *swig_obj[1] ;
8132
8133 if (!args) SWIG_fail;
8134 swig_obj[0] = args;
8135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8136 if (!SWIG_IsOK(res1)) {
8137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8138 }
8139 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 delete arg1;
8143
8144 wxPyEndAllowThreads(__tstate);
8145 if (PyErr_Occurred()) SWIG_fail;
8146 }
8147 resultobj = SWIG_Py_Void();
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8155 PyObject *obj;
8156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8157 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8158 return SWIG_Py_Void();
8159 }
8160
8161 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8162 return SWIG_Python_InitShadowInstance(args);
8163 }
8164
8165 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8166 PyObject *resultobj = 0;
8167 bool result;
8168
8169 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 result = (bool)wxThread_IsMain();
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8178 }
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj = 0;
8187 wxString *arg1 = 0 ;
8188 wxToolTip *result = 0 ;
8189 bool temp1 = false ;
8190 PyObject * obj0 = 0 ;
8191 char * kwnames[] = {
8192 (char *) "tip", NULL
8193 };
8194
8195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8196 {
8197 arg1 = wxString_in_helper(obj0);
8198 if (arg1 == NULL) SWIG_fail;
8199 temp1 = true;
8200 }
8201 {
8202 if (!wxPyCheckForApp()) SWIG_fail;
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8209 {
8210 if (temp1)
8211 delete arg1;
8212 }
8213 return resultobj;
8214 fail:
8215 {
8216 if (temp1)
8217 delete arg1;
8218 }
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8224 PyObject *resultobj = 0;
8225 wxToolTip *arg1 = (wxToolTip *) 0 ;
8226 void *argp1 = 0 ;
8227 int res1 = 0 ;
8228 PyObject *swig_obj[1] ;
8229
8230 if (!args) SWIG_fail;
8231 swig_obj[0] = args;
8232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8233 if (!SWIG_IsOK(res1)) {
8234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8235 }
8236 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8237 {
8238 PyThreadState* __tstate = wxPyBeginAllowThreads();
8239 delete arg1;
8240
8241 wxPyEndAllowThreads(__tstate);
8242 if (PyErr_Occurred()) SWIG_fail;
8243 }
8244 resultobj = SWIG_Py_Void();
8245 return resultobj;
8246 fail:
8247 return NULL;
8248 }
8249
8250
8251 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8252 PyObject *resultobj = 0;
8253 wxToolTip *arg1 = (wxToolTip *) 0 ;
8254 wxString *arg2 = 0 ;
8255 void *argp1 = 0 ;
8256 int res1 = 0 ;
8257 bool temp2 = false ;
8258 PyObject * obj0 = 0 ;
8259 PyObject * obj1 = 0 ;
8260 char * kwnames[] = {
8261 (char *) "self",(char *) "tip", NULL
8262 };
8263
8264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8266 if (!SWIG_IsOK(res1)) {
8267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8268 }
8269 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8270 {
8271 arg2 = wxString_in_helper(obj1);
8272 if (arg2 == NULL) SWIG_fail;
8273 temp2 = true;
8274 }
8275 {
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 (arg1)->SetTip((wxString const &)*arg2);
8278 wxPyEndAllowThreads(__tstate);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 resultobj = SWIG_Py_Void();
8282 {
8283 if (temp2)
8284 delete arg2;
8285 }
8286 return resultobj;
8287 fail:
8288 {
8289 if (temp2)
8290 delete arg2;
8291 }
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8297 PyObject *resultobj = 0;
8298 wxToolTip *arg1 = (wxToolTip *) 0 ;
8299 wxString result;
8300 void *argp1 = 0 ;
8301 int res1 = 0 ;
8302 PyObject *swig_obj[1] ;
8303
8304 if (!args) SWIG_fail;
8305 swig_obj[0] = args;
8306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8307 if (!SWIG_IsOK(res1)) {
8308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8309 }
8310 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (arg1)->GetTip();
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 {
8318 #if wxUSE_UNICODE
8319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8320 #else
8321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8322 #endif
8323 }
8324 return resultobj;
8325 fail:
8326 return NULL;
8327 }
8328
8329
8330 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8331 PyObject *resultobj = 0;
8332 wxToolTip *arg1 = (wxToolTip *) 0 ;
8333 wxWindow *result = 0 ;
8334 void *argp1 = 0 ;
8335 int res1 = 0 ;
8336 PyObject *swig_obj[1] ;
8337
8338 if (!args) SWIG_fail;
8339 swig_obj[0] = args;
8340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8343 }
8344 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8345 {
8346 PyThreadState* __tstate = wxPyBeginAllowThreads();
8347 result = (wxWindow *)(arg1)->GetWindow();
8348 wxPyEndAllowThreads(__tstate);
8349 if (PyErr_Occurred()) SWIG_fail;
8350 }
8351 {
8352 resultobj = wxPyMake_wxObject(result, 0);
8353 }
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 bool arg1 ;
8363 bool val1 ;
8364 int ecode1 = 0 ;
8365 PyObject * obj0 = 0 ;
8366 char * kwnames[] = {
8367 (char *) "flag", NULL
8368 };
8369
8370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8371 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8372 if (!SWIG_IsOK(ecode1)) {
8373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8374 }
8375 arg1 = static_cast< bool >(val1);
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 wxToolTip::Enable(arg1);
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 resultobj = SWIG_Py_Void();
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj = 0;
8391 long arg1 ;
8392 long val1 ;
8393 int ecode1 = 0 ;
8394 PyObject * obj0 = 0 ;
8395 char * kwnames[] = {
8396 (char *) "milliseconds", NULL
8397 };
8398
8399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8400 ecode1 = SWIG_AsVal_long(obj0, &val1);
8401 if (!SWIG_IsOK(ecode1)) {
8402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8403 }
8404 arg1 = static_cast< long >(val1);
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 wxToolTip::SetDelay(arg1);
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_Py_Void();
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8419 PyObject *obj;
8420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8421 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8422 return SWIG_Py_Void();
8423 }
8424
8425 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8426 return SWIG_Python_InitShadowInstance(args);
8427 }
8428
8429 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8430 PyObject *resultobj = 0;
8431 wxWindow *arg1 = (wxWindow *) 0 ;
8432 wxSize *arg2 = 0 ;
8433 wxCaret *result = 0 ;
8434 void *argp1 = 0 ;
8435 int res1 = 0 ;
8436 wxSize temp2 ;
8437 PyObject * obj0 = 0 ;
8438 PyObject * obj1 = 0 ;
8439 char * kwnames[] = {
8440 (char *) "window",(char *) "size", NULL
8441 };
8442
8443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8445 if (!SWIG_IsOK(res1)) {
8446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8447 }
8448 arg1 = reinterpret_cast< wxWindow * >(argp1);
8449 {
8450 arg2 = &temp2;
8451 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8452 }
8453 {
8454 if (!wxPyCheckForApp()) SWIG_fail;
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8457 wxPyEndAllowThreads(__tstate);
8458 if (PyErr_Occurred()) SWIG_fail;
8459 }
8460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8468 PyObject *resultobj = 0;
8469 wxCaret *arg1 = (wxCaret *) 0 ;
8470 void *argp1 = 0 ;
8471 int res1 = 0 ;
8472 PyObject *swig_obj[1] ;
8473
8474 if (!args) SWIG_fail;
8475 swig_obj[0] = args;
8476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8477 if (!SWIG_IsOK(res1)) {
8478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8479 }
8480 arg1 = reinterpret_cast< wxCaret * >(argp1);
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 delete arg1;
8484
8485 wxPyEndAllowThreads(__tstate);
8486 if (PyErr_Occurred()) SWIG_fail;
8487 }
8488 resultobj = SWIG_Py_Void();
8489 return resultobj;
8490 fail:
8491 return NULL;
8492 }
8493
8494
8495 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8496 PyObject *resultobj = 0;
8497 wxCaret *arg1 = (wxCaret *) 0 ;
8498 void *argp1 = 0 ;
8499 int res1 = 0 ;
8500 PyObject *swig_obj[1] ;
8501
8502 if (!args) SWIG_fail;
8503 swig_obj[0] = args;
8504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8505 if (!SWIG_IsOK(res1)) {
8506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8507 }
8508 arg1 = reinterpret_cast< wxCaret * >(argp1);
8509 {
8510 PyThreadState* __tstate = wxPyBeginAllowThreads();
8511 wxCaret_Destroy(arg1);
8512 wxPyEndAllowThreads(__tstate);
8513 if (PyErr_Occurred()) SWIG_fail;
8514 }
8515 resultobj = SWIG_Py_Void();
8516 return resultobj;
8517 fail:
8518 return NULL;
8519 }
8520
8521
8522 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8523 PyObject *resultobj = 0;
8524 wxCaret *arg1 = (wxCaret *) 0 ;
8525 bool result;
8526 void *argp1 = 0 ;
8527 int res1 = 0 ;
8528 PyObject *swig_obj[1] ;
8529
8530 if (!args) SWIG_fail;
8531 swig_obj[0] = args;
8532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8533 if (!SWIG_IsOK(res1)) {
8534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8535 }
8536 arg1 = reinterpret_cast< wxCaret * >(argp1);
8537 {
8538 PyThreadState* __tstate = wxPyBeginAllowThreads();
8539 result = (bool)(arg1)->IsOk();
8540 wxPyEndAllowThreads(__tstate);
8541 if (PyErr_Occurred()) SWIG_fail;
8542 }
8543 {
8544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8545 }
8546 return resultobj;
8547 fail:
8548 return NULL;
8549 }
8550
8551
8552 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8553 PyObject *resultobj = 0;
8554 wxCaret *arg1 = (wxCaret *) 0 ;
8555 bool result;
8556 void *argp1 = 0 ;
8557 int res1 = 0 ;
8558 PyObject *swig_obj[1] ;
8559
8560 if (!args) SWIG_fail;
8561 swig_obj[0] = args;
8562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8565 }
8566 arg1 = reinterpret_cast< wxCaret * >(argp1);
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 result = (bool)(arg1)->IsVisible();
8570 wxPyEndAllowThreads(__tstate);
8571 if (PyErr_Occurred()) SWIG_fail;
8572 }
8573 {
8574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8575 }
8576 return resultobj;
8577 fail:
8578 return NULL;
8579 }
8580
8581
8582 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8583 PyObject *resultobj = 0;
8584 wxCaret *arg1 = (wxCaret *) 0 ;
8585 wxPoint result;
8586 void *argp1 = 0 ;
8587 int res1 = 0 ;
8588 PyObject *swig_obj[1] ;
8589
8590 if (!args) SWIG_fail;
8591 swig_obj[0] = args;
8592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8595 }
8596 arg1 = reinterpret_cast< wxCaret * >(argp1);
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 result = (arg1)->GetPosition();
8600 wxPyEndAllowThreads(__tstate);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8611 PyObject *resultobj = 0;
8612 wxCaret *arg1 = (wxCaret *) 0 ;
8613 int *arg2 = (int *) 0 ;
8614 int *arg3 = (int *) 0 ;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 int temp2 ;
8618 int res2 = SWIG_TMPOBJ ;
8619 int temp3 ;
8620 int res3 = SWIG_TMPOBJ ;
8621 PyObject *swig_obj[1] ;
8622
8623 arg2 = &temp2;
8624 arg3 = &temp3;
8625 if (!args) SWIG_fail;
8626 swig_obj[0] = args;
8627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8630 }
8631 arg1 = reinterpret_cast< wxCaret * >(argp1);
8632 {
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 (arg1)->GetPosition(arg2,arg3);
8635 wxPyEndAllowThreads(__tstate);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 resultobj = SWIG_Py_Void();
8639 if (SWIG_IsTmpObj(res2)) {
8640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8641 } else {
8642 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8644 }
8645 if (SWIG_IsTmpObj(res3)) {
8646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8647 } else {
8648 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8650 }
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8658 PyObject *resultobj = 0;
8659 wxCaret *arg1 = (wxCaret *) 0 ;
8660 wxSize result;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 PyObject *swig_obj[1] ;
8664
8665 if (!args) SWIG_fail;
8666 swig_obj[0] = args;
8667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8668 if (!SWIG_IsOK(res1)) {
8669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8670 }
8671 arg1 = reinterpret_cast< wxCaret * >(argp1);
8672 {
8673 PyThreadState* __tstate = wxPyBeginAllowThreads();
8674 result = (arg1)->GetSize();
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8679 return resultobj;
8680 fail:
8681 return NULL;
8682 }
8683
8684
8685 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8686 PyObject *resultobj = 0;
8687 wxCaret *arg1 = (wxCaret *) 0 ;
8688 int *arg2 = (int *) 0 ;
8689 int *arg3 = (int *) 0 ;
8690 void *argp1 = 0 ;
8691 int res1 = 0 ;
8692 int temp2 ;
8693 int res2 = SWIG_TMPOBJ ;
8694 int temp3 ;
8695 int res3 = SWIG_TMPOBJ ;
8696 PyObject *swig_obj[1] ;
8697
8698 arg2 = &temp2;
8699 arg3 = &temp3;
8700 if (!args) SWIG_fail;
8701 swig_obj[0] = args;
8702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8703 if (!SWIG_IsOK(res1)) {
8704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8705 }
8706 arg1 = reinterpret_cast< wxCaret * >(argp1);
8707 {
8708 PyThreadState* __tstate = wxPyBeginAllowThreads();
8709 (arg1)->GetSize(arg2,arg3);
8710 wxPyEndAllowThreads(__tstate);
8711 if (PyErr_Occurred()) SWIG_fail;
8712 }
8713 resultobj = SWIG_Py_Void();
8714 if (SWIG_IsTmpObj(res2)) {
8715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8716 } else {
8717 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8719 }
8720 if (SWIG_IsTmpObj(res3)) {
8721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8722 } else {
8723 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8725 }
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8733 PyObject *resultobj = 0;
8734 wxCaret *arg1 = (wxCaret *) 0 ;
8735 wxWindow *result = 0 ;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 PyObject *swig_obj[1] ;
8739
8740 if (!args) SWIG_fail;
8741 swig_obj[0] = args;
8742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8743 if (!SWIG_IsOK(res1)) {
8744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8745 }
8746 arg1 = reinterpret_cast< wxCaret * >(argp1);
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 result = (wxWindow *)(arg1)->GetWindow();
8750 wxPyEndAllowThreads(__tstate);
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 {
8754 resultobj = wxPyMake_wxObject(result, 0);
8755 }
8756 return resultobj;
8757 fail:
8758 return NULL;
8759 }
8760
8761
8762 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8763 PyObject *resultobj = 0;
8764 wxCaret *arg1 = (wxCaret *) 0 ;
8765 int arg2 ;
8766 int arg3 ;
8767 void *argp1 = 0 ;
8768 int res1 = 0 ;
8769 int val2 ;
8770 int ecode2 = 0 ;
8771 int val3 ;
8772 int ecode3 = 0 ;
8773 PyObject * obj0 = 0 ;
8774 PyObject * obj1 = 0 ;
8775 PyObject * obj2 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "x",(char *) "y", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8784 }
8785 arg1 = reinterpret_cast< wxCaret * >(argp1);
8786 ecode2 = SWIG_AsVal_int(obj1, &val2);
8787 if (!SWIG_IsOK(ecode2)) {
8788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8789 }
8790 arg2 = static_cast< int >(val2);
8791 ecode3 = SWIG_AsVal_int(obj2, &val3);
8792 if (!SWIG_IsOK(ecode3)) {
8793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8794 }
8795 arg3 = static_cast< int >(val3);
8796 {
8797 PyThreadState* __tstate = wxPyBeginAllowThreads();
8798 (arg1)->Move(arg2,arg3);
8799 wxPyEndAllowThreads(__tstate);
8800 if (PyErr_Occurred()) SWIG_fail;
8801 }
8802 resultobj = SWIG_Py_Void();
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
8809 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8810 PyObject *resultobj = 0;
8811 wxCaret *arg1 = (wxCaret *) 0 ;
8812 wxPoint *arg2 = 0 ;
8813 void *argp1 = 0 ;
8814 int res1 = 0 ;
8815 wxPoint temp2 ;
8816 PyObject * obj0 = 0 ;
8817 PyObject * obj1 = 0 ;
8818 char * kwnames[] = {
8819 (char *) "self",(char *) "pt", NULL
8820 };
8821
8822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8824 if (!SWIG_IsOK(res1)) {
8825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8826 }
8827 arg1 = reinterpret_cast< wxCaret * >(argp1);
8828 {
8829 arg2 = &temp2;
8830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8831 }
8832 {
8833 PyThreadState* __tstate = wxPyBeginAllowThreads();
8834 (arg1)->Move((wxPoint const &)*arg2);
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 resultobj = SWIG_Py_Void();
8839 return resultobj;
8840 fail:
8841 return NULL;
8842 }
8843
8844
8845 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8846 PyObject *resultobj = 0;
8847 wxCaret *arg1 = (wxCaret *) 0 ;
8848 int arg2 ;
8849 int arg3 ;
8850 void *argp1 = 0 ;
8851 int res1 = 0 ;
8852 int val2 ;
8853 int ecode2 = 0 ;
8854 int val3 ;
8855 int ecode3 = 0 ;
8856 PyObject * obj0 = 0 ;
8857 PyObject * obj1 = 0 ;
8858 PyObject * obj2 = 0 ;
8859 char * kwnames[] = {
8860 (char *) "self",(char *) "width",(char *) "height", NULL
8861 };
8862
8863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8867 }
8868 arg1 = reinterpret_cast< wxCaret * >(argp1);
8869 ecode2 = SWIG_AsVal_int(obj1, &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8872 }
8873 arg2 = static_cast< int >(val2);
8874 ecode3 = SWIG_AsVal_int(obj2, &val3);
8875 if (!SWIG_IsOK(ecode3)) {
8876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8877 }
8878 arg3 = static_cast< int >(val3);
8879 {
8880 PyThreadState* __tstate = wxPyBeginAllowThreads();
8881 (arg1)->SetSize(arg2,arg3);
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_Py_Void();
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj = 0;
8894 wxCaret *arg1 = (wxCaret *) 0 ;
8895 wxSize *arg2 = 0 ;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 wxSize temp2 ;
8899 PyObject * obj0 = 0 ;
8900 PyObject * obj1 = 0 ;
8901 char * kwnames[] = {
8902 (char *) "self",(char *) "size", NULL
8903 };
8904
8905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8907 if (!SWIG_IsOK(res1)) {
8908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8909 }
8910 arg1 = reinterpret_cast< wxCaret * >(argp1);
8911 {
8912 arg2 = &temp2;
8913 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8914 }
8915 {
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 (arg1)->SetSize((wxSize const &)*arg2);
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 resultobj = SWIG_Py_Void();
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj = 0;
8930 wxCaret *arg1 = (wxCaret *) 0 ;
8931 int arg2 = (int) true ;
8932 void *argp1 = 0 ;
8933 int res1 = 0 ;
8934 int val2 ;
8935 int ecode2 = 0 ;
8936 PyObject * obj0 = 0 ;
8937 PyObject * obj1 = 0 ;
8938 char * kwnames[] = {
8939 (char *) "self",(char *) "show", NULL
8940 };
8941
8942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8944 if (!SWIG_IsOK(res1)) {
8945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8946 }
8947 arg1 = reinterpret_cast< wxCaret * >(argp1);
8948 if (obj1) {
8949 ecode2 = SWIG_AsVal_int(obj1, &val2);
8950 if (!SWIG_IsOK(ecode2)) {
8951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8952 }
8953 arg2 = static_cast< int >(val2);
8954 }
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 (arg1)->Show(arg2);
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 resultobj = SWIG_Py_Void();
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8969 PyObject *resultobj = 0;
8970 wxCaret *arg1 = (wxCaret *) 0 ;
8971 void *argp1 = 0 ;
8972 int res1 = 0 ;
8973 PyObject *swig_obj[1] ;
8974
8975 if (!args) SWIG_fail;
8976 swig_obj[0] = args;
8977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8978 if (!SWIG_IsOK(res1)) {
8979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8980 }
8981 arg1 = reinterpret_cast< wxCaret * >(argp1);
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 (arg1)->Hide();
8985 wxPyEndAllowThreads(__tstate);
8986 if (PyErr_Occurred()) SWIG_fail;
8987 }
8988 resultobj = SWIG_Py_Void();
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 int result;
8998
8999 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
9000 {
9001 PyThreadState* __tstate = wxPyBeginAllowThreads();
9002 result = (int)wxCaret::GetBlinkTime();
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 resultobj = SWIG_From_int(static_cast< int >(result));
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj = 0;
9015 int arg1 ;
9016 int val1 ;
9017 int ecode1 = 0 ;
9018 PyObject * obj0 = 0 ;
9019 char * kwnames[] = {
9020 (char *) "milliseconds", NULL
9021 };
9022
9023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9024 ecode1 = SWIG_AsVal_int(obj0, &val1);
9025 if (!SWIG_IsOK(ecode1)) {
9026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9027 }
9028 arg1 = static_cast< int >(val1);
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 wxCaret::SetBlinkTime(arg1);
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 resultobj = SWIG_Py_Void();
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9043 PyObject *obj;
9044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9045 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9046 return SWIG_Py_Void();
9047 }
9048
9049 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9050 return SWIG_Python_InitShadowInstance(args);
9051 }
9052
9053 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9054 PyObject *resultobj = 0;
9055 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9056 wxBusyCursor *result = 0 ;
9057 void *argp1 = 0 ;
9058 int res1 = 0 ;
9059 PyObject * obj0 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "cursor", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9065 if (obj0) {
9066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9067 if (!SWIG_IsOK(res1)) {
9068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9069 }
9070 arg1 = reinterpret_cast< wxCursor * >(argp1);
9071 }
9072 {
9073 if (!wxPyCheckForApp()) SWIG_fail;
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9076 wxPyEndAllowThreads(__tstate);
9077 if (PyErr_Occurred()) SWIG_fail;
9078 }
9079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9087 PyObject *resultobj = 0;
9088 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9089 void *argp1 = 0 ;
9090 int res1 = 0 ;
9091 PyObject *swig_obj[1] ;
9092
9093 if (!args) SWIG_fail;
9094 swig_obj[0] = args;
9095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9096 if (!SWIG_IsOK(res1)) {
9097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9098 }
9099 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 delete arg1;
9103
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_Py_Void();
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 PyObject *obj;
9116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9117 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9118 return SWIG_Py_Void();
9119 }
9120
9121 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 return SWIG_Python_InitShadowInstance(args);
9123 }
9124
9125 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj = 0;
9127 wxWindow *arg1 = (wxWindow *) NULL ;
9128 wxWindowDisabler *result = 0 ;
9129 void *argp1 = 0 ;
9130 int res1 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 char * kwnames[] = {
9133 (char *) "winToSkip", NULL
9134 };
9135
9136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9137 if (obj0) {
9138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9139 if (!SWIG_IsOK(res1)) {
9140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9141 }
9142 arg1 = reinterpret_cast< wxWindow * >(argp1);
9143 }
9144 {
9145 if (!wxPyCheckForApp()) SWIG_fail;
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9159 PyObject *resultobj = 0;
9160 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9161 void *argp1 = 0 ;
9162 int res1 = 0 ;
9163 PyObject *swig_obj[1] ;
9164
9165 if (!args) SWIG_fail;
9166 swig_obj[0] = args;
9167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9168 if (!SWIG_IsOK(res1)) {
9169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9170 }
9171 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 delete arg1;
9175
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 resultobj = SWIG_Py_Void();
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9187 PyObject *obj;
9188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9189 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9190 return SWIG_Py_Void();
9191 }
9192
9193 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9194 return SWIG_Python_InitShadowInstance(args);
9195 }
9196
9197 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj = 0;
9199 wxString *arg1 = 0 ;
9200 wxWindow *arg2 = (wxWindow *) NULL ;
9201 wxBusyInfo *result = 0 ;
9202 bool temp1 = false ;
9203 void *argp2 = 0 ;
9204 int res2 = 0 ;
9205 PyObject * obj0 = 0 ;
9206 PyObject * obj1 = 0 ;
9207 char * kwnames[] = {
9208 (char *) "message",(char *) "parent", NULL
9209 };
9210
9211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9212 {
9213 arg1 = wxString_in_helper(obj0);
9214 if (arg1 == NULL) SWIG_fail;
9215 temp1 = true;
9216 }
9217 if (obj1) {
9218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9219 if (!SWIG_IsOK(res2)) {
9220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9221 }
9222 arg2 = reinterpret_cast< wxWindow * >(argp2);
9223 }
9224 {
9225 if (!wxPyCheckForApp()) SWIG_fail;
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9232 {
9233 if (temp1)
9234 delete arg1;
9235 }
9236 return resultobj;
9237 fail:
9238 {
9239 if (temp1)
9240 delete arg1;
9241 }
9242 return NULL;
9243 }
9244
9245
9246 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9247 PyObject *resultobj = 0;
9248 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9249 void *argp1 = 0 ;
9250 int res1 = 0 ;
9251 PyObject *swig_obj[1] ;
9252
9253 if (!args) SWIG_fail;
9254 swig_obj[0] = args;
9255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9256 if (!SWIG_IsOK(res1)) {
9257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9258 }
9259 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9260 {
9261 PyThreadState* __tstate = wxPyBeginAllowThreads();
9262 delete arg1;
9263
9264 wxPyEndAllowThreads(__tstate);
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 resultobj = SWIG_Py_Void();
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 PyObject *obj;
9276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9277 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9278 return SWIG_Py_Void();
9279 }
9280
9281 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9282 return SWIG_Python_InitShadowInstance(args);
9283 }
9284
9285 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9286 PyObject *resultobj = 0;
9287 wxStopWatch *result = 0 ;
9288
9289 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 result = (wxStopWatch *)new wxStopWatch();
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9304 PyObject *resultobj = 0;
9305 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9306 void *argp1 = 0 ;
9307 int res1 = 0 ;
9308 PyObject *swig_obj[1] ;
9309
9310 if (!args) SWIG_fail;
9311 swig_obj[0] = args;
9312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9313 if (!SWIG_IsOK(res1)) {
9314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9315 }
9316 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 delete arg1;
9320
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj = 0;
9333 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9334 long arg2 = (long) 0 ;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 long val2 ;
9338 int ecode2 = 0 ;
9339 PyObject * obj0 = 0 ;
9340 PyObject * obj1 = 0 ;
9341 char * kwnames[] = {
9342 (char *) "self",(char *) "t0", NULL
9343 };
9344
9345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9347 if (!SWIG_IsOK(res1)) {
9348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9349 }
9350 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9351 if (obj1) {
9352 ecode2 = SWIG_AsVal_long(obj1, &val2);
9353 if (!SWIG_IsOK(ecode2)) {
9354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9355 }
9356 arg2 = static_cast< long >(val2);
9357 }
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 (arg1)->Start(arg2);
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 resultobj = SWIG_Py_Void();
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9372 PyObject *resultobj = 0;
9373 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 PyObject *swig_obj[1] ;
9377
9378 if (!args) SWIG_fail;
9379 swig_obj[0] = args;
9380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9383 }
9384 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 (arg1)->Pause();
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 resultobj = SWIG_Py_Void();
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9399 PyObject *resultobj = 0;
9400 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 PyObject *swig_obj[1] ;
9404
9405 if (!args) SWIG_fail;
9406 swig_obj[0] = args;
9407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9408 if (!SWIG_IsOK(res1)) {
9409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9410 }
9411 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 (arg1)->Resume();
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_Py_Void();
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9426 PyObject *resultobj = 0;
9427 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9428 long result;
9429 void *argp1 = 0 ;
9430 int res1 = 0 ;
9431 PyObject *swig_obj[1] ;
9432
9433 if (!args) SWIG_fail;
9434 swig_obj[0] = args;
9435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9436 if (!SWIG_IsOK(res1)) {
9437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9438 }
9439 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (long)((wxStopWatch const *)arg1)->Time();
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = SWIG_From_long(static_cast< long >(result));
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9454 PyObject *obj;
9455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9456 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9457 return SWIG_Py_Void();
9458 }
9459
9460 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9461 return SWIG_Python_InitShadowInstance(args);
9462 }
9463
9464 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9465 PyObject *resultobj = 0;
9466 int arg1 = (int) 9 ;
9467 int arg2 = (int) wxID_FILE1 ;
9468 wxFileHistory *result = 0 ;
9469 int val1 ;
9470 int ecode1 = 0 ;
9471 int val2 ;
9472 int ecode2 = 0 ;
9473 PyObject * obj0 = 0 ;
9474 PyObject * obj1 = 0 ;
9475 char * kwnames[] = {
9476 (char *) "maxFiles",(char *) "idBase", NULL
9477 };
9478
9479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9480 if (obj0) {
9481 ecode1 = SWIG_AsVal_int(obj0, &val1);
9482 if (!SWIG_IsOK(ecode1)) {
9483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9484 }
9485 arg1 = static_cast< int >(val1);
9486 }
9487 if (obj1) {
9488 ecode2 = SWIG_AsVal_int(obj1, &val2);
9489 if (!SWIG_IsOK(ecode2)) {
9490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9491 }
9492 arg2 = static_cast< int >(val2);
9493 }
9494 {
9495 PyThreadState* __tstate = wxPyBeginAllowThreads();
9496 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9497 wxPyEndAllowThreads(__tstate);
9498 if (PyErr_Occurred()) SWIG_fail;
9499 }
9500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9508 PyObject *resultobj = 0;
9509 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9510 void *argp1 = 0 ;
9511 int res1 = 0 ;
9512 PyObject *swig_obj[1] ;
9513
9514 if (!args) SWIG_fail;
9515 swig_obj[0] = args;
9516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9517 if (!SWIG_IsOK(res1)) {
9518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9519 }
9520 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9521 {
9522 PyThreadState* __tstate = wxPyBeginAllowThreads();
9523 delete arg1;
9524
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 resultobj = SWIG_Py_Void();
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj = 0;
9537 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9538 wxString *arg2 = 0 ;
9539 void *argp1 = 0 ;
9540 int res1 = 0 ;
9541 bool temp2 = false ;
9542 PyObject * obj0 = 0 ;
9543 PyObject * obj1 = 0 ;
9544 char * kwnames[] = {
9545 (char *) "self",(char *) "file", NULL
9546 };
9547
9548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9550 if (!SWIG_IsOK(res1)) {
9551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9552 }
9553 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9554 {
9555 arg2 = wxString_in_helper(obj1);
9556 if (arg2 == NULL) SWIG_fail;
9557 temp2 = true;
9558 }
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 (arg1)->AddFileToHistory((wxString const &)*arg2);
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 resultobj = SWIG_Py_Void();
9566 {
9567 if (temp2)
9568 delete arg2;
9569 }
9570 return resultobj;
9571 fail:
9572 {
9573 if (temp2)
9574 delete arg2;
9575 }
9576 return NULL;
9577 }
9578
9579
9580 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9581 PyObject *resultobj = 0;
9582 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9583 int arg2 ;
9584 void *argp1 = 0 ;
9585 int res1 = 0 ;
9586 int val2 ;
9587 int ecode2 = 0 ;
9588 PyObject * obj0 = 0 ;
9589 PyObject * obj1 = 0 ;
9590 char * kwnames[] = {
9591 (char *) "self",(char *) "i", NULL
9592 };
9593
9594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9596 if (!SWIG_IsOK(res1)) {
9597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9598 }
9599 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9600 ecode2 = SWIG_AsVal_int(obj1, &val2);
9601 if (!SWIG_IsOK(ecode2)) {
9602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9603 }
9604 arg2 = static_cast< int >(val2);
9605 {
9606 PyThreadState* __tstate = wxPyBeginAllowThreads();
9607 (arg1)->RemoveFileFromHistory(arg2);
9608 wxPyEndAllowThreads(__tstate);
9609 if (PyErr_Occurred()) SWIG_fail;
9610 }
9611 resultobj = SWIG_Py_Void();
9612 return resultobj;
9613 fail:
9614 return NULL;
9615 }
9616
9617
9618 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9619 PyObject *resultobj = 0;
9620 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9621 int result;
9622 void *argp1 = 0 ;
9623 int res1 = 0 ;
9624 PyObject *swig_obj[1] ;
9625
9626 if (!args) SWIG_fail;
9627 swig_obj[0] = args;
9628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9629 if (!SWIG_IsOK(res1)) {
9630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9631 }
9632 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9633 {
9634 PyThreadState* __tstate = wxPyBeginAllowThreads();
9635 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_From_int(static_cast< int >(result));
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9647 PyObject *resultobj = 0;
9648 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9649 wxMenu *arg2 = (wxMenu *) 0 ;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 void *argp2 = 0 ;
9653 int res2 = 0 ;
9654 PyObject * obj0 = 0 ;
9655 PyObject * obj1 = 0 ;
9656 char * kwnames[] = {
9657 (char *) "self",(char *) "menu", NULL
9658 };
9659
9660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9662 if (!SWIG_IsOK(res1)) {
9663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9664 }
9665 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9667 if (!SWIG_IsOK(res2)) {
9668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9669 }
9670 arg2 = reinterpret_cast< wxMenu * >(argp2);
9671 {
9672 PyThreadState* __tstate = wxPyBeginAllowThreads();
9673 (arg1)->UseMenu(arg2);
9674 wxPyEndAllowThreads(__tstate);
9675 if (PyErr_Occurred()) SWIG_fail;
9676 }
9677 resultobj = SWIG_Py_Void();
9678 return resultobj;
9679 fail:
9680 return NULL;
9681 }
9682
9683
9684 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9685 PyObject *resultobj = 0;
9686 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9687 wxMenu *arg2 = (wxMenu *) 0 ;
9688 void *argp1 = 0 ;
9689 int res1 = 0 ;
9690 void *argp2 = 0 ;
9691 int res2 = 0 ;
9692 PyObject * obj0 = 0 ;
9693 PyObject * obj1 = 0 ;
9694 char * kwnames[] = {
9695 (char *) "self",(char *) "menu", NULL
9696 };
9697
9698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9700 if (!SWIG_IsOK(res1)) {
9701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9702 }
9703 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9705 if (!SWIG_IsOK(res2)) {
9706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9707 }
9708 arg2 = reinterpret_cast< wxMenu * >(argp2);
9709 {
9710 PyThreadState* __tstate = wxPyBeginAllowThreads();
9711 (arg1)->RemoveMenu(arg2);
9712 wxPyEndAllowThreads(__tstate);
9713 if (PyErr_Occurred()) SWIG_fail;
9714 }
9715 resultobj = SWIG_Py_Void();
9716 return resultobj;
9717 fail:
9718 return NULL;
9719 }
9720
9721
9722 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj = 0;
9724 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9725 wxConfigBase *arg2 = 0 ;
9726 void *argp1 = 0 ;
9727 int res1 = 0 ;
9728 void *argp2 = 0 ;
9729 int res2 = 0 ;
9730 PyObject * obj0 = 0 ;
9731 PyObject * obj1 = 0 ;
9732 char * kwnames[] = {
9733 (char *) "self",(char *) "config", NULL
9734 };
9735
9736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9738 if (!SWIG_IsOK(res1)) {
9739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9740 }
9741 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9743 if (!SWIG_IsOK(res2)) {
9744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9745 }
9746 if (!argp2) {
9747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9748 }
9749 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9750 {
9751 PyThreadState* __tstate = wxPyBeginAllowThreads();
9752 (arg1)->Load(*arg2);
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 resultobj = SWIG_Py_Void();
9757 return resultobj;
9758 fail:
9759 return NULL;
9760 }
9761
9762
9763 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj = 0;
9765 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9766 wxConfigBase *arg2 = 0 ;
9767 void *argp1 = 0 ;
9768 int res1 = 0 ;
9769 void *argp2 = 0 ;
9770 int res2 = 0 ;
9771 PyObject * obj0 = 0 ;
9772 PyObject * obj1 = 0 ;
9773 char * kwnames[] = {
9774 (char *) "self",(char *) "config", NULL
9775 };
9776
9777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9779 if (!SWIG_IsOK(res1)) {
9780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9781 }
9782 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9784 if (!SWIG_IsOK(res2)) {
9785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9786 }
9787 if (!argp2) {
9788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9789 }
9790 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 (arg1)->Save(*arg2);
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 resultobj = SWIG_Py_Void();
9798 return resultobj;
9799 fail:
9800 return NULL;
9801 }
9802
9803
9804 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9805 PyObject *resultobj = 0;
9806 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9807 void *argp1 = 0 ;
9808 int res1 = 0 ;
9809 PyObject *swig_obj[1] ;
9810
9811 if (!args) SWIG_fail;
9812 swig_obj[0] = args;
9813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9814 if (!SWIG_IsOK(res1)) {
9815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9816 }
9817 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 (arg1)->AddFilesToMenu();
9821 wxPyEndAllowThreads(__tstate);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 resultobj = SWIG_Py_Void();
9825 return resultobj;
9826 fail:
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9832 PyObject *resultobj = 0;
9833 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9834 wxMenu *arg2 = (wxMenu *) 0 ;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 void *argp2 = 0 ;
9838 int res2 = 0 ;
9839 PyObject * obj0 = 0 ;
9840 PyObject * obj1 = 0 ;
9841 char * kwnames[] = {
9842 (char *) "self",(char *) "menu", NULL
9843 };
9844
9845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9847 if (!SWIG_IsOK(res1)) {
9848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9849 }
9850 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9851 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9852 if (!SWIG_IsOK(res2)) {
9853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9854 }
9855 arg2 = reinterpret_cast< wxMenu * >(argp2);
9856 {
9857 PyThreadState* __tstate = wxPyBeginAllowThreads();
9858 (arg1)->AddFilesToMenu(arg2);
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 resultobj = SWIG_Py_Void();
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj = 0;
9871 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9872 int arg2 ;
9873 wxString result;
9874 void *argp1 = 0 ;
9875 int res1 = 0 ;
9876 int val2 ;
9877 int ecode2 = 0 ;
9878 PyObject * obj0 = 0 ;
9879 PyObject * obj1 = 0 ;
9880 char * kwnames[] = {
9881 (char *) "self",(char *) "i", NULL
9882 };
9883
9884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9886 if (!SWIG_IsOK(res1)) {
9887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9888 }
9889 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9890 ecode2 = SWIG_AsVal_int(obj1, &val2);
9891 if (!SWIG_IsOK(ecode2)) {
9892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9893 }
9894 arg2 = static_cast< int >(val2);
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9898 wxPyEndAllowThreads(__tstate);
9899 if (PyErr_Occurred()) SWIG_fail;
9900 }
9901 {
9902 #if wxUSE_UNICODE
9903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9904 #else
9905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9906 #endif
9907 }
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9915 PyObject *resultobj = 0;
9916 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9917 int result;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 PyObject *swig_obj[1] ;
9921
9922 if (!args) SWIG_fail;
9923 swig_obj[0] = args;
9924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9925 if (!SWIG_IsOK(res1)) {
9926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9927 }
9928 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 result = (int)((wxFileHistory const *)arg1)->GetCount();
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 resultobj = SWIG_From_int(static_cast< int >(result));
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9943 PyObject *obj;
9944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9945 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9946 return SWIG_Py_Void();
9947 }
9948
9949 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9950 return SWIG_Python_InitShadowInstance(args);
9951 }
9952
9953 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj = 0;
9955 wxString *arg1 = 0 ;
9956 wxString const &arg2_defvalue = wxPyEmptyString ;
9957 wxString *arg2 = (wxString *) &arg2_defvalue ;
9958 wxSingleInstanceChecker *result = 0 ;
9959 bool temp1 = false ;
9960 bool temp2 = false ;
9961 PyObject * obj0 = 0 ;
9962 PyObject * obj1 = 0 ;
9963 char * kwnames[] = {
9964 (char *) "name",(char *) "path", NULL
9965 };
9966
9967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9968 {
9969 arg1 = wxString_in_helper(obj0);
9970 if (arg1 == NULL) SWIG_fail;
9971 temp1 = true;
9972 }
9973 if (obj1) {
9974 {
9975 arg2 = wxString_in_helper(obj1);
9976 if (arg2 == NULL) SWIG_fail;
9977 temp2 = true;
9978 }
9979 }
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9987 {
9988 if (temp1)
9989 delete arg1;
9990 }
9991 {
9992 if (temp2)
9993 delete arg2;
9994 }
9995 return resultobj;
9996 fail:
9997 {
9998 if (temp1)
9999 delete arg1;
10000 }
10001 {
10002 if (temp2)
10003 delete arg2;
10004 }
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10010 PyObject *resultobj = 0;
10011 wxSingleInstanceChecker *result = 0 ;
10012
10013 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *resultobj = 0;
10029 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10030 void *argp1 = 0 ;
10031 int res1 = 0 ;
10032 PyObject *swig_obj[1] ;
10033
10034 if (!args) SWIG_fail;
10035 swig_obj[0] = args;
10036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10037 if (!SWIG_IsOK(res1)) {
10038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10039 }
10040 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 delete arg1;
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 resultobj = SWIG_Py_Void();
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj = 0;
10057 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10058 wxString *arg2 = 0 ;
10059 wxString const &arg3_defvalue = wxPyEmptyString ;
10060 wxString *arg3 = (wxString *) &arg3_defvalue ;
10061 bool result;
10062 void *argp1 = 0 ;
10063 int res1 = 0 ;
10064 bool temp2 = false ;
10065 bool temp3 = false ;
10066 PyObject * obj0 = 0 ;
10067 PyObject * obj1 = 0 ;
10068 PyObject * obj2 = 0 ;
10069 char * kwnames[] = {
10070 (char *) "self",(char *) "name",(char *) "path", NULL
10071 };
10072
10073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10075 if (!SWIG_IsOK(res1)) {
10076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10077 }
10078 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10079 {
10080 arg2 = wxString_in_helper(obj1);
10081 if (arg2 == NULL) SWIG_fail;
10082 temp2 = true;
10083 }
10084 if (obj2) {
10085 {
10086 arg3 = wxString_in_helper(obj2);
10087 if (arg3 == NULL) SWIG_fail;
10088 temp3 = true;
10089 }
10090 }
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10094 wxPyEndAllowThreads(__tstate);
10095 if (PyErr_Occurred()) SWIG_fail;
10096 }
10097 {
10098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10099 }
10100 {
10101 if (temp2)
10102 delete arg2;
10103 }
10104 {
10105 if (temp3)
10106 delete arg3;
10107 }
10108 return resultobj;
10109 fail:
10110 {
10111 if (temp2)
10112 delete arg2;
10113 }
10114 {
10115 if (temp3)
10116 delete arg3;
10117 }
10118 return NULL;
10119 }
10120
10121
10122 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10123 PyObject *resultobj = 0;
10124 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10125 bool result;
10126 void *argp1 = 0 ;
10127 int res1 = 0 ;
10128 PyObject *swig_obj[1] ;
10129
10130 if (!args) SWIG_fail;
10131 swig_obj[0] = args;
10132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10133 if (!SWIG_IsOK(res1)) {
10134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10135 }
10136 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 {
10144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10145 }
10146 return resultobj;
10147 fail:
10148 return NULL;
10149 }
10150
10151
10152 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10153 PyObject *obj;
10154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10155 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10156 return SWIG_Py_Void();
10157 }
10158
10159 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10160 return SWIG_Python_InitShadowInstance(args);
10161 }
10162
10163 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10164 PyObject *resultobj = 0;
10165 wxPlatformInfo *result = 0 ;
10166
10167 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10168 {
10169 PyThreadState* __tstate = wxPyBeginAllowThreads();
10170 result = (wxPlatformInfo *)new wxPlatformInfo();
10171 wxPyEndAllowThreads(__tstate);
10172 if (PyErr_Occurred()) SWIG_fail;
10173 }
10174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10182 PyObject *resultobj = 0;
10183 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10184 wxPlatformInfo *arg2 = 0 ;
10185 bool result;
10186 void *argp1 = 0 ;
10187 int res1 = 0 ;
10188 void *argp2 = 0 ;
10189 int res2 = 0 ;
10190 PyObject * obj0 = 0 ;
10191 PyObject * obj1 = 0 ;
10192 char * kwnames[] = {
10193 (char *) "self",(char *) "t", NULL
10194 };
10195
10196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10198 if (!SWIG_IsOK(res1)) {
10199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10200 }
10201 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10203 if (!SWIG_IsOK(res2)) {
10204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10205 }
10206 if (!argp2) {
10207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10208 }
10209 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10213 wxPyEndAllowThreads(__tstate);
10214 if (PyErr_Occurred()) SWIG_fail;
10215 }
10216 {
10217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10218 }
10219 return resultobj;
10220 fail:
10221 return NULL;
10222 }
10223
10224
10225 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10226 PyObject *resultobj = 0;
10227 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10228 wxPlatformInfo *arg2 = 0 ;
10229 bool result;
10230 void *argp1 = 0 ;
10231 int res1 = 0 ;
10232 void *argp2 = 0 ;
10233 int res2 = 0 ;
10234 PyObject * obj0 = 0 ;
10235 PyObject * obj1 = 0 ;
10236 char * kwnames[] = {
10237 (char *) "self",(char *) "t", NULL
10238 };
10239
10240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10242 if (!SWIG_IsOK(res1)) {
10243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10244 }
10245 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10247 if (!SWIG_IsOK(res2)) {
10248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10249 }
10250 if (!argp2) {
10251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10252 }
10253 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 {
10261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10262 }
10263 return resultobj;
10264 fail:
10265 return NULL;
10266 }
10267
10268
10269 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10270 PyObject *resultobj = 0;
10271 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10272 int result;
10273 void *argp1 = 0 ;
10274 int res1 = 0 ;
10275 PyObject *swig_obj[1] ;
10276
10277 if (!args) SWIG_fail;
10278 swig_obj[0] = args;
10279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10280 if (!SWIG_IsOK(res1)) {
10281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10282 }
10283 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10284 {
10285 PyThreadState* __tstate = wxPyBeginAllowThreads();
10286 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10287 wxPyEndAllowThreads(__tstate);
10288 if (PyErr_Occurred()) SWIG_fail;
10289 }
10290 resultobj = SWIG_From_int(static_cast< int >(result));
10291 return resultobj;
10292 fail:
10293 return NULL;
10294 }
10295
10296
10297 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10298 PyObject *resultobj = 0;
10299 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10300 int result;
10301 void *argp1 = 0 ;
10302 int res1 = 0 ;
10303 PyObject *swig_obj[1] ;
10304
10305 if (!args) SWIG_fail;
10306 swig_obj[0] = args;
10307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10308 if (!SWIG_IsOK(res1)) {
10309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10310 }
10311 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10315 wxPyEndAllowThreads(__tstate);
10316 if (PyErr_Occurred()) SWIG_fail;
10317 }
10318 resultobj = SWIG_From_int(static_cast< int >(result));
10319 return resultobj;
10320 fail:
10321 return NULL;
10322 }
10323
10324
10325 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10326 PyObject *resultobj = 0;
10327 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10328 int arg2 ;
10329 int arg3 ;
10330 bool result;
10331 void *argp1 = 0 ;
10332 int res1 = 0 ;
10333 int val2 ;
10334 int ecode2 = 0 ;
10335 int val3 ;
10336 int ecode3 = 0 ;
10337 PyObject * obj0 = 0 ;
10338 PyObject * obj1 = 0 ;
10339 PyObject * obj2 = 0 ;
10340 char * kwnames[] = {
10341 (char *) "self",(char *) "major",(char *) "minor", NULL
10342 };
10343
10344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10346 if (!SWIG_IsOK(res1)) {
10347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10348 }
10349 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10350 ecode2 = SWIG_AsVal_int(obj1, &val2);
10351 if (!SWIG_IsOK(ecode2)) {
10352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10353 }
10354 arg2 = static_cast< int >(val2);
10355 ecode3 = SWIG_AsVal_int(obj2, &val3);
10356 if (!SWIG_IsOK(ecode3)) {
10357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10358 }
10359 arg3 = static_cast< int >(val3);
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 {
10367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10368 }
10369 return resultobj;
10370 fail:
10371 return NULL;
10372 }
10373
10374
10375 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10376 PyObject *resultobj = 0;
10377 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10378 int result;
10379 void *argp1 = 0 ;
10380 int res1 = 0 ;
10381 PyObject *swig_obj[1] ;
10382
10383 if (!args) SWIG_fail;
10384 swig_obj[0] = args;
10385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10386 if (!SWIG_IsOK(res1)) {
10387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10388 }
10389 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10390 {
10391 PyThreadState* __tstate = wxPyBeginAllowThreads();
10392 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10393 wxPyEndAllowThreads(__tstate);
10394 if (PyErr_Occurred()) SWIG_fail;
10395 }
10396 resultobj = SWIG_From_int(static_cast< int >(result));
10397 return resultobj;
10398 fail:
10399 return NULL;
10400 }
10401
10402
10403 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10404 PyObject *resultobj = 0;
10405 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10406 int result;
10407 void *argp1 = 0 ;
10408 int res1 = 0 ;
10409 PyObject *swig_obj[1] ;
10410
10411 if (!args) SWIG_fail;
10412 swig_obj[0] = args;
10413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10414 if (!SWIG_IsOK(res1)) {
10415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10416 }
10417 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10418 {
10419 PyThreadState* __tstate = wxPyBeginAllowThreads();
10420 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10421 wxPyEndAllowThreads(__tstate);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 resultobj = SWIG_From_int(static_cast< int >(result));
10425 return resultobj;
10426 fail:
10427 return NULL;
10428 }
10429
10430
10431 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10432 PyObject *resultobj = 0;
10433 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10434 int arg2 ;
10435 int arg3 ;
10436 bool result;
10437 void *argp1 = 0 ;
10438 int res1 = 0 ;
10439 int val2 ;
10440 int ecode2 = 0 ;
10441 int val3 ;
10442 int ecode3 = 0 ;
10443 PyObject * obj0 = 0 ;
10444 PyObject * obj1 = 0 ;
10445 PyObject * obj2 = 0 ;
10446 char * kwnames[] = {
10447 (char *) "self",(char *) "major",(char *) "minor", NULL
10448 };
10449
10450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10452 if (!SWIG_IsOK(res1)) {
10453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10454 }
10455 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10456 ecode2 = SWIG_AsVal_int(obj1, &val2);
10457 if (!SWIG_IsOK(ecode2)) {
10458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10459 }
10460 arg2 = static_cast< int >(val2);
10461 ecode3 = SWIG_AsVal_int(obj2, &val3);
10462 if (!SWIG_IsOK(ecode3)) {
10463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10464 }
10465 arg3 = static_cast< int >(val3);
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 {
10473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10474 }
10475 return resultobj;
10476 fail:
10477 return NULL;
10478 }
10479
10480
10481 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10482 PyObject *resultobj = 0;
10483 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10484 bool result;
10485 void *argp1 = 0 ;
10486 int res1 = 0 ;
10487 PyObject *swig_obj[1] ;
10488
10489 if (!args) SWIG_fail;
10490 swig_obj[0] = args;
10491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10492 if (!SWIG_IsOK(res1)) {
10493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10494 }
10495 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10496 {
10497 PyThreadState* __tstate = wxPyBeginAllowThreads();
10498 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10499 wxPyEndAllowThreads(__tstate);
10500 if (PyErr_Occurred()) SWIG_fail;
10501 }
10502 {
10503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10504 }
10505 return resultobj;
10506 fail:
10507 return NULL;
10508 }
10509
10510
10511 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10512 PyObject *resultobj = 0;
10513 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10514 wxOperatingSystemId result;
10515 void *argp1 = 0 ;
10516 int res1 = 0 ;
10517 PyObject *swig_obj[1] ;
10518
10519 if (!args) SWIG_fail;
10520 swig_obj[0] = args;
10521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10522 if (!SWIG_IsOK(res1)) {
10523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10524 }
10525 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 resultobj = SWIG_From_int(static_cast< int >(result));
10533 return resultobj;
10534 fail:
10535 return NULL;
10536 }
10537
10538
10539 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10540 PyObject *resultobj = 0;
10541 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10542 wxPortId result;
10543 void *argp1 = 0 ;
10544 int res1 = 0 ;
10545 PyObject *swig_obj[1] ;
10546
10547 if (!args) SWIG_fail;
10548 swig_obj[0] = args;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10552 }
10553 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 resultobj = SWIG_From_int(static_cast< int >(result));
10561 return resultobj;
10562 fail:
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *resultobj = 0;
10569 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10570 wxArchitecture result;
10571 void *argp1 = 0 ;
10572 int res1 = 0 ;
10573 PyObject *swig_obj[1] ;
10574
10575 if (!args) SWIG_fail;
10576 swig_obj[0] = args;
10577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10578 if (!SWIG_IsOK(res1)) {
10579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10580 }
10581 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 resultobj = SWIG_From_int(static_cast< int >(result));
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10596 PyObject *resultobj = 0;
10597 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10598 wxEndianness result;
10599 void *argp1 = 0 ;
10600 int res1 = 0 ;
10601 PyObject *swig_obj[1] ;
10602
10603 if (!args) SWIG_fail;
10604 swig_obj[0] = args;
10605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10606 if (!SWIG_IsOK(res1)) {
10607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10608 }
10609 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10610 {
10611 PyThreadState* __tstate = wxPyBeginAllowThreads();
10612 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10613 wxPyEndAllowThreads(__tstate);
10614 if (PyErr_Occurred()) SWIG_fail;
10615 }
10616 resultobj = SWIG_From_int(static_cast< int >(result));
10617 return resultobj;
10618 fail:
10619 return NULL;
10620 }
10621
10622
10623 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10624 PyObject *resultobj = 0;
10625 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10626 wxString result;
10627 void *argp1 = 0 ;
10628 int res1 = 0 ;
10629 PyObject *swig_obj[1] ;
10630
10631 if (!args) SWIG_fail;
10632 swig_obj[0] = args;
10633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10634 if (!SWIG_IsOK(res1)) {
10635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10636 }
10637 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10638 {
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10641 wxPyEndAllowThreads(__tstate);
10642 if (PyErr_Occurred()) SWIG_fail;
10643 }
10644 {
10645 #if wxUSE_UNICODE
10646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10647 #else
10648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10649 #endif
10650 }
10651 return resultobj;
10652 fail:
10653 return NULL;
10654 }
10655
10656
10657 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10658 PyObject *resultobj = 0;
10659 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10660 wxString result;
10661 void *argp1 = 0 ;
10662 int res1 = 0 ;
10663 PyObject *swig_obj[1] ;
10664
10665 if (!args) SWIG_fail;
10666 swig_obj[0] = args;
10667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10668 if (!SWIG_IsOK(res1)) {
10669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10670 }
10671 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10672 {
10673 PyThreadState* __tstate = wxPyBeginAllowThreads();
10674 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10675 wxPyEndAllowThreads(__tstate);
10676 if (PyErr_Occurred()) SWIG_fail;
10677 }
10678 {
10679 #if wxUSE_UNICODE
10680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10681 #else
10682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10683 #endif
10684 }
10685 return resultobj;
10686 fail:
10687 return NULL;
10688 }
10689
10690
10691 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10692 PyObject *resultobj = 0;
10693 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10694 wxString result;
10695 void *argp1 = 0 ;
10696 int res1 = 0 ;
10697 PyObject *swig_obj[1] ;
10698
10699 if (!args) SWIG_fail;
10700 swig_obj[0] = args;
10701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10702 if (!SWIG_IsOK(res1)) {
10703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10704 }
10705 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10706 {
10707 PyThreadState* __tstate = wxPyBeginAllowThreads();
10708 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10709 wxPyEndAllowThreads(__tstate);
10710 if (PyErr_Occurred()) SWIG_fail;
10711 }
10712 {
10713 #if wxUSE_UNICODE
10714 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10715 #else
10716 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10717 #endif
10718 }
10719 return resultobj;
10720 fail:
10721 return NULL;
10722 }
10723
10724
10725 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10726 PyObject *resultobj = 0;
10727 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10728 wxString result;
10729 void *argp1 = 0 ;
10730 int res1 = 0 ;
10731 PyObject *swig_obj[1] ;
10732
10733 if (!args) SWIG_fail;
10734 swig_obj[0] = args;
10735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10736 if (!SWIG_IsOK(res1)) {
10737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10738 }
10739 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 {
10747 #if wxUSE_UNICODE
10748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10749 #else
10750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10751 #endif
10752 }
10753 return resultobj;
10754 fail:
10755 return NULL;
10756 }
10757
10758
10759 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10760 PyObject *resultobj = 0;
10761 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10762 wxString result;
10763 void *argp1 = 0 ;
10764 int res1 = 0 ;
10765 PyObject *swig_obj[1] ;
10766
10767 if (!args) SWIG_fail;
10768 swig_obj[0] = args;
10769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10770 if (!SWIG_IsOK(res1)) {
10771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10772 }
10773 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10774 {
10775 PyThreadState* __tstate = wxPyBeginAllowThreads();
10776 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10777 wxPyEndAllowThreads(__tstate);
10778 if (PyErr_Occurred()) SWIG_fail;
10779 }
10780 {
10781 #if wxUSE_UNICODE
10782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10783 #else
10784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10785 #endif
10786 }
10787 return resultobj;
10788 fail:
10789 return NULL;
10790 }
10791
10792
10793 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10794 PyObject *resultobj = 0;
10795 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10796 wxString result;
10797 void *argp1 = 0 ;
10798 int res1 = 0 ;
10799 PyObject *swig_obj[1] ;
10800
10801 if (!args) SWIG_fail;
10802 swig_obj[0] = args;
10803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10804 if (!SWIG_IsOK(res1)) {
10805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10806 }
10807 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 {
10815 #if wxUSE_UNICODE
10816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10817 #else
10818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10819 #endif
10820 }
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10830 int arg2 ;
10831 int arg3 ;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 int val2 ;
10835 int ecode2 = 0 ;
10836 int val3 ;
10837 int ecode3 = 0 ;
10838 PyObject * obj0 = 0 ;
10839 PyObject * obj1 = 0 ;
10840 PyObject * obj2 = 0 ;
10841 char * kwnames[] = {
10842 (char *) "self",(char *) "major",(char *) "minor", NULL
10843 };
10844
10845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10847 if (!SWIG_IsOK(res1)) {
10848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10849 }
10850 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10851 ecode2 = SWIG_AsVal_int(obj1, &val2);
10852 if (!SWIG_IsOK(ecode2)) {
10853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10854 }
10855 arg2 = static_cast< int >(val2);
10856 ecode3 = SWIG_AsVal_int(obj2, &val3);
10857 if (!SWIG_IsOK(ecode3)) {
10858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10859 }
10860 arg3 = static_cast< int >(val3);
10861 {
10862 PyThreadState* __tstate = wxPyBeginAllowThreads();
10863 (arg1)->SetOSVersion(arg2,arg3);
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_Py_Void();
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = 0;
10876 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10877 int arg2 ;
10878 int arg3 ;
10879 void *argp1 = 0 ;
10880 int res1 = 0 ;
10881 int val2 ;
10882 int ecode2 = 0 ;
10883 int val3 ;
10884 int ecode3 = 0 ;
10885 PyObject * obj0 = 0 ;
10886 PyObject * obj1 = 0 ;
10887 PyObject * obj2 = 0 ;
10888 char * kwnames[] = {
10889 (char *) "self",(char *) "major",(char *) "minor", NULL
10890 };
10891
10892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10894 if (!SWIG_IsOK(res1)) {
10895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10896 }
10897 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10898 ecode2 = SWIG_AsVal_int(obj1, &val2);
10899 if (!SWIG_IsOK(ecode2)) {
10900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10901 }
10902 arg2 = static_cast< int >(val2);
10903 ecode3 = SWIG_AsVal_int(obj2, &val3);
10904 if (!SWIG_IsOK(ecode3)) {
10905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10906 }
10907 arg3 = static_cast< int >(val3);
10908 {
10909 PyThreadState* __tstate = wxPyBeginAllowThreads();
10910 (arg1)->SetToolkitVersion(arg2,arg3);
10911 wxPyEndAllowThreads(__tstate);
10912 if (PyErr_Occurred()) SWIG_fail;
10913 }
10914 resultobj = SWIG_Py_Void();
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj = 0;
10923 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10924 wxOperatingSystemId arg2 ;
10925 void *argp1 = 0 ;
10926 int res1 = 0 ;
10927 int val2 ;
10928 int ecode2 = 0 ;
10929 PyObject * obj0 = 0 ;
10930 PyObject * obj1 = 0 ;
10931 char * kwnames[] = {
10932 (char *) "self",(char *) "n", NULL
10933 };
10934
10935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10937 if (!SWIG_IsOK(res1)) {
10938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10939 }
10940 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10941 ecode2 = SWIG_AsVal_int(obj1, &val2);
10942 if (!SWIG_IsOK(ecode2)) {
10943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10944 }
10945 arg2 = static_cast< wxOperatingSystemId >(val2);
10946 {
10947 PyThreadState* __tstate = wxPyBeginAllowThreads();
10948 (arg1)->SetOperatingSystemId(arg2);
10949 wxPyEndAllowThreads(__tstate);
10950 if (PyErr_Occurred()) SWIG_fail;
10951 }
10952 resultobj = SWIG_Py_Void();
10953 return resultobj;
10954 fail:
10955 return NULL;
10956 }
10957
10958
10959 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10960 PyObject *resultobj = 0;
10961 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10962 wxPortId arg2 ;
10963 void *argp1 = 0 ;
10964 int res1 = 0 ;
10965 int val2 ;
10966 int ecode2 = 0 ;
10967 PyObject * obj0 = 0 ;
10968 PyObject * obj1 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "self",(char *) "n", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10975 if (!SWIG_IsOK(res1)) {
10976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10977 }
10978 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10979 ecode2 = SWIG_AsVal_int(obj1, &val2);
10980 if (!SWIG_IsOK(ecode2)) {
10981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10982 }
10983 arg2 = static_cast< wxPortId >(val2);
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 (arg1)->SetPortId(arg2);
10987 wxPyEndAllowThreads(__tstate);
10988 if (PyErr_Occurred()) SWIG_fail;
10989 }
10990 resultobj = SWIG_Py_Void();
10991 return resultobj;
10992 fail:
10993 return NULL;
10994 }
10995
10996
10997 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10998 PyObject *resultobj = 0;
10999 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11000 wxArchitecture arg2 ;
11001 void *argp1 = 0 ;
11002 int res1 = 0 ;
11003 int val2 ;
11004 int ecode2 = 0 ;
11005 PyObject * obj0 = 0 ;
11006 PyObject * obj1 = 0 ;
11007 char * kwnames[] = {
11008 (char *) "self",(char *) "n", NULL
11009 };
11010
11011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
11012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11013 if (!SWIG_IsOK(res1)) {
11014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11015 }
11016 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11017 ecode2 = SWIG_AsVal_int(obj1, &val2);
11018 if (!SWIG_IsOK(ecode2)) {
11019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11020 }
11021 arg2 = static_cast< wxArchitecture >(val2);
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 (arg1)->SetArchitecture(arg2);
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 resultobj = SWIG_Py_Void();
11029 return resultobj;
11030 fail:
11031 return NULL;
11032 }
11033
11034
11035 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11036 PyObject *resultobj = 0;
11037 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11038 wxEndianness arg2 ;
11039 void *argp1 = 0 ;
11040 int res1 = 0 ;
11041 int val2 ;
11042 int ecode2 = 0 ;
11043 PyObject * obj0 = 0 ;
11044 PyObject * obj1 = 0 ;
11045 char * kwnames[] = {
11046 (char *) "self",(char *) "n", NULL
11047 };
11048
11049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11051 if (!SWIG_IsOK(res1)) {
11052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11053 }
11054 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11055 ecode2 = SWIG_AsVal_int(obj1, &val2);
11056 if (!SWIG_IsOK(ecode2)) {
11057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11058 }
11059 arg2 = static_cast< wxEndianness >(val2);
11060 {
11061 PyThreadState* __tstate = wxPyBeginAllowThreads();
11062 (arg1)->SetEndianness(arg2);
11063 wxPyEndAllowThreads(__tstate);
11064 if (PyErr_Occurred()) SWIG_fail;
11065 }
11066 resultobj = SWIG_Py_Void();
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11074 PyObject *resultobj = 0;
11075 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11076 bool result;
11077 void *argp1 = 0 ;
11078 int res1 = 0 ;
11079 PyObject *swig_obj[1] ;
11080
11081 if (!args) SWIG_fail;
11082 swig_obj[0] = args;
11083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11084 if (!SWIG_IsOK(res1)) {
11085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11086 }
11087 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11091 wxPyEndAllowThreads(__tstate);
11092 if (PyErr_Occurred()) SWIG_fail;
11093 }
11094 {
11095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11096 }
11097 return resultobj;
11098 fail:
11099 return NULL;
11100 }
11101
11102
11103 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11104 PyObject *obj;
11105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11106 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11107 return SWIG_Py_Void();
11108 }
11109
11110 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11111 return SWIG_Python_InitShadowInstance(args);
11112 }
11113
11114 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11115 PyObject *resultobj = 0;
11116 wxWindow *arg1 = (wxWindow *) 0 ;
11117 wxDC *arg2 = 0 ;
11118 bool result;
11119 void *argp1 = 0 ;
11120 int res1 = 0 ;
11121 void *argp2 = 0 ;
11122 int res2 = 0 ;
11123 PyObject * obj0 = 0 ;
11124 PyObject * obj1 = 0 ;
11125 char * kwnames[] = {
11126 (char *) "window",(char *) "dc", NULL
11127 };
11128
11129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11131 if (!SWIG_IsOK(res1)) {
11132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11133 }
11134 arg1 = reinterpret_cast< wxWindow * >(argp1);
11135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11136 if (!SWIG_IsOK(res2)) {
11137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11138 }
11139 if (!argp2) {
11140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11141 }
11142 arg2 = reinterpret_cast< wxDC * >(argp2);
11143 {
11144 PyThreadState* __tstate = wxPyBeginAllowThreads();
11145 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11146 wxPyEndAllowThreads(__tstate);
11147 if (PyErr_Occurred()) SWIG_fail;
11148 }
11149 {
11150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11151 }
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11159 PyObject *resultobj = 0;
11160 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11161 void *argp1 = 0 ;
11162 int res1 = 0 ;
11163 PyObject *swig_obj[1] ;
11164
11165 if (!args) SWIG_fail;
11166 swig_obj[0] = args;
11167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11168 if (!SWIG_IsOK(res1)) {
11169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11170 }
11171 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 delete arg1;
11175
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 resultobj = SWIG_Py_Void();
11180 return resultobj;
11181 fail:
11182 return NULL;
11183 }
11184
11185
11186 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11187 PyObject *resultobj = 0;
11188 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11189 wxString result;
11190 void *argp1 = 0 ;
11191 int res1 = 0 ;
11192 PyObject *swig_obj[1] ;
11193
11194 if (!args) SWIG_fail;
11195 swig_obj[0] = args;
11196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11197 if (!SWIG_IsOK(res1)) {
11198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11199 }
11200 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11201 {
11202 PyThreadState* __tstate = wxPyBeginAllowThreads();
11203 result = (arg1)->GetTip();
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 {
11208 #if wxUSE_UNICODE
11209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11210 #else
11211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11212 #endif
11213 }
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11221 PyObject *resultobj = 0;
11222 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11223 size_t result;
11224 void *argp1 = 0 ;
11225 int res1 = 0 ;
11226 PyObject *swig_obj[1] ;
11227
11228 if (!args) SWIG_fail;
11229 swig_obj[0] = args;
11230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11231 if (!SWIG_IsOK(res1)) {
11232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11233 }
11234 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11235 {
11236 PyThreadState* __tstate = wxPyBeginAllowThreads();
11237 result = (size_t)(arg1)->GetCurrentTip();
11238 wxPyEndAllowThreads(__tstate);
11239 if (PyErr_Occurred()) SWIG_fail;
11240 }
11241 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj = 0;
11250 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11251 wxString *arg2 = 0 ;
11252 wxString result;
11253 void *argp1 = 0 ;
11254 int res1 = 0 ;
11255 bool temp2 = false ;
11256 PyObject * obj0 = 0 ;
11257 PyObject * obj1 = 0 ;
11258 char * kwnames[] = {
11259 (char *) "self",(char *) "tip", NULL
11260 };
11261
11262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11264 if (!SWIG_IsOK(res1)) {
11265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11266 }
11267 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11268 {
11269 arg2 = wxString_in_helper(obj1);
11270 if (arg2 == NULL) SWIG_fail;
11271 temp2 = true;
11272 }
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 {
11280 #if wxUSE_UNICODE
11281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11282 #else
11283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11284 #endif
11285 }
11286 {
11287 if (temp2)
11288 delete arg2;
11289 }
11290 return resultobj;
11291 fail:
11292 {
11293 if (temp2)
11294 delete arg2;
11295 }
11296 return NULL;
11297 }
11298
11299
11300 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11301 PyObject *obj;
11302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11303 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11304 return SWIG_Py_Void();
11305 }
11306
11307 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11308 PyObject *resultobj = 0;
11309 size_t arg1 ;
11310 wxPyTipProvider *result = 0 ;
11311 size_t val1 ;
11312 int ecode1 = 0 ;
11313 PyObject * obj0 = 0 ;
11314 char * kwnames[] = {
11315 (char *) "currentTip", NULL
11316 };
11317
11318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11319 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11320 if (!SWIG_IsOK(ecode1)) {
11321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11322 }
11323 arg1 = static_cast< size_t >(val1);
11324 {
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj = 0;
11339 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11340 PyObject *arg2 = (PyObject *) 0 ;
11341 PyObject *arg3 = (PyObject *) 0 ;
11342 void *argp1 = 0 ;
11343 int res1 = 0 ;
11344 PyObject * obj0 = 0 ;
11345 PyObject * obj1 = 0 ;
11346 PyObject * obj2 = 0 ;
11347 char * kwnames[] = {
11348 (char *) "self",(char *) "self",(char *) "_class", NULL
11349 };
11350
11351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11353 if (!SWIG_IsOK(res1)) {
11354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11355 }
11356 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11357 arg2 = obj1;
11358 arg3 = obj2;
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 (arg1)->_setCallbackInfo(arg2,arg3);
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 resultobj = SWIG_Py_Void();
11366 return resultobj;
11367 fail:
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11373 PyObject *obj;
11374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11375 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11376 return SWIG_Py_Void();
11377 }
11378
11379 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11380 return SWIG_Python_InitShadowInstance(args);
11381 }
11382
11383 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11384 PyObject *resultobj = 0;
11385 wxWindow *arg1 = (wxWindow *) 0 ;
11386 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11387 bool arg3 = (bool) true ;
11388 bool result;
11389 void *argp1 = 0 ;
11390 int res1 = 0 ;
11391 void *argp2 = 0 ;
11392 int res2 = 0 ;
11393 bool val3 ;
11394 int ecode3 = 0 ;
11395 PyObject * obj0 = 0 ;
11396 PyObject * obj1 = 0 ;
11397 PyObject * obj2 = 0 ;
11398 char * kwnames[] = {
11399 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11400 };
11401
11402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11404 if (!SWIG_IsOK(res1)) {
11405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11406 }
11407 arg1 = reinterpret_cast< wxWindow * >(argp1);
11408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11409 if (!SWIG_IsOK(res2)) {
11410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11411 }
11412 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11413 if (obj2) {
11414 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11415 if (!SWIG_IsOK(ecode3)) {
11416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11417 }
11418 arg3 = static_cast< bool >(val3);
11419 }
11420 {
11421 if (!wxPyCheckForApp()) SWIG_fail;
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 result = (bool)wxShowTip(arg1,arg2,arg3);
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 {
11428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11429 }
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11437 PyObject *resultobj = 0;
11438 wxString *arg1 = 0 ;
11439 size_t arg2 ;
11440 wxTipProvider *result = 0 ;
11441 bool temp1 = false ;
11442 size_t val2 ;
11443 int ecode2 = 0 ;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 char * kwnames[] = {
11447 (char *) "filename",(char *) "currentTip", NULL
11448 };
11449
11450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11451 {
11452 arg1 = wxString_in_helper(obj0);
11453 if (arg1 == NULL) SWIG_fail;
11454 temp1 = true;
11455 }
11456 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11457 if (!SWIG_IsOK(ecode2)) {
11458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11459 }
11460 arg2 = static_cast< size_t >(val2);
11461 {
11462 if (!wxPyCheckForApp()) SWIG_fail;
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11469 {
11470 if (temp1)
11471 delete arg1;
11472 }
11473 return resultobj;
11474 fail:
11475 {
11476 if (temp1)
11477 delete arg1;
11478 }
11479 return NULL;
11480 }
11481
11482
11483 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11484 PyObject *resultobj = 0;
11485 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11486 int arg2 = (int) wxID_ANY ;
11487 wxPyTimer *result = 0 ;
11488 void *argp1 = 0 ;
11489 int res1 = 0 ;
11490 int val2 ;
11491 int ecode2 = 0 ;
11492 PyObject * obj0 = 0 ;
11493 PyObject * obj1 = 0 ;
11494 char * kwnames[] = {
11495 (char *) "owner",(char *) "id", NULL
11496 };
11497
11498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11499 if (obj0) {
11500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11501 if (!SWIG_IsOK(res1)) {
11502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11503 }
11504 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11505 }
11506 if (obj1) {
11507 ecode2 = SWIG_AsVal_int(obj1, &val2);
11508 if (!SWIG_IsOK(ecode2)) {
11509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11510 }
11511 arg2 = static_cast< int >(val2);
11512 }
11513 {
11514 if (!wxPyCheckForApp()) SWIG_fail;
11515 PyThreadState* __tstate = wxPyBeginAllowThreads();
11516 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11521 return resultobj;
11522 fail:
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11528 PyObject *resultobj = 0;
11529 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11530 void *argp1 = 0 ;
11531 int res1 = 0 ;
11532 PyObject *swig_obj[1] ;
11533
11534 if (!args) SWIG_fail;
11535 swig_obj[0] = args;
11536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11537 if (!SWIG_IsOK(res1)) {
11538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11539 }
11540 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 delete arg1;
11544
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 resultobj = SWIG_Py_Void();
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj = 0;
11557 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11558 PyObject *arg2 = (PyObject *) 0 ;
11559 PyObject *arg3 = (PyObject *) 0 ;
11560 int arg4 = (int) 0 ;
11561 void *argp1 = 0 ;
11562 int res1 = 0 ;
11563 int val4 ;
11564 int ecode4 = 0 ;
11565 PyObject * obj0 = 0 ;
11566 PyObject * obj1 = 0 ;
11567 PyObject * obj2 = 0 ;
11568 PyObject * obj3 = 0 ;
11569 char * kwnames[] = {
11570 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11571 };
11572
11573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11575 if (!SWIG_IsOK(res1)) {
11576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11577 }
11578 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11579 arg2 = obj1;
11580 arg3 = obj2;
11581 if (obj3) {
11582 ecode4 = SWIG_AsVal_int(obj3, &val4);
11583 if (!SWIG_IsOK(ecode4)) {
11584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11585 }
11586 arg4 = static_cast< int >(val4);
11587 }
11588 {
11589 PyThreadState* __tstate = wxPyBeginAllowThreads();
11590 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11591 wxPyEndAllowThreads(__tstate);
11592 if (PyErr_Occurred()) SWIG_fail;
11593 }
11594 resultobj = SWIG_Py_Void();
11595 return resultobj;
11596 fail:
11597 return NULL;
11598 }
11599
11600
11601 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11602 PyObject *resultobj = 0;
11603 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11604 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11605 int arg3 = (int) wxID_ANY ;
11606 void *argp1 = 0 ;
11607 int res1 = 0 ;
11608 void *argp2 = 0 ;
11609 int res2 = 0 ;
11610 int val3 ;
11611 int ecode3 = 0 ;
11612 PyObject * obj0 = 0 ;
11613 PyObject * obj1 = 0 ;
11614 PyObject * obj2 = 0 ;
11615 char * kwnames[] = {
11616 (char *) "self",(char *) "owner",(char *) "id", NULL
11617 };
11618
11619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11621 if (!SWIG_IsOK(res1)) {
11622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11623 }
11624 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11626 if (!SWIG_IsOK(res2)) {
11627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11628 }
11629 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11630 if (obj2) {
11631 ecode3 = SWIG_AsVal_int(obj2, &val3);
11632 if (!SWIG_IsOK(ecode3)) {
11633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11634 }
11635 arg3 = static_cast< int >(val3);
11636 }
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 (arg1)->SetOwner(arg2,arg3);
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 resultobj = SWIG_Py_Void();
11644 return resultobj;
11645 fail:
11646 return NULL;
11647 }
11648
11649
11650 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11651 PyObject *resultobj = 0;
11652 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11653 wxEvtHandler *result = 0 ;
11654 void *argp1 = 0 ;
11655 int res1 = 0 ;
11656 PyObject *swig_obj[1] ;
11657
11658 if (!args) SWIG_fail;
11659 swig_obj[0] = args;
11660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11661 if (!SWIG_IsOK(res1)) {
11662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11663 }
11664 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (wxEvtHandler *)(arg1)->GetOwner();
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 resultobj = wxPyMake_wxObject(result, 0);
11673 }
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11681 PyObject *resultobj = 0;
11682 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11683 int arg2 = (int) -1 ;
11684 bool arg3 = (bool) false ;
11685 bool result;
11686 void *argp1 = 0 ;
11687 int res1 = 0 ;
11688 int val2 ;
11689 int ecode2 = 0 ;
11690 bool val3 ;
11691 int ecode3 = 0 ;
11692 PyObject * obj0 = 0 ;
11693 PyObject * obj1 = 0 ;
11694 PyObject * obj2 = 0 ;
11695 char * kwnames[] = {
11696 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11697 };
11698
11699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11701 if (!SWIG_IsOK(res1)) {
11702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11703 }
11704 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11705 if (obj1) {
11706 ecode2 = SWIG_AsVal_int(obj1, &val2);
11707 if (!SWIG_IsOK(ecode2)) {
11708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11709 }
11710 arg2 = static_cast< int >(val2);
11711 }
11712 if (obj2) {
11713 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11714 if (!SWIG_IsOK(ecode3)) {
11715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11716 }
11717 arg3 = static_cast< bool >(val3);
11718 }
11719 {
11720 PyThreadState* __tstate = wxPyBeginAllowThreads();
11721 result = (bool)(arg1)->Start(arg2,arg3);
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 {
11726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11727 }
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 PyObject *resultobj = 0;
11736 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 PyObject *swig_obj[1] ;
11740
11741 if (!args) SWIG_fail;
11742 swig_obj[0] = args;
11743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11746 }
11747 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 (arg1)->Stop();
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 resultobj = SWIG_Py_Void();
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11762 PyObject *resultobj = 0;
11763 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11764 void *argp1 = 0 ;
11765 int res1 = 0 ;
11766 PyObject *swig_obj[1] ;
11767
11768 if (!args) SWIG_fail;
11769 swig_obj[0] = args;
11770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11771 if (!SWIG_IsOK(res1)) {
11772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11773 }
11774 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 (arg1)->Notify();
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 resultobj = SWIG_Py_Void();
11782 return resultobj;
11783 fail:
11784 return NULL;
11785 }
11786
11787
11788 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11789 PyObject *resultobj = 0;
11790 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11791 bool result;
11792 void *argp1 = 0 ;
11793 int res1 = 0 ;
11794 PyObject *swig_obj[1] ;
11795
11796 if (!args) SWIG_fail;
11797 swig_obj[0] = args;
11798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11799 if (!SWIG_IsOK(res1)) {
11800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11801 }
11802 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 {
11810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11811 }
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11819 PyObject *resultobj = 0;
11820 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11821 int result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 PyObject *swig_obj[1] ;
11825
11826 if (!args) SWIG_fail;
11827 swig_obj[0] = args;
11828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11831 }
11832 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11836 wxPyEndAllowThreads(__tstate);
11837 if (PyErr_Occurred()) SWIG_fail;
11838 }
11839 resultobj = SWIG_From_int(static_cast< int >(result));
11840 return resultobj;
11841 fail:
11842 return NULL;
11843 }
11844
11845
11846 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11847 PyObject *resultobj = 0;
11848 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11849 int result;
11850 void *argp1 = 0 ;
11851 int res1 = 0 ;
11852 PyObject *swig_obj[1] ;
11853
11854 if (!args) SWIG_fail;
11855 swig_obj[0] = args;
11856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11857 if (!SWIG_IsOK(res1)) {
11858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11859 }
11860 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11861 {
11862 PyThreadState* __tstate = wxPyBeginAllowThreads();
11863 result = (int)((wxPyTimer const *)arg1)->GetId();
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 resultobj = SWIG_From_int(static_cast< int >(result));
11868 return resultobj;
11869 fail:
11870 return NULL;
11871 }
11872
11873
11874 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11875 PyObject *resultobj = 0;
11876 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11877 bool result;
11878 void *argp1 = 0 ;
11879 int res1 = 0 ;
11880 PyObject *swig_obj[1] ;
11881
11882 if (!args) SWIG_fail;
11883 swig_obj[0] = args;
11884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11885 if (!SWIG_IsOK(res1)) {
11886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11887 }
11888 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 {
11896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11897 }
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11905 PyObject *obj;
11906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11907 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11908 return SWIG_Py_Void();
11909 }
11910
11911 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11912 return SWIG_Python_InitShadowInstance(args);
11913 }
11914
11915 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11916 PyObject *resultobj = 0;
11917 int arg1 = (int) 0 ;
11918 int arg2 = (int) 0 ;
11919 wxTimerEvent *result = 0 ;
11920 int val1 ;
11921 int ecode1 = 0 ;
11922 int val2 ;
11923 int ecode2 = 0 ;
11924 PyObject * obj0 = 0 ;
11925 PyObject * obj1 = 0 ;
11926 char * kwnames[] = {
11927 (char *) "timerid",(char *) "interval", NULL
11928 };
11929
11930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11931 if (obj0) {
11932 ecode1 = SWIG_AsVal_int(obj0, &val1);
11933 if (!SWIG_IsOK(ecode1)) {
11934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11935 }
11936 arg1 = static_cast< int >(val1);
11937 }
11938 if (obj1) {
11939 ecode2 = SWIG_AsVal_int(obj1, &val2);
11940 if (!SWIG_IsOK(ecode2)) {
11941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11942 }
11943 arg2 = static_cast< int >(val2);
11944 }
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11952 return resultobj;
11953 fail:
11954 return NULL;
11955 }
11956
11957
11958 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11959 PyObject *resultobj = 0;
11960 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11961 int result;
11962 void *argp1 = 0 ;
11963 int res1 = 0 ;
11964 PyObject *swig_obj[1] ;
11965
11966 if (!args) SWIG_fail;
11967 swig_obj[0] = args;
11968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11969 if (!SWIG_IsOK(res1)) {
11970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11971 }
11972 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 resultobj = SWIG_From_int(static_cast< int >(result));
11980 return resultobj;
11981 fail:
11982 return NULL;
11983 }
11984
11985
11986 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11987 PyObject *obj;
11988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11989 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11990 return SWIG_Py_Void();
11991 }
11992
11993 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11994 return SWIG_Python_InitShadowInstance(args);
11995 }
11996
11997 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11998 PyObject *resultobj = 0;
11999 wxTimer *arg1 = 0 ;
12000 wxTimerRunner *result = 0 ;
12001 void *argp1 = 0 ;
12002 int res1 = 0 ;
12003
12004 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
12005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12006 if (!SWIG_IsOK(res1)) {
12007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12008 }
12009 if (!argp1) {
12010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12011 }
12012 arg1 = reinterpret_cast< wxTimer * >(argp1);
12013 {
12014 if (!wxPyCheckForApp()) SWIG_fail;
12015 PyThreadState* __tstate = wxPyBeginAllowThreads();
12016 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12028 PyObject *resultobj = 0;
12029 wxTimer *arg1 = 0 ;
12030 int arg2 ;
12031 bool arg3 = (bool) false ;
12032 wxTimerRunner *result = 0 ;
12033 void *argp1 = 0 ;
12034 int res1 = 0 ;
12035 int val2 ;
12036 int ecode2 = 0 ;
12037 bool val3 ;
12038 int ecode3 = 0 ;
12039
12040 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12042 if (!SWIG_IsOK(res1)) {
12043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12044 }
12045 if (!argp1) {
12046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12047 }
12048 arg1 = reinterpret_cast< wxTimer * >(argp1);
12049 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12050 if (!SWIG_IsOK(ecode2)) {
12051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12052 }
12053 arg2 = static_cast< int >(val2);
12054 if (swig_obj[2]) {
12055 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12056 if (!SWIG_IsOK(ecode3)) {
12057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12058 }
12059 arg3 = static_cast< bool >(val3);
12060 }
12061 {
12062 if (!wxPyCheckForApp()) SWIG_fail;
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12065 wxPyEndAllowThreads(__tstate);
12066 if (PyErr_Occurred()) SWIG_fail;
12067 }
12068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12069 return resultobj;
12070 fail:
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12076 int argc;
12077 PyObject *argv[4];
12078
12079 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12080 --argc;
12081 if (argc == 1) {
12082 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12083 }
12084 if ((argc >= 2) && (argc <= 3)) {
12085 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12086 }
12087
12088 fail:
12089 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 PyObject *resultobj = 0;
12096 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12097 void *argp1 = 0 ;
12098 int res1 = 0 ;
12099 PyObject *swig_obj[1] ;
12100
12101 if (!args) SWIG_fail;
12102 swig_obj[0] = args;
12103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12104 if (!SWIG_IsOK(res1)) {
12105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12106 }
12107 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 delete arg1;
12111
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 resultobj = SWIG_Py_Void();
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12123 PyObject *resultobj = 0;
12124 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12125 int arg2 ;
12126 bool arg3 = (bool) false ;
12127 void *argp1 = 0 ;
12128 int res1 = 0 ;
12129 int val2 ;
12130 int ecode2 = 0 ;
12131 bool val3 ;
12132 int ecode3 = 0 ;
12133 PyObject * obj0 = 0 ;
12134 PyObject * obj1 = 0 ;
12135 PyObject * obj2 = 0 ;
12136 char * kwnames[] = {
12137 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12138 };
12139
12140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12142 if (!SWIG_IsOK(res1)) {
12143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12144 }
12145 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12146 ecode2 = SWIG_AsVal_int(obj1, &val2);
12147 if (!SWIG_IsOK(ecode2)) {
12148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12149 }
12150 arg2 = static_cast< int >(val2);
12151 if (obj2) {
12152 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12153 if (!SWIG_IsOK(ecode3)) {
12154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12155 }
12156 arg3 = static_cast< bool >(val3);
12157 }
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 (arg1)->Start(arg2,arg3);
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_Py_Void();
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *obj;
12173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12174 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12175 return SWIG_Py_Void();
12176 }
12177
12178 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12179 return SWIG_Python_InitShadowInstance(args);
12180 }
12181
12182 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12183 PyObject *resultobj = 0;
12184 wxLog *result = 0 ;
12185
12186 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (wxLog *)new wxLog();
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201 PyObject *resultobj = 0;
12202 wxLog *arg1 = (wxLog *) 0 ;
12203 void *argp1 = 0 ;
12204 int res1 = 0 ;
12205 PyObject *swig_obj[1] ;
12206
12207 if (!args) SWIG_fail;
12208 swig_obj[0] = args;
12209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12210 if (!SWIG_IsOK(res1)) {
12211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12212 }
12213 arg1 = reinterpret_cast< wxLog * >(argp1);
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 delete arg1;
12217
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 resultobj = SWIG_Py_Void();
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12229 PyObject *resultobj = 0;
12230 bool result;
12231
12232 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12233 {
12234 PyThreadState* __tstate = wxPyBeginAllowThreads();
12235 result = (bool)wxLog::IsEnabled();
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 {
12240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12241 }
12242 return resultobj;
12243 fail:
12244 return NULL;
12245 }
12246
12247
12248 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12249 PyObject *resultobj = 0;
12250 bool arg1 = (bool) true ;
12251 bool result;
12252 bool val1 ;
12253 int ecode1 = 0 ;
12254 PyObject * obj0 = 0 ;
12255 char * kwnames[] = {
12256 (char *) "doIt", NULL
12257 };
12258
12259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12260 if (obj0) {
12261 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12262 if (!SWIG_IsOK(ecode1)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12264 }
12265 arg1 = static_cast< bool >(val1);
12266 }
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (bool)wxLog::EnableLogging(arg1);
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 {
12274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12275 }
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12283 PyObject *resultobj = 0;
12284 wxLogLevel arg1 ;
12285 wxChar *arg2 = (wxChar *) 0 ;
12286 time_t arg3 ;
12287 unsigned long val1 ;
12288 int ecode1 = 0 ;
12289 void *argp2 = 0 ;
12290 int res2 = 0 ;
12291 unsigned int val3 ;
12292 int ecode3 = 0 ;
12293 PyObject * obj0 = 0 ;
12294 PyObject * obj1 = 0 ;
12295 PyObject * obj2 = 0 ;
12296 char * kwnames[] = {
12297 (char *) "level",(char *) "szString",(char *) "t", NULL
12298 };
12299
12300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12301 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12302 if (!SWIG_IsOK(ecode1)) {
12303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12304 }
12305 arg1 = static_cast< wxLogLevel >(val1);
12306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12307 if (!SWIG_IsOK(res2)) {
12308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12309 }
12310 arg2 = reinterpret_cast< wxChar * >(argp2);
12311 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12312 if (!SWIG_IsOK(ecode3)) {
12313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12314 }
12315 arg3 = static_cast< time_t >(val3);
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 resultobj = SWIG_Py_Void();
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12330 PyObject *resultobj = 0;
12331 wxLog *arg1 = (wxLog *) 0 ;
12332 void *argp1 = 0 ;
12333 int res1 = 0 ;
12334 PyObject *swig_obj[1] ;
12335
12336 if (!args) SWIG_fail;
12337 swig_obj[0] = args;
12338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12339 if (!SWIG_IsOK(res1)) {
12340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12341 }
12342 arg1 = reinterpret_cast< wxLog * >(argp1);
12343 {
12344 PyThreadState* __tstate = wxPyBeginAllowThreads();
12345 (arg1)->Flush();
12346 wxPyEndAllowThreads(__tstate);
12347 if (PyErr_Occurred()) SWIG_fail;
12348 }
12349 resultobj = SWIG_Py_Void();
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357 PyObject *resultobj = 0;
12358
12359 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 wxLog::FlushActive();
12363 wxPyEndAllowThreads(__tstate);
12364 if (PyErr_Occurred()) SWIG_fail;
12365 }
12366 resultobj = SWIG_Py_Void();
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12374 PyObject *resultobj = 0;
12375 wxLog *result = 0 ;
12376
12377 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 result = (wxLog *)wxLog::GetActiveTarget();
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12385 return resultobj;
12386 fail:
12387 return NULL;
12388 }
12389
12390
12391 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12392 PyObject *resultobj = 0;
12393 wxLog *arg1 = (wxLog *) 0 ;
12394 wxLog *result = 0 ;
12395 int res1 = 0 ;
12396 PyObject * obj0 = 0 ;
12397 char * kwnames[] = {
12398 (char *) "pLogger", NULL
12399 };
12400
12401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12402 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12403 if (!SWIG_IsOK(res1)) {
12404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12405 }
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12420 PyObject *resultobj = 0;
12421
12422 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 wxLog::Suspend();
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 resultobj = SWIG_Py_Void();
12430 return resultobj;
12431 fail:
12432 return NULL;
12433 }
12434
12435
12436 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12437 PyObject *resultobj = 0;
12438
12439 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12440 {
12441 PyThreadState* __tstate = wxPyBeginAllowThreads();
12442 wxLog::Resume();
12443 wxPyEndAllowThreads(__tstate);
12444 if (PyErr_Occurred()) SWIG_fail;
12445 }
12446 resultobj = SWIG_Py_Void();
12447 return resultobj;
12448 fail:
12449 return NULL;
12450 }
12451
12452
12453 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12454 PyObject *resultobj = 0;
12455 bool arg1 = (bool) true ;
12456 bool val1 ;
12457 int ecode1 = 0 ;
12458 PyObject * obj0 = 0 ;
12459 char * kwnames[] = {
12460 (char *) "bVerbose", NULL
12461 };
12462
12463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12464 if (obj0) {
12465 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12466 if (!SWIG_IsOK(ecode1)) {
12467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12468 }
12469 arg1 = static_cast< bool >(val1);
12470 }
12471 {
12472 PyThreadState* __tstate = wxPyBeginAllowThreads();
12473 wxLog::SetVerbose(arg1);
12474 wxPyEndAllowThreads(__tstate);
12475 if (PyErr_Occurred()) SWIG_fail;
12476 }
12477 resultobj = SWIG_Py_Void();
12478 return resultobj;
12479 fail:
12480 return NULL;
12481 }
12482
12483
12484 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12485 PyObject *resultobj = 0;
12486 wxLogLevel arg1 ;
12487 unsigned long val1 ;
12488 int ecode1 = 0 ;
12489 PyObject * obj0 = 0 ;
12490 char * kwnames[] = {
12491 (char *) "logLevel", NULL
12492 };
12493
12494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12495 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12496 if (!SWIG_IsOK(ecode1)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12498 }
12499 arg1 = static_cast< wxLogLevel >(val1);
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 wxLog::SetLogLevel(arg1);
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 resultobj = SWIG_Py_Void();
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12514 PyObject *resultobj = 0;
12515
12516 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12517 {
12518 PyThreadState* __tstate = wxPyBeginAllowThreads();
12519 wxLog::DontCreateOnDemand();
12520 wxPyEndAllowThreads(__tstate);
12521 if (PyErr_Occurred()) SWIG_fail;
12522 }
12523 resultobj = SWIG_Py_Void();
12524 return resultobj;
12525 fail:
12526 return NULL;
12527 }
12528
12529
12530 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12531 PyObject *resultobj = 0;
12532 bool arg1 = (bool) true ;
12533 bool val1 ;
12534 int ecode1 = 0 ;
12535 PyObject * obj0 = 0 ;
12536 char * kwnames[] = {
12537 (char *) "bRepetCounting", NULL
12538 };
12539
12540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12541 if (obj0) {
12542 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12543 if (!SWIG_IsOK(ecode1)) {
12544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12545 }
12546 arg1 = static_cast< bool >(val1);
12547 }
12548 {
12549 PyThreadState* __tstate = wxPyBeginAllowThreads();
12550 wxLog::SetRepetitionCounting(arg1);
12551 wxPyEndAllowThreads(__tstate);
12552 if (PyErr_Occurred()) SWIG_fail;
12553 }
12554 resultobj = SWIG_Py_Void();
12555 return resultobj;
12556 fail:
12557 return NULL;
12558 }
12559
12560
12561 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12562 PyObject *resultobj = 0;
12563 bool result;
12564
12565 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 result = (bool)wxLog::GetRepetitionCounting();
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 {
12573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12574 }
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj = 0;
12583 wxTraceMask arg1 ;
12584 unsigned long val1 ;
12585 int ecode1 = 0 ;
12586 PyObject * obj0 = 0 ;
12587 char * kwnames[] = {
12588 (char *) "ulMask", NULL
12589 };
12590
12591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12592 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12593 if (!SWIG_IsOK(ecode1)) {
12594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12595 }
12596 arg1 = static_cast< wxTraceMask >(val1);
12597 {
12598 PyThreadState* __tstate = wxPyBeginAllowThreads();
12599 wxLog::SetTraceMask(arg1);
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 resultobj = SWIG_Py_Void();
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj = 0;
12612 wxString *arg1 = 0 ;
12613 bool temp1 = false ;
12614 PyObject * obj0 = 0 ;
12615 char * kwnames[] = {
12616 (char *) "str", NULL
12617 };
12618
12619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12620 {
12621 arg1 = wxString_in_helper(obj0);
12622 if (arg1 == NULL) SWIG_fail;
12623 temp1 = true;
12624 }
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 wxLog::AddTraceMask((wxString const &)*arg1);
12628 wxPyEndAllowThreads(__tstate);
12629 if (PyErr_Occurred()) SWIG_fail;
12630 }
12631 resultobj = SWIG_Py_Void();
12632 {
12633 if (temp1)
12634 delete arg1;
12635 }
12636 return resultobj;
12637 fail:
12638 {
12639 if (temp1)
12640 delete arg1;
12641 }
12642 return NULL;
12643 }
12644
12645
12646 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12647 PyObject *resultobj = 0;
12648 wxString *arg1 = 0 ;
12649 bool temp1 = false ;
12650 PyObject * obj0 = 0 ;
12651 char * kwnames[] = {
12652 (char *) "str", NULL
12653 };
12654
12655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12656 {
12657 arg1 = wxString_in_helper(obj0);
12658 if (arg1 == NULL) SWIG_fail;
12659 temp1 = true;
12660 }
12661 {
12662 PyThreadState* __tstate = wxPyBeginAllowThreads();
12663 wxLog::RemoveTraceMask((wxString const &)*arg1);
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 resultobj = SWIG_Py_Void();
12668 {
12669 if (temp1)
12670 delete arg1;
12671 }
12672 return resultobj;
12673 fail:
12674 {
12675 if (temp1)
12676 delete arg1;
12677 }
12678 return NULL;
12679 }
12680
12681
12682 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12683 PyObject *resultobj = 0;
12684
12685 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12686 {
12687 PyThreadState* __tstate = wxPyBeginAllowThreads();
12688 wxLog::ClearTraceMasks();
12689 wxPyEndAllowThreads(__tstate);
12690 if (PyErr_Occurred()) SWIG_fail;
12691 }
12692 resultobj = SWIG_Py_Void();
12693 return resultobj;
12694 fail:
12695 return NULL;
12696 }
12697
12698
12699 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12700 PyObject *resultobj = 0;
12701 wxArrayString *result = 0 ;
12702
12703 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 {
12707 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12708 result = (wxArrayString *) &_result_ref;
12709 }
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 {
12714 resultobj = wxArrayString2PyList_helper(*result);
12715 }
12716 return resultobj;
12717 fail:
12718 return NULL;
12719 }
12720
12721
12722 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12723 PyObject *resultobj = 0;
12724 wxChar *arg1 = (wxChar *) 0 ;
12725 void *argp1 = 0 ;
12726 int res1 = 0 ;
12727 PyObject * obj0 = 0 ;
12728 char * kwnames[] = {
12729 (char *) "ts", NULL
12730 };
12731
12732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12734 if (!SWIG_IsOK(res1)) {
12735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12736 }
12737 arg1 = reinterpret_cast< wxChar * >(argp1);
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 wxLog::SetTimestamp((wxChar const *)arg1);
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 resultobj = SWIG_Py_Void();
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 bool result;
12754
12755 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12756 {
12757 PyThreadState* __tstate = wxPyBeginAllowThreads();
12758 result = (bool)wxLog::GetVerbose();
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 {
12763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12764 }
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12772 PyObject *resultobj = 0;
12773 wxTraceMask result;
12774
12775 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12776 {
12777 PyThreadState* __tstate = wxPyBeginAllowThreads();
12778 result = (wxTraceMask)wxLog::GetTraceMask();
12779 wxPyEndAllowThreads(__tstate);
12780 if (PyErr_Occurred()) SWIG_fail;
12781 }
12782 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12790 PyObject *resultobj = 0;
12791 wxChar *arg1 = (wxChar *) 0 ;
12792 bool result;
12793 void *argp1 = 0 ;
12794 int res1 = 0 ;
12795 PyObject * obj0 = 0 ;
12796 char * kwnames[] = {
12797 (char *) "mask", NULL
12798 };
12799
12800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12802 if (!SWIG_IsOK(res1)) {
12803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12804 }
12805 arg1 = reinterpret_cast< wxChar * >(argp1);
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 {
12813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12814 }
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12822 PyObject *resultobj = 0;
12823 wxLogLevel result;
12824
12825 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12826 {
12827 PyThreadState* __tstate = wxPyBeginAllowThreads();
12828 result = (wxLogLevel)wxLog::GetLogLevel();
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840 PyObject *resultobj = 0;
12841 wxChar *result = 0 ;
12842
12843 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = (wxChar *)wxLog::GetTimestamp();
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12851 return resultobj;
12852 fail:
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12858 PyObject *resultobj = 0;
12859 wxString result;
12860
12861 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 result = wxLog_TimeStamp();
12865 wxPyEndAllowThreads(__tstate);
12866 if (PyErr_Occurred()) SWIG_fail;
12867 }
12868 {
12869 #if wxUSE_UNICODE
12870 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12871 #else
12872 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12873 #endif
12874 }
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 PyObject *resultobj = 0;
12883 wxLog *arg1 = (wxLog *) 0 ;
12884 void *argp1 = 0 ;
12885 int res1 = 0 ;
12886 PyObject *swig_obj[1] ;
12887
12888 if (!args) SWIG_fail;
12889 swig_obj[0] = args;
12890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12891 if (!SWIG_IsOK(res1)) {
12892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12893 }
12894 arg1 = reinterpret_cast< wxLog * >(argp1);
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 wxLog_Destroy(arg1);
12898 wxPyEndAllowThreads(__tstate);
12899 if (PyErr_Occurred()) SWIG_fail;
12900 }
12901 resultobj = SWIG_Py_Void();
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *obj;
12910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12911 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12912 return SWIG_Py_Void();
12913 }
12914
12915 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12916 return SWIG_Python_InitShadowInstance(args);
12917 }
12918
12919 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12920 PyObject *resultobj = 0;
12921 wxLogStderr *result = 0 ;
12922
12923 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 result = (wxLogStderr *)new wxLogStderr();
12927 wxPyEndAllowThreads(__tstate);
12928 if (PyErr_Occurred()) SWIG_fail;
12929 }
12930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *obj;
12939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12940 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12941 return SWIG_Py_Void();
12942 }
12943
12944 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12945 return SWIG_Python_InitShadowInstance(args);
12946 }
12947
12948 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12949 PyObject *resultobj = 0;
12950 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12951 wxLogTextCtrl *result = 0 ;
12952 void *argp1 = 0 ;
12953 int res1 = 0 ;
12954 PyObject * obj0 = 0 ;
12955 char * kwnames[] = {
12956 (char *) "pTextCtrl", NULL
12957 };
12958
12959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12961 if (!SWIG_IsOK(res1)) {
12962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12963 }
12964 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12968 wxPyEndAllowThreads(__tstate);
12969 if (PyErr_Occurred()) SWIG_fail;
12970 }
12971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12979 PyObject *obj;
12980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12981 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12982 return SWIG_Py_Void();
12983 }
12984
12985 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12986 return SWIG_Python_InitShadowInstance(args);
12987 }
12988
12989 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12990 PyObject *resultobj = 0;
12991 wxLogGui *result = 0 ;
12992
12993 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12994 {
12995 PyThreadState* __tstate = wxPyBeginAllowThreads();
12996 result = (wxLogGui *)new wxLogGui();
12997 wxPyEndAllowThreads(__tstate);
12998 if (PyErr_Occurred()) SWIG_fail;
12999 }
13000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
13001 return resultobj;
13002 fail:
13003 return NULL;
13004 }
13005
13006
13007 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 PyObject *obj;
13009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13010 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
13011 return SWIG_Py_Void();
13012 }
13013
13014 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 return SWIG_Python_InitShadowInstance(args);
13016 }
13017
13018 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13019 PyObject *resultobj = 0;
13020 wxFrame *arg1 = (wxFrame *) 0 ;
13021 wxString *arg2 = 0 ;
13022 bool arg3 = (bool) true ;
13023 bool arg4 = (bool) true ;
13024 wxLogWindow *result = 0 ;
13025 void *argp1 = 0 ;
13026 int res1 = 0 ;
13027 bool temp2 = false ;
13028 bool val3 ;
13029 int ecode3 = 0 ;
13030 bool val4 ;
13031 int ecode4 = 0 ;
13032 PyObject * obj0 = 0 ;
13033 PyObject * obj1 = 0 ;
13034 PyObject * obj2 = 0 ;
13035 PyObject * obj3 = 0 ;
13036 char * kwnames[] = {
13037 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13038 };
13039
13040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13042 if (!SWIG_IsOK(res1)) {
13043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13044 }
13045 arg1 = reinterpret_cast< wxFrame * >(argp1);
13046 {
13047 arg2 = wxString_in_helper(obj1);
13048 if (arg2 == NULL) SWIG_fail;
13049 temp2 = true;
13050 }
13051 if (obj2) {
13052 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13053 if (!SWIG_IsOK(ecode3)) {
13054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13055 }
13056 arg3 = static_cast< bool >(val3);
13057 }
13058 if (obj3) {
13059 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13060 if (!SWIG_IsOK(ecode4)) {
13061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13062 }
13063 arg4 = static_cast< bool >(val4);
13064 }
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13068 wxPyEndAllowThreads(__tstate);
13069 if (PyErr_Occurred()) SWIG_fail;
13070 }
13071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13072 {
13073 if (temp2)
13074 delete arg2;
13075 }
13076 return resultobj;
13077 fail:
13078 {
13079 if (temp2)
13080 delete arg2;
13081 }
13082 return NULL;
13083 }
13084
13085
13086 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13087 PyObject *resultobj = 0;
13088 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13089 bool arg2 = (bool) true ;
13090 void *argp1 = 0 ;
13091 int res1 = 0 ;
13092 bool val2 ;
13093 int ecode2 = 0 ;
13094 PyObject * obj0 = 0 ;
13095 PyObject * obj1 = 0 ;
13096 char * kwnames[] = {
13097 (char *) "self",(char *) "bShow", NULL
13098 };
13099
13100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13102 if (!SWIG_IsOK(res1)) {
13103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13104 }
13105 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13106 if (obj1) {
13107 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13108 if (!SWIG_IsOK(ecode2)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13110 }
13111 arg2 = static_cast< bool >(val2);
13112 }
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 (arg1)->Show(arg2);
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 resultobj = SWIG_Py_Void();
13120 return resultobj;
13121 fail:
13122 return NULL;
13123 }
13124
13125
13126 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13127 PyObject *resultobj = 0;
13128 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13129 wxFrame *result = 0 ;
13130 void *argp1 = 0 ;
13131 int res1 = 0 ;
13132 PyObject *swig_obj[1] ;
13133
13134 if (!args) SWIG_fail;
13135 swig_obj[0] = args;
13136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13137 if (!SWIG_IsOK(res1)) {
13138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13139 }
13140 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 {
13148 resultobj = wxPyMake_wxObject(result, (bool)0);
13149 }
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13157 PyObject *resultobj = 0;
13158 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13159 wxLog *result = 0 ;
13160 void *argp1 = 0 ;
13161 int res1 = 0 ;
13162 PyObject *swig_obj[1] ;
13163
13164 if (!args) SWIG_fail;
13165 swig_obj[0] = args;
13166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13167 if (!SWIG_IsOK(res1)) {
13168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13169 }
13170 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13178 return resultobj;
13179 fail:
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13185 PyObject *resultobj = 0;
13186 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13187 bool result;
13188 void *argp1 = 0 ;
13189 int res1 = 0 ;
13190 PyObject *swig_obj[1] ;
13191
13192 if (!args) SWIG_fail;
13193 swig_obj[0] = args;
13194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13195 if (!SWIG_IsOK(res1)) {
13196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13197 }
13198 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13199 {
13200 PyThreadState* __tstate = wxPyBeginAllowThreads();
13201 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 {
13206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13207 }
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj = 0;
13216 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13217 bool arg2 ;
13218 void *argp1 = 0 ;
13219 int res1 = 0 ;
13220 bool val2 ;
13221 int ecode2 = 0 ;
13222 PyObject * obj0 = 0 ;
13223 PyObject * obj1 = 0 ;
13224 char * kwnames[] = {
13225 (char *) "self",(char *) "bDoPass", NULL
13226 };
13227
13228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13230 if (!SWIG_IsOK(res1)) {
13231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13232 }
13233 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13235 if (!SWIG_IsOK(ecode2)) {
13236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13237 }
13238 arg2 = static_cast< bool >(val2);
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 (arg1)->PassMessages(arg2);
13242 wxPyEndAllowThreads(__tstate);
13243 if (PyErr_Occurred()) SWIG_fail;
13244 }
13245 resultobj = SWIG_Py_Void();
13246 return resultobj;
13247 fail:
13248 return NULL;
13249 }
13250
13251
13252 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13253 PyObject *obj;
13254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13255 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13256 return SWIG_Py_Void();
13257 }
13258
13259 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13260 return SWIG_Python_InitShadowInstance(args);
13261 }
13262
13263 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13264 PyObject *resultobj = 0;
13265 wxLog *arg1 = (wxLog *) 0 ;
13266 wxLogChain *result = 0 ;
13267 void *argp1 = 0 ;
13268 int res1 = 0 ;
13269 PyObject * obj0 = 0 ;
13270 char * kwnames[] = {
13271 (char *) "logger", NULL
13272 };
13273
13274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13276 if (!SWIG_IsOK(res1)) {
13277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13278 }
13279 arg1 = reinterpret_cast< wxLog * >(argp1);
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 result = (wxLogChain *)new wxLogChain(arg1);
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj = 0;
13295 wxLogChain *arg1 = (wxLogChain *) 0 ;
13296 wxLog *arg2 = (wxLog *) 0 ;
13297 void *argp1 = 0 ;
13298 int res1 = 0 ;
13299 void *argp2 = 0 ;
13300 int res2 = 0 ;
13301 PyObject * obj0 = 0 ;
13302 PyObject * obj1 = 0 ;
13303 char * kwnames[] = {
13304 (char *) "self",(char *) "logger", NULL
13305 };
13306
13307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13309 if (!SWIG_IsOK(res1)) {
13310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13311 }
13312 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13314 if (!SWIG_IsOK(res2)) {
13315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13316 }
13317 arg2 = reinterpret_cast< wxLog * >(argp2);
13318 {
13319 PyThreadState* __tstate = wxPyBeginAllowThreads();
13320 (arg1)->SetLog(arg2);
13321 wxPyEndAllowThreads(__tstate);
13322 if (PyErr_Occurred()) SWIG_fail;
13323 }
13324 resultobj = SWIG_Py_Void();
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13332 PyObject *resultobj = 0;
13333 wxLogChain *arg1 = (wxLogChain *) 0 ;
13334 bool arg2 ;
13335 void *argp1 = 0 ;
13336 int res1 = 0 ;
13337 bool val2 ;
13338 int ecode2 = 0 ;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 char * kwnames[] = {
13342 (char *) "self",(char *) "bDoPass", NULL
13343 };
13344
13345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13347 if (!SWIG_IsOK(res1)) {
13348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13349 }
13350 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13351 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13352 if (!SWIG_IsOK(ecode2)) {
13353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13354 }
13355 arg2 = static_cast< bool >(val2);
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 (arg1)->PassMessages(arg2);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_Py_Void();
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13370 PyObject *resultobj = 0;
13371 wxLogChain *arg1 = (wxLogChain *) 0 ;
13372 bool result;
13373 void *argp1 = 0 ;
13374 int res1 = 0 ;
13375 PyObject *swig_obj[1] ;
13376
13377 if (!args) SWIG_fail;
13378 swig_obj[0] = args;
13379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13380 if (!SWIG_IsOK(res1)) {
13381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13382 }
13383 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13384 {
13385 PyThreadState* __tstate = wxPyBeginAllowThreads();
13386 result = (bool)(arg1)->IsPassingMessages();
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 {
13391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13392 }
13393 return resultobj;
13394 fail:
13395 return NULL;
13396 }
13397
13398
13399 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13400 PyObject *resultobj = 0;
13401 wxLogChain *arg1 = (wxLogChain *) 0 ;
13402 wxLog *result = 0 ;
13403 void *argp1 = 0 ;
13404 int res1 = 0 ;
13405 PyObject *swig_obj[1] ;
13406
13407 if (!args) SWIG_fail;
13408 swig_obj[0] = args;
13409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13410 if (!SWIG_IsOK(res1)) {
13411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13412 }
13413 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13414 {
13415 PyThreadState* __tstate = wxPyBeginAllowThreads();
13416 result = (wxLog *)(arg1)->GetOldLog();
13417 wxPyEndAllowThreads(__tstate);
13418 if (PyErr_Occurred()) SWIG_fail;
13419 }
13420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13421 return resultobj;
13422 fail:
13423 return NULL;
13424 }
13425
13426
13427 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13428 PyObject *obj;
13429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13430 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13431 return SWIG_Py_Void();
13432 }
13433
13434 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13435 return SWIG_Python_InitShadowInstance(args);
13436 }
13437
13438 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *resultobj = 0;
13440 wxLogBuffer *result = 0 ;
13441
13442 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13443 {
13444 PyThreadState* __tstate = wxPyBeginAllowThreads();
13445 result = (wxLogBuffer *)new wxLogBuffer();
13446 wxPyEndAllowThreads(__tstate);
13447 if (PyErr_Occurred()) SWIG_fail;
13448 }
13449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13450 return resultobj;
13451 fail:
13452 return NULL;
13453 }
13454
13455
13456 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13457 PyObject *resultobj = 0;
13458 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13459 wxString *result = 0 ;
13460 void *argp1 = 0 ;
13461 int res1 = 0 ;
13462 PyObject *swig_obj[1] ;
13463
13464 if (!args) SWIG_fail;
13465 swig_obj[0] = args;
13466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13467 if (!SWIG_IsOK(res1)) {
13468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13469 }
13470 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13471 {
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 {
13474 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13475 result = (wxString *) &_result_ref;
13476 }
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 {
13481 #if wxUSE_UNICODE
13482 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13483 #else
13484 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13485 #endif
13486 }
13487 return resultobj;
13488 fail:
13489 return NULL;
13490 }
13491
13492
13493 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13494 PyObject *obj;
13495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13496 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13497 return SWIG_Py_Void();
13498 }
13499
13500 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13501 return SWIG_Python_InitShadowInstance(args);
13502 }
13503
13504 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13505 PyObject *resultobj = 0;
13506 unsigned long result;
13507
13508 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13509 {
13510 PyThreadState* __tstate = wxPyBeginAllowThreads();
13511 result = (unsigned long)wxSysErrorCode();
13512 wxPyEndAllowThreads(__tstate);
13513 if (PyErr_Occurred()) SWIG_fail;
13514 }
13515 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13516 return resultobj;
13517 fail:
13518 return NULL;
13519 }
13520
13521
13522 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13523 PyObject *resultobj = 0;
13524 unsigned long arg1 = (unsigned long) 0 ;
13525 wxString result;
13526 unsigned long val1 ;
13527 int ecode1 = 0 ;
13528 PyObject * obj0 = 0 ;
13529 char * kwnames[] = {
13530 (char *) "nErrCode", NULL
13531 };
13532
13533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13534 if (obj0) {
13535 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13536 if (!SWIG_IsOK(ecode1)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13538 }
13539 arg1 = static_cast< unsigned long >(val1);
13540 }
13541 {
13542 PyThreadState* __tstate = wxPyBeginAllowThreads();
13543 result = wxSysErrorMsg(arg1);
13544 wxPyEndAllowThreads(__tstate);
13545 if (PyErr_Occurred()) SWIG_fail;
13546 }
13547 {
13548 #if wxUSE_UNICODE
13549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13550 #else
13551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13552 #endif
13553 }
13554 return resultobj;
13555 fail:
13556 return NULL;
13557 }
13558
13559
13560 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13561 PyObject *resultobj = 0;
13562 wxString *arg1 = 0 ;
13563 bool temp1 = false ;
13564 PyObject * obj0 = 0 ;
13565 char * kwnames[] = {
13566 (char *) "msg", NULL
13567 };
13568
13569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13570 {
13571 arg1 = wxString_in_helper(obj0);
13572 if (arg1 == NULL) SWIG_fail;
13573 temp1 = true;
13574 }
13575 {
13576 PyThreadState* __tstate = wxPyBeginAllowThreads();
13577 wxPyLogFatalError((wxString const &)*arg1);
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 resultobj = SWIG_Py_Void();
13582 {
13583 if (temp1)
13584 delete arg1;
13585 }
13586 return resultobj;
13587 fail:
13588 {
13589 if (temp1)
13590 delete arg1;
13591 }
13592 return NULL;
13593 }
13594
13595
13596 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13597 PyObject *resultobj = 0;
13598 wxString *arg1 = 0 ;
13599 bool temp1 = false ;
13600 PyObject * obj0 = 0 ;
13601 char * kwnames[] = {
13602 (char *) "msg", NULL
13603 };
13604
13605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13606 {
13607 arg1 = wxString_in_helper(obj0);
13608 if (arg1 == NULL) SWIG_fail;
13609 temp1 = true;
13610 }
13611 {
13612 PyThreadState* __tstate = wxPyBeginAllowThreads();
13613 wxPyLogError((wxString const &)*arg1);
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 resultobj = SWIG_Py_Void();
13618 {
13619 if (temp1)
13620 delete arg1;
13621 }
13622 return resultobj;
13623 fail:
13624 {
13625 if (temp1)
13626 delete arg1;
13627 }
13628 return NULL;
13629 }
13630
13631
13632 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13633 PyObject *resultobj = 0;
13634 wxString *arg1 = 0 ;
13635 bool temp1 = false ;
13636 PyObject * obj0 = 0 ;
13637 char * kwnames[] = {
13638 (char *) "msg", NULL
13639 };
13640
13641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13642 {
13643 arg1 = wxString_in_helper(obj0);
13644 if (arg1 == NULL) SWIG_fail;
13645 temp1 = true;
13646 }
13647 {
13648 PyThreadState* __tstate = wxPyBeginAllowThreads();
13649 wxPyLogWarning((wxString const &)*arg1);
13650 wxPyEndAllowThreads(__tstate);
13651 if (PyErr_Occurred()) SWIG_fail;
13652 }
13653 resultobj = SWIG_Py_Void();
13654 {
13655 if (temp1)
13656 delete arg1;
13657 }
13658 return resultobj;
13659 fail:
13660 {
13661 if (temp1)
13662 delete arg1;
13663 }
13664 return NULL;
13665 }
13666
13667
13668 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13669 PyObject *resultobj = 0;
13670 wxString *arg1 = 0 ;
13671 bool temp1 = false ;
13672 PyObject * obj0 = 0 ;
13673 char * kwnames[] = {
13674 (char *) "msg", NULL
13675 };
13676
13677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13678 {
13679 arg1 = wxString_in_helper(obj0);
13680 if (arg1 == NULL) SWIG_fail;
13681 temp1 = true;
13682 }
13683 {
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 wxPyLogMessage((wxString const &)*arg1);
13686 wxPyEndAllowThreads(__tstate);
13687 if (PyErr_Occurred()) SWIG_fail;
13688 }
13689 resultobj = SWIG_Py_Void();
13690 {
13691 if (temp1)
13692 delete arg1;
13693 }
13694 return resultobj;
13695 fail:
13696 {
13697 if (temp1)
13698 delete arg1;
13699 }
13700 return NULL;
13701 }
13702
13703
13704 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj = 0;
13706 wxString *arg1 = 0 ;
13707 bool temp1 = false ;
13708 PyObject * obj0 = 0 ;
13709 char * kwnames[] = {
13710 (char *) "msg", NULL
13711 };
13712
13713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13714 {
13715 arg1 = wxString_in_helper(obj0);
13716 if (arg1 == NULL) SWIG_fail;
13717 temp1 = true;
13718 }
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 wxPyLogInfo((wxString const &)*arg1);
13722 wxPyEndAllowThreads(__tstate);
13723 if (PyErr_Occurred()) SWIG_fail;
13724 }
13725 resultobj = SWIG_Py_Void();
13726 {
13727 if (temp1)
13728 delete arg1;
13729 }
13730 return resultobj;
13731 fail:
13732 {
13733 if (temp1)
13734 delete arg1;
13735 }
13736 return NULL;
13737 }
13738
13739
13740 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13741 PyObject *resultobj = 0;
13742 wxString *arg1 = 0 ;
13743 bool temp1 = false ;
13744 PyObject * obj0 = 0 ;
13745 char * kwnames[] = {
13746 (char *) "msg", NULL
13747 };
13748
13749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13750 {
13751 arg1 = wxString_in_helper(obj0);
13752 if (arg1 == NULL) SWIG_fail;
13753 temp1 = true;
13754 }
13755 {
13756 PyThreadState* __tstate = wxPyBeginAllowThreads();
13757 wxPyLogDebug((wxString const &)*arg1);
13758 wxPyEndAllowThreads(__tstate);
13759 if (PyErr_Occurred()) SWIG_fail;
13760 }
13761 resultobj = SWIG_Py_Void();
13762 {
13763 if (temp1)
13764 delete arg1;
13765 }
13766 return resultobj;
13767 fail:
13768 {
13769 if (temp1)
13770 delete arg1;
13771 }
13772 return NULL;
13773 }
13774
13775
13776 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13777 PyObject *resultobj = 0;
13778 wxString *arg1 = 0 ;
13779 bool temp1 = false ;
13780 PyObject * obj0 = 0 ;
13781 char * kwnames[] = {
13782 (char *) "msg", NULL
13783 };
13784
13785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13786 {
13787 arg1 = wxString_in_helper(obj0);
13788 if (arg1 == NULL) SWIG_fail;
13789 temp1 = true;
13790 }
13791 {
13792 PyThreadState* __tstate = wxPyBeginAllowThreads();
13793 wxPyLogVerbose((wxString const &)*arg1);
13794 wxPyEndAllowThreads(__tstate);
13795 if (PyErr_Occurred()) SWIG_fail;
13796 }
13797 resultobj = SWIG_Py_Void();
13798 {
13799 if (temp1)
13800 delete arg1;
13801 }
13802 return resultobj;
13803 fail:
13804 {
13805 if (temp1)
13806 delete arg1;
13807 }
13808 return NULL;
13809 }
13810
13811
13812 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13813 PyObject *resultobj = 0;
13814 wxString *arg1 = 0 ;
13815 bool temp1 = false ;
13816 PyObject * obj0 = 0 ;
13817 char * kwnames[] = {
13818 (char *) "msg", NULL
13819 };
13820
13821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13822 {
13823 arg1 = wxString_in_helper(obj0);
13824 if (arg1 == NULL) SWIG_fail;
13825 temp1 = true;
13826 }
13827 {
13828 PyThreadState* __tstate = wxPyBeginAllowThreads();
13829 wxPyLogStatus((wxString const &)*arg1);
13830 wxPyEndAllowThreads(__tstate);
13831 if (PyErr_Occurred()) SWIG_fail;
13832 }
13833 resultobj = SWIG_Py_Void();
13834 {
13835 if (temp1)
13836 delete arg1;
13837 }
13838 return resultobj;
13839 fail:
13840 {
13841 if (temp1)
13842 delete arg1;
13843 }
13844 return NULL;
13845 }
13846
13847
13848 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13849 PyObject *resultobj = 0;
13850 wxFrame *arg1 = (wxFrame *) 0 ;
13851 wxString *arg2 = 0 ;
13852 void *argp1 = 0 ;
13853 int res1 = 0 ;
13854 bool temp2 = false ;
13855 PyObject * obj0 = 0 ;
13856 PyObject * obj1 = 0 ;
13857 char * kwnames[] = {
13858 (char *) "pFrame",(char *) "msg", NULL
13859 };
13860
13861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13863 if (!SWIG_IsOK(res1)) {
13864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13865 }
13866 arg1 = reinterpret_cast< wxFrame * >(argp1);
13867 {
13868 arg2 = wxString_in_helper(obj1);
13869 if (arg2 == NULL) SWIG_fail;
13870 temp2 = true;
13871 }
13872 {
13873 PyThreadState* __tstate = wxPyBeginAllowThreads();
13874 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13875 wxPyEndAllowThreads(__tstate);
13876 if (PyErr_Occurred()) SWIG_fail;
13877 }
13878 resultobj = SWIG_Py_Void();
13879 {
13880 if (temp2)
13881 delete arg2;
13882 }
13883 return resultobj;
13884 fail:
13885 {
13886 if (temp2)
13887 delete arg2;
13888 }
13889 return NULL;
13890 }
13891
13892
13893 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13894 PyObject *resultobj = 0;
13895 wxString *arg1 = 0 ;
13896 bool temp1 = false ;
13897 PyObject * obj0 = 0 ;
13898 char * kwnames[] = {
13899 (char *) "msg", NULL
13900 };
13901
13902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13903 {
13904 arg1 = wxString_in_helper(obj0);
13905 if (arg1 == NULL) SWIG_fail;
13906 temp1 = true;
13907 }
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 wxPyLogSysError((wxString const &)*arg1);
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_Py_Void();
13915 {
13916 if (temp1)
13917 delete arg1;
13918 }
13919 return resultobj;
13920 fail:
13921 {
13922 if (temp1)
13923 delete arg1;
13924 }
13925 return NULL;
13926 }
13927
13928
13929 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13930 PyObject *resultobj = 0;
13931 unsigned long arg1 ;
13932 wxString *arg2 = 0 ;
13933 unsigned long val1 ;
13934 int ecode1 = 0 ;
13935 bool temp2 = false ;
13936 PyObject * obj0 = 0 ;
13937 PyObject * obj1 = 0 ;
13938 char * kwnames[] = {
13939 (char *) "level",(char *) "msg", NULL
13940 };
13941
13942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13943 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13944 if (!SWIG_IsOK(ecode1)) {
13945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13946 }
13947 arg1 = static_cast< unsigned long >(val1);
13948 {
13949 arg2 = wxString_in_helper(obj1);
13950 if (arg2 == NULL) SWIG_fail;
13951 temp2 = true;
13952 }
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13956 wxPyEndAllowThreads(__tstate);
13957 if (PyErr_Occurred()) SWIG_fail;
13958 }
13959 resultobj = SWIG_Py_Void();
13960 {
13961 if (temp2)
13962 delete arg2;
13963 }
13964 return resultobj;
13965 fail:
13966 {
13967 if (temp2)
13968 delete arg2;
13969 }
13970 return NULL;
13971 }
13972
13973
13974 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13975 PyObject *resultobj = 0;
13976 unsigned long arg1 ;
13977 wxString *arg2 = 0 ;
13978 unsigned long val1 ;
13979 int ecode1 = 0 ;
13980 bool temp2 = false ;
13981
13982 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13983 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13984 if (!SWIG_IsOK(ecode1)) {
13985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13986 }
13987 arg1 = static_cast< unsigned long >(val1);
13988 {
13989 arg2 = wxString_in_helper(swig_obj[1]);
13990 if (arg2 == NULL) SWIG_fail;
13991 temp2 = true;
13992 }
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 wxPyLogTrace(arg1,(wxString const &)*arg2);
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 resultobj = SWIG_Py_Void();
14000 {
14001 if (temp2)
14002 delete arg2;
14003 }
14004 return resultobj;
14005 fail:
14006 {
14007 if (temp2)
14008 delete arg2;
14009 }
14010 return NULL;
14011 }
14012
14013
14014 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14015 PyObject *resultobj = 0;
14016 wxString *arg1 = 0 ;
14017 wxString *arg2 = 0 ;
14018 bool temp1 = false ;
14019 bool temp2 = false ;
14020
14021 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14022 {
14023 arg1 = wxString_in_helper(swig_obj[0]);
14024 if (arg1 == NULL) SWIG_fail;
14025 temp1 = true;
14026 }
14027 {
14028 arg2 = wxString_in_helper(swig_obj[1]);
14029 if (arg2 == NULL) SWIG_fail;
14030 temp2 = true;
14031 }
14032 {
14033 PyThreadState* __tstate = wxPyBeginAllowThreads();
14034 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 resultobj = SWIG_Py_Void();
14039 {
14040 if (temp1)
14041 delete arg1;
14042 }
14043 {
14044 if (temp2)
14045 delete arg2;
14046 }
14047 return resultobj;
14048 fail:
14049 {
14050 if (temp1)
14051 delete arg1;
14052 }
14053 {
14054 if (temp2)
14055 delete arg2;
14056 }
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14062 int argc;
14063 PyObject *argv[3];
14064
14065 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14066 --argc;
14067 if (argc == 2) {
14068 int _v = 0;
14069 {
14070 {
14071 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14072 }
14073 }
14074 if (!_v) goto check_1;
14075 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14076 }
14077 check_1:
14078
14079 if (argc == 2) {
14080 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14081 }
14082
14083 fail:
14084 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxString *arg1 = 0 ;
14092 wxString *arg2 = 0 ;
14093 bool temp1 = false ;
14094 bool temp2 = false ;
14095 PyObject * obj0 = 0 ;
14096 PyObject * obj1 = 0 ;
14097 char * kwnames[] = {
14098 (char *) "title",(char *) "text", NULL
14099 };
14100
14101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14102 {
14103 arg1 = wxString_in_helper(obj0);
14104 if (arg1 == NULL) SWIG_fail;
14105 temp1 = true;
14106 }
14107 {
14108 arg2 = wxString_in_helper(obj1);
14109 if (arg2 == NULL) SWIG_fail;
14110 temp2 = true;
14111 }
14112 {
14113 PyThreadState* __tstate = wxPyBeginAllowThreads();
14114 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14115 wxPyEndAllowThreads(__tstate);
14116 if (PyErr_Occurred()) SWIG_fail;
14117 }
14118 resultobj = SWIG_Py_Void();
14119 {
14120 if (temp1)
14121 delete arg1;
14122 }
14123 {
14124 if (temp2)
14125 delete arg2;
14126 }
14127 return resultobj;
14128 fail:
14129 {
14130 if (temp1)
14131 delete arg1;
14132 }
14133 {
14134 if (temp2)
14135 delete arg2;
14136 }
14137 return NULL;
14138 }
14139
14140
14141 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14142 PyObject *resultobj = 0;
14143 wxLogNull *result = 0 ;
14144
14145 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 result = (wxLogNull *)new wxLogNull();
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14160 PyObject *resultobj = 0;
14161 wxLogNull *arg1 = (wxLogNull *) 0 ;
14162 void *argp1 = 0 ;
14163 int res1 = 0 ;
14164 PyObject *swig_obj[1] ;
14165
14166 if (!args) SWIG_fail;
14167 swig_obj[0] = args;
14168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14169 if (!SWIG_IsOK(res1)) {
14170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14171 }
14172 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 delete arg1;
14176
14177 wxPyEndAllowThreads(__tstate);
14178 if (PyErr_Occurred()) SWIG_fail;
14179 }
14180 resultobj = SWIG_Py_Void();
14181 return resultobj;
14182 fail:
14183 return NULL;
14184 }
14185
14186
14187 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14188 PyObject *obj;
14189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14190 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14191 return SWIG_Py_Void();
14192 }
14193
14194 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14195 return SWIG_Python_InitShadowInstance(args);
14196 }
14197
14198 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14199 PyObject *resultobj = 0;
14200 wxPyLog *result = 0 ;
14201
14202 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14203 {
14204 PyThreadState* __tstate = wxPyBeginAllowThreads();
14205 result = (wxPyLog *)new wxPyLog();
14206 wxPyEndAllowThreads(__tstate);
14207 if (PyErr_Occurred()) SWIG_fail;
14208 }
14209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj = 0;
14218 wxPyLog *arg1 = (wxPyLog *) 0 ;
14219 PyObject *arg2 = (PyObject *) 0 ;
14220 PyObject *arg3 = (PyObject *) 0 ;
14221 void *argp1 = 0 ;
14222 int res1 = 0 ;
14223 PyObject * obj0 = 0 ;
14224 PyObject * obj1 = 0 ;
14225 PyObject * obj2 = 0 ;
14226 char * kwnames[] = {
14227 (char *) "self",(char *) "self",(char *) "_class", NULL
14228 };
14229
14230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14232 if (!SWIG_IsOK(res1)) {
14233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14234 }
14235 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14236 arg2 = obj1;
14237 arg3 = obj2;
14238 {
14239 PyThreadState* __tstate = wxPyBeginAllowThreads();
14240 (arg1)->_setCallbackInfo(arg2,arg3);
14241 wxPyEndAllowThreads(__tstate);
14242 if (PyErr_Occurred()) SWIG_fail;
14243 }
14244 resultobj = SWIG_Py_Void();
14245 return resultobj;
14246 fail:
14247 return NULL;
14248 }
14249
14250
14251 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14252 PyObject *obj;
14253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14254 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14255 return SWIG_Py_Void();
14256 }
14257
14258 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14259 return SWIG_Python_InitShadowInstance(args);
14260 }
14261
14262 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14263 PyObject *resultobj = 0;
14264 int arg1 ;
14265 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14266 int arg3 = (int) wxKILL_NOCHILDREN ;
14267 wxKillError result;
14268 int val1 ;
14269 int ecode1 = 0 ;
14270 int val2 ;
14271 int ecode2 = 0 ;
14272 int val3 ;
14273 int ecode3 = 0 ;
14274 PyObject * obj0 = 0 ;
14275 PyObject * obj1 = 0 ;
14276 PyObject * obj2 = 0 ;
14277 char * kwnames[] = {
14278 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14279 };
14280
14281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14282 ecode1 = SWIG_AsVal_int(obj0, &val1);
14283 if (!SWIG_IsOK(ecode1)) {
14284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14285 }
14286 arg1 = static_cast< int >(val1);
14287 if (obj1) {
14288 ecode2 = SWIG_AsVal_int(obj1, &val2);
14289 if (!SWIG_IsOK(ecode2)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14291 }
14292 arg2 = static_cast< wxSignal >(val2);
14293 }
14294 if (obj2) {
14295 ecode3 = SWIG_AsVal_int(obj2, &val3);
14296 if (!SWIG_IsOK(ecode3)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14298 }
14299 arg3 = static_cast< int >(val3);
14300 }
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 resultobj = SWIG_From_int(static_cast< int >(result));
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14315 PyObject *resultobj = 0;
14316 int arg1 ;
14317 bool result;
14318 int val1 ;
14319 int ecode1 = 0 ;
14320 PyObject * obj0 = 0 ;
14321 char * kwnames[] = {
14322 (char *) "pid", NULL
14323 };
14324
14325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14326 ecode1 = SWIG_AsVal_int(obj0, &val1);
14327 if (!SWIG_IsOK(ecode1)) {
14328 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14329 }
14330 arg1 = static_cast< int >(val1);
14331 {
14332 PyThreadState* __tstate = wxPyBeginAllowThreads();
14333 result = (bool)wxPyProcess::Exists(arg1);
14334 wxPyEndAllowThreads(__tstate);
14335 if (PyErr_Occurred()) SWIG_fail;
14336 }
14337 {
14338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14339 }
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj = 0;
14348 wxString *arg1 = 0 ;
14349 int arg2 = (int) wxEXEC_ASYNC ;
14350 wxPyProcess *result = 0 ;
14351 bool temp1 = false ;
14352 int val2 ;
14353 int ecode2 = 0 ;
14354 PyObject * obj0 = 0 ;
14355 PyObject * obj1 = 0 ;
14356 char * kwnames[] = {
14357 (char *) "cmd",(char *) "flags", NULL
14358 };
14359
14360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14361 {
14362 arg1 = wxString_in_helper(obj0);
14363 if (arg1 == NULL) SWIG_fail;
14364 temp1 = true;
14365 }
14366 if (obj1) {
14367 ecode2 = SWIG_AsVal_int(obj1, &val2);
14368 if (!SWIG_IsOK(ecode2)) {
14369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14370 }
14371 arg2 = static_cast< int >(val2);
14372 }
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14380 {
14381 if (temp1)
14382 delete arg1;
14383 }
14384 return resultobj;
14385 fail:
14386 {
14387 if (temp1)
14388 delete arg1;
14389 }
14390 return NULL;
14391 }
14392
14393
14394 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14395 PyObject *resultobj = 0;
14396 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14397 int arg2 = (int) -1 ;
14398 wxPyProcess *result = 0 ;
14399 void *argp1 = 0 ;
14400 int res1 = 0 ;
14401 int val2 ;
14402 int ecode2 = 0 ;
14403 PyObject * obj0 = 0 ;
14404 PyObject * obj1 = 0 ;
14405 char * kwnames[] = {
14406 (char *) "parent",(char *) "id", NULL
14407 };
14408
14409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14410 if (obj0) {
14411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14412 if (!SWIG_IsOK(res1)) {
14413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14414 }
14415 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14416 }
14417 if (obj1) {
14418 ecode2 = SWIG_AsVal_int(obj1, &val2);
14419 if (!SWIG_IsOK(ecode2)) {
14420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14421 }
14422 arg2 = static_cast< int >(val2);
14423 }
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14438 PyObject *resultobj = 0;
14439 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14440 void *argp1 = 0 ;
14441 int res1 = 0 ;
14442 PyObject *swig_obj[1] ;
14443
14444 if (!args) SWIG_fail;
14445 swig_obj[0] = args;
14446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14447 if (!SWIG_IsOK(res1)) {
14448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14449 }
14450 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14451 {
14452 PyThreadState* __tstate = wxPyBeginAllowThreads();
14453 delete arg1;
14454
14455 wxPyEndAllowThreads(__tstate);
14456 if (PyErr_Occurred()) SWIG_fail;
14457 }
14458 resultobj = SWIG_Py_Void();
14459 return resultobj;
14460 fail:
14461 return NULL;
14462 }
14463
14464
14465 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14466 PyObject *resultobj = 0;
14467 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14468 PyObject *arg2 = (PyObject *) 0 ;
14469 PyObject *arg3 = (PyObject *) 0 ;
14470 void *argp1 = 0 ;
14471 int res1 = 0 ;
14472 PyObject * obj0 = 0 ;
14473 PyObject * obj1 = 0 ;
14474 PyObject * obj2 = 0 ;
14475 char * kwnames[] = {
14476 (char *) "self",(char *) "self",(char *) "_class", NULL
14477 };
14478
14479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14481 if (!SWIG_IsOK(res1)) {
14482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14483 }
14484 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14485 arg2 = obj1;
14486 arg3 = obj2;
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 (arg1)->_setCallbackInfo(arg2,arg3);
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 resultobj = SWIG_Py_Void();
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14501 PyObject *resultobj = 0;
14502 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14503 long result;
14504 void *argp1 = 0 ;
14505 int res1 = 0 ;
14506 PyObject *swig_obj[1] ;
14507
14508 if (!args) SWIG_fail;
14509 swig_obj[0] = args;
14510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14511 if (!SWIG_IsOK(res1)) {
14512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14513 }
14514 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 result = (long)((wxPyProcess const *)arg1)->GetPid();
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = SWIG_From_long(static_cast< long >(result));
14522 return resultobj;
14523 fail:
14524 return NULL;
14525 }
14526
14527
14528 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj = 0;
14530 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14531 int arg2 ;
14532 int arg3 ;
14533 void *argp1 = 0 ;
14534 int res1 = 0 ;
14535 int val2 ;
14536 int ecode2 = 0 ;
14537 int val3 ;
14538 int ecode3 = 0 ;
14539 PyObject * obj0 = 0 ;
14540 PyObject * obj1 = 0 ;
14541 PyObject * obj2 = 0 ;
14542 char * kwnames[] = {
14543 (char *) "self",(char *) "pid",(char *) "status", NULL
14544 };
14545
14546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14548 if (!SWIG_IsOK(res1)) {
14549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14550 }
14551 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14552 ecode2 = SWIG_AsVal_int(obj1, &val2);
14553 if (!SWIG_IsOK(ecode2)) {
14554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14555 }
14556 arg2 = static_cast< int >(val2);
14557 ecode3 = SWIG_AsVal_int(obj2, &val3);
14558 if (!SWIG_IsOK(ecode3)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14560 }
14561 arg3 = static_cast< int >(val3);
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 (arg1)->OnTerminate(arg2,arg3);
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 resultobj = SWIG_Py_Void();
14569 return resultobj;
14570 fail:
14571 return NULL;
14572 }
14573
14574
14575 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14576 PyObject *resultobj = 0;
14577 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14578 void *argp1 = 0 ;
14579 int res1 = 0 ;
14580 PyObject *swig_obj[1] ;
14581
14582 if (!args) SWIG_fail;
14583 swig_obj[0] = args;
14584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14585 if (!SWIG_IsOK(res1)) {
14586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14587 }
14588 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 (arg1)->Redirect();
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = SWIG_Py_Void();
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14603 PyObject *resultobj = 0;
14604 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14605 bool result;
14606 void *argp1 = 0 ;
14607 int res1 = 0 ;
14608 PyObject *swig_obj[1] ;
14609
14610 if (!args) SWIG_fail;
14611 swig_obj[0] = args;
14612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14613 if (!SWIG_IsOK(res1)) {
14614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14615 }
14616 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)(arg1)->IsRedirected();
14620 wxPyEndAllowThreads(__tstate);
14621 if (PyErr_Occurred()) SWIG_fail;
14622 }
14623 {
14624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14625 }
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14633 PyObject *resultobj = 0;
14634 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14635 void *argp1 = 0 ;
14636 int res1 = 0 ;
14637 PyObject *swig_obj[1] ;
14638
14639 if (!args) SWIG_fail;
14640 swig_obj[0] = args;
14641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14642 if (!SWIG_IsOK(res1)) {
14643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14644 }
14645 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14646 {
14647 PyThreadState* __tstate = wxPyBeginAllowThreads();
14648 (arg1)->Detach();
14649 wxPyEndAllowThreads(__tstate);
14650 if (PyErr_Occurred()) SWIG_fail;
14651 }
14652 resultobj = SWIG_Py_Void();
14653 return resultobj;
14654 fail:
14655 return NULL;
14656 }
14657
14658
14659 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14660 PyObject *resultobj = 0;
14661 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14662 wxInputStream *result = 0 ;
14663 void *argp1 = 0 ;
14664 int res1 = 0 ;
14665 PyObject *swig_obj[1] ;
14666
14667 if (!args) SWIG_fail;
14668 swig_obj[0] = args;
14669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14670 if (!SWIG_IsOK(res1)) {
14671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14672 }
14673 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (wxInputStream *)(arg1)->GetInputStream();
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 {
14681 wxPyInputStream * _ptr = NULL;
14682
14683 if (result) {
14684 _ptr = new wxPyInputStream(result);
14685 }
14686 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14687 }
14688 return resultobj;
14689 fail:
14690 return NULL;
14691 }
14692
14693
14694 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14695 PyObject *resultobj = 0;
14696 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14697 wxInputStream *result = 0 ;
14698 void *argp1 = 0 ;
14699 int res1 = 0 ;
14700 PyObject *swig_obj[1] ;
14701
14702 if (!args) SWIG_fail;
14703 swig_obj[0] = args;
14704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14705 if (!SWIG_IsOK(res1)) {
14706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14707 }
14708 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 result = (wxInputStream *)(arg1)->GetErrorStream();
14712 wxPyEndAllowThreads(__tstate);
14713 if (PyErr_Occurred()) SWIG_fail;
14714 }
14715 {
14716 wxPyInputStream * _ptr = NULL;
14717
14718 if (result) {
14719 _ptr = new wxPyInputStream(result);
14720 }
14721 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14722 }
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 PyObject *resultobj = 0;
14731 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14732 wxOutputStream *result = 0 ;
14733 void *argp1 = 0 ;
14734 int res1 = 0 ;
14735 PyObject *swig_obj[1] ;
14736
14737 if (!args) SWIG_fail;
14738 swig_obj[0] = args;
14739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14740 if (!SWIG_IsOK(res1)) {
14741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14742 }
14743 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (wxOutputStream *)(arg1)->GetOutputStream();
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14751 return resultobj;
14752 fail:
14753 return NULL;
14754 }
14755
14756
14757 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14758 PyObject *resultobj = 0;
14759 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14760 void *argp1 = 0 ;
14761 int res1 = 0 ;
14762 PyObject *swig_obj[1] ;
14763
14764 if (!args) SWIG_fail;
14765 swig_obj[0] = args;
14766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14767 if (!SWIG_IsOK(res1)) {
14768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14769 }
14770 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14771 {
14772 PyThreadState* __tstate = wxPyBeginAllowThreads();
14773 (arg1)->CloseOutput();
14774 wxPyEndAllowThreads(__tstate);
14775 if (PyErr_Occurred()) SWIG_fail;
14776 }
14777 resultobj = SWIG_Py_Void();
14778 return resultobj;
14779 fail:
14780 return NULL;
14781 }
14782
14783
14784 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14785 PyObject *resultobj = 0;
14786 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14787 bool result;
14788 void *argp1 = 0 ;
14789 int res1 = 0 ;
14790 PyObject *swig_obj[1] ;
14791
14792 if (!args) SWIG_fail;
14793 swig_obj[0] = args;
14794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14795 if (!SWIG_IsOK(res1)) {
14796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14797 }
14798 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14799 {
14800 PyThreadState* __tstate = wxPyBeginAllowThreads();
14801 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14802 wxPyEndAllowThreads(__tstate);
14803 if (PyErr_Occurred()) SWIG_fail;
14804 }
14805 {
14806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14807 }
14808 return resultobj;
14809 fail:
14810 return NULL;
14811 }
14812
14813
14814 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14815 PyObject *resultobj = 0;
14816 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14817 bool result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 PyObject *swig_obj[1] ;
14821
14822 if (!args) SWIG_fail;
14823 swig_obj[0] = args;
14824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14825 if (!SWIG_IsOK(res1)) {
14826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14827 }
14828 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14829 {
14830 PyThreadState* __tstate = wxPyBeginAllowThreads();
14831 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14832 wxPyEndAllowThreads(__tstate);
14833 if (PyErr_Occurred()) SWIG_fail;
14834 }
14835 {
14836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14837 }
14838 return resultobj;
14839 fail:
14840 return NULL;
14841 }
14842
14843
14844 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14845 PyObject *resultobj = 0;
14846 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14847 bool result;
14848 void *argp1 = 0 ;
14849 int res1 = 0 ;
14850 PyObject *swig_obj[1] ;
14851
14852 if (!args) SWIG_fail;
14853 swig_obj[0] = args;
14854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14855 if (!SWIG_IsOK(res1)) {
14856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14857 }
14858 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 {
14866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14867 }
14868 return resultobj;
14869 fail:
14870 return NULL;
14871 }
14872
14873
14874 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14875 PyObject *obj;
14876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14877 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14878 return SWIG_Py_Void();
14879 }
14880
14881 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14882 return SWIG_Python_InitShadowInstance(args);
14883 }
14884
14885 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14886 PyObject *resultobj = 0;
14887 int arg1 = (int) 0 ;
14888 int arg2 = (int) 0 ;
14889 int arg3 = (int) 0 ;
14890 wxProcessEvent *result = 0 ;
14891 int val1 ;
14892 int ecode1 = 0 ;
14893 int val2 ;
14894 int ecode2 = 0 ;
14895 int val3 ;
14896 int ecode3 = 0 ;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 PyObject * obj2 = 0 ;
14900 char * kwnames[] = {
14901 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14902 };
14903
14904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14905 if (obj0) {
14906 ecode1 = SWIG_AsVal_int(obj0, &val1);
14907 if (!SWIG_IsOK(ecode1)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14909 }
14910 arg1 = static_cast< int >(val1);
14911 }
14912 if (obj1) {
14913 ecode2 = SWIG_AsVal_int(obj1, &val2);
14914 if (!SWIG_IsOK(ecode2)) {
14915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14916 }
14917 arg2 = static_cast< int >(val2);
14918 }
14919 if (obj2) {
14920 ecode3 = SWIG_AsVal_int(obj2, &val3);
14921 if (!SWIG_IsOK(ecode3)) {
14922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14923 }
14924 arg3 = static_cast< int >(val3);
14925 }
14926 {
14927 PyThreadState* __tstate = wxPyBeginAllowThreads();
14928 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14933 return resultobj;
14934 fail:
14935 return NULL;
14936 }
14937
14938
14939 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14940 PyObject *resultobj = 0;
14941 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14942 int result;
14943 void *argp1 = 0 ;
14944 int res1 = 0 ;
14945 PyObject *swig_obj[1] ;
14946
14947 if (!args) SWIG_fail;
14948 swig_obj[0] = args;
14949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14950 if (!SWIG_IsOK(res1)) {
14951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14952 }
14953 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 result = (int)(arg1)->GetPid();
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 resultobj = SWIG_From_int(static_cast< int >(result));
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14968 PyObject *resultobj = 0;
14969 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14970 int result;
14971 void *argp1 = 0 ;
14972 int res1 = 0 ;
14973 PyObject *swig_obj[1] ;
14974
14975 if (!args) SWIG_fail;
14976 swig_obj[0] = args;
14977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14978 if (!SWIG_IsOK(res1)) {
14979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14980 }
14981 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14982 {
14983 PyThreadState* __tstate = wxPyBeginAllowThreads();
14984 result = (int)(arg1)->GetExitCode();
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 resultobj = SWIG_From_int(static_cast< int >(result));
14989 return resultobj;
14990 fail:
14991 return NULL;
14992 }
14993
14994
14995 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14996 PyObject *resultobj = 0;
14997 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14998 int arg2 ;
14999 void *argp1 = 0 ;
15000 int res1 = 0 ;
15001 int val2 ;
15002 int ecode2 = 0 ;
15003 PyObject *swig_obj[2] ;
15004
15005 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
15006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15007 if (!SWIG_IsOK(res1)) {
15008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15009 }
15010 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15011 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15012 if (!SWIG_IsOK(ecode2)) {
15013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
15014 }
15015 arg2 = static_cast< int >(val2);
15016 if (arg1) (arg1)->m_pid = arg2;
15017
15018 resultobj = SWIG_Py_Void();
15019 return resultobj;
15020 fail:
15021 return NULL;
15022 }
15023
15024
15025 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15026 PyObject *resultobj = 0;
15027 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15028 int result;
15029 void *argp1 = 0 ;
15030 int res1 = 0 ;
15031 PyObject *swig_obj[1] ;
15032
15033 if (!args) SWIG_fail;
15034 swig_obj[0] = args;
15035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15036 if (!SWIG_IsOK(res1)) {
15037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15038 }
15039 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15040 result = (int) ((arg1)->m_pid);
15041 resultobj = SWIG_From_int(static_cast< int >(result));
15042 return resultobj;
15043 fail:
15044 return NULL;
15045 }
15046
15047
15048 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15049 PyObject *resultobj = 0;
15050 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15051 int arg2 ;
15052 void *argp1 = 0 ;
15053 int res1 = 0 ;
15054 int val2 ;
15055 int ecode2 = 0 ;
15056 PyObject *swig_obj[2] ;
15057
15058 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15060 if (!SWIG_IsOK(res1)) {
15061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15062 }
15063 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15064 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15065 if (!SWIG_IsOK(ecode2)) {
15066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15067 }
15068 arg2 = static_cast< int >(val2);
15069 if (arg1) (arg1)->m_exitcode = arg2;
15070
15071 resultobj = SWIG_Py_Void();
15072 return resultobj;
15073 fail:
15074 return NULL;
15075 }
15076
15077
15078 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15079 PyObject *resultobj = 0;
15080 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15081 int result;
15082 void *argp1 = 0 ;
15083 int res1 = 0 ;
15084 PyObject *swig_obj[1] ;
15085
15086 if (!args) SWIG_fail;
15087 swig_obj[0] = args;
15088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15089 if (!SWIG_IsOK(res1)) {
15090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15091 }
15092 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15093 result = (int) ((arg1)->m_exitcode);
15094 resultobj = SWIG_From_int(static_cast< int >(result));
15095 return resultobj;
15096 fail:
15097 return NULL;
15098 }
15099
15100
15101 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15102 PyObject *obj;
15103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15104 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15105 return SWIG_Py_Void();
15106 }
15107
15108 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15109 return SWIG_Python_InitShadowInstance(args);
15110 }
15111
15112 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj = 0;
15114 wxString *arg1 = 0 ;
15115 int arg2 = (int) wxEXEC_ASYNC ;
15116 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15117 long result;
15118 bool temp1 = false ;
15119 int val2 ;
15120 int ecode2 = 0 ;
15121 void *argp3 = 0 ;
15122 int res3 = 0 ;
15123 PyObject * obj0 = 0 ;
15124 PyObject * obj1 = 0 ;
15125 PyObject * obj2 = 0 ;
15126 char * kwnames[] = {
15127 (char *) "command",(char *) "flags",(char *) "process", NULL
15128 };
15129
15130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15131 {
15132 arg1 = wxString_in_helper(obj0);
15133 if (arg1 == NULL) SWIG_fail;
15134 temp1 = true;
15135 }
15136 if (obj1) {
15137 ecode2 = SWIG_AsVal_int(obj1, &val2);
15138 if (!SWIG_IsOK(ecode2)) {
15139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15140 }
15141 arg2 = static_cast< int >(val2);
15142 }
15143 if (obj2) {
15144 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15145 if (!SWIG_IsOK(res3)) {
15146 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15147 }
15148 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15149 }
15150 {
15151 if (!wxPyCheckForApp()) SWIG_fail;
15152 PyThreadState* __tstate = wxPyBeginAllowThreads();
15153 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 resultobj = SWIG_From_long(static_cast< long >(result));
15158 {
15159 if (temp1)
15160 delete arg1;
15161 }
15162 return resultobj;
15163 fail:
15164 {
15165 if (temp1)
15166 delete arg1;
15167 }
15168 return NULL;
15169 }
15170
15171
15172 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj = 0;
15174 long arg1 ;
15175 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15176 wxKillError *arg3 = (wxKillError *) 0 ;
15177 int arg4 = (int) wxKILL_NOCHILDREN ;
15178 int result;
15179 long val1 ;
15180 int ecode1 = 0 ;
15181 int val2 ;
15182 int ecode2 = 0 ;
15183 wxKillError temp3 ;
15184 int val4 ;
15185 int ecode4 = 0 ;
15186 PyObject * obj0 = 0 ;
15187 PyObject * obj1 = 0 ;
15188 PyObject * obj2 = 0 ;
15189 char * kwnames[] = {
15190 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15191 };
15192
15193 {
15194 arg3 = &temp3;
15195 }
15196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15197 ecode1 = SWIG_AsVal_long(obj0, &val1);
15198 if (!SWIG_IsOK(ecode1)) {
15199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15200 }
15201 arg1 = static_cast< long >(val1);
15202 if (obj1) {
15203 ecode2 = SWIG_AsVal_int(obj1, &val2);
15204 if (!SWIG_IsOK(ecode2)) {
15205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15206 }
15207 arg2 = static_cast< wxSignal >(val2);
15208 }
15209 if (obj2) {
15210 ecode4 = SWIG_AsVal_int(obj2, &val4);
15211 if (!SWIG_IsOK(ecode4)) {
15212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15213 }
15214 arg4 = static_cast< int >(val4);
15215 }
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (int)wxKill(arg1,arg2,arg3,arg4);
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_From_int(static_cast< int >(result));
15223 {
15224 PyObject* o;
15225 o = PyInt_FromLong((long) (*arg3));
15226
15227
15228
15229 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15230
15231 }
15232 return resultobj;
15233 fail:
15234 return NULL;
15235 }
15236
15237
15238 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15239 PyObject *resultobj = 0;
15240 int arg1 = (int) wxJOYSTICK1 ;
15241 wxJoystick *result = 0 ;
15242 int val1 ;
15243 int ecode1 = 0 ;
15244 PyObject * obj0 = 0 ;
15245 char * kwnames[] = {
15246 (char *) "joystick", NULL
15247 };
15248
15249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15250 if (obj0) {
15251 ecode1 = SWIG_AsVal_int(obj0, &val1);
15252 if (!SWIG_IsOK(ecode1)) {
15253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15254 }
15255 arg1 = static_cast< int >(val1);
15256 }
15257 {
15258 if (!wxPyCheckForApp()) SWIG_fail;
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 result = (wxJoystick *)new wxJoystick(arg1);
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 wxJoystick *arg1 = (wxJoystick *) 0 ;
15274 void *argp1 = 0 ;
15275 int res1 = 0 ;
15276 PyObject *swig_obj[1] ;
15277
15278 if (!args) SWIG_fail;
15279 swig_obj[0] = args;
15280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15281 if (!SWIG_IsOK(res1)) {
15282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15283 }
15284 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 delete arg1;
15288
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_Py_Void();
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300 PyObject *resultobj = 0;
15301 wxJoystick *arg1 = (wxJoystick *) 0 ;
15302 wxPoint result;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 PyObject *swig_obj[1] ;
15306
15307 if (!args) SWIG_fail;
15308 swig_obj[0] = args;
15309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15310 if (!SWIG_IsOK(res1)) {
15311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15312 }
15313 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 result = (arg1)->GetPosition();
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15321 return resultobj;
15322 fail:
15323 return NULL;
15324 }
15325
15326
15327 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15328 PyObject *resultobj = 0;
15329 wxJoystick *arg1 = (wxJoystick *) 0 ;
15330 int result;
15331 void *argp1 = 0 ;
15332 int res1 = 0 ;
15333 PyObject *swig_obj[1] ;
15334
15335 if (!args) SWIG_fail;
15336 swig_obj[0] = args;
15337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15340 }
15341 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (int)(arg1)->GetZPosition();
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 resultobj = SWIG_From_int(static_cast< int >(result));
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15356 PyObject *resultobj = 0;
15357 wxJoystick *arg1 = (wxJoystick *) 0 ;
15358 int result;
15359 void *argp1 = 0 ;
15360 int res1 = 0 ;
15361 PyObject *swig_obj[1] ;
15362
15363 if (!args) SWIG_fail;
15364 swig_obj[0] = args;
15365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15366 if (!SWIG_IsOK(res1)) {
15367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15368 }
15369 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (int)(arg1)->GetButtonState();
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = SWIG_From_int(static_cast< int >(result));
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxJoystick *arg1 = (wxJoystick *) 0 ;
15386 int result;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15396 }
15397 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (int)(arg1)->GetPOVPosition();
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = SWIG_From_int(static_cast< int >(result));
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15412 PyObject *resultobj = 0;
15413 wxJoystick *arg1 = (wxJoystick *) 0 ;
15414 int result;
15415 void *argp1 = 0 ;
15416 int res1 = 0 ;
15417 PyObject *swig_obj[1] ;
15418
15419 if (!args) SWIG_fail;
15420 swig_obj[0] = args;
15421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15422 if (!SWIG_IsOK(res1)) {
15423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15424 }
15425 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15426 {
15427 PyThreadState* __tstate = wxPyBeginAllowThreads();
15428 result = (int)(arg1)->GetPOVCTSPosition();
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 resultobj = SWIG_From_int(static_cast< int >(result));
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440 PyObject *resultobj = 0;
15441 wxJoystick *arg1 = (wxJoystick *) 0 ;
15442 int result;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 PyObject *swig_obj[1] ;
15446
15447 if (!args) SWIG_fail;
15448 swig_obj[0] = args;
15449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15450 if (!SWIG_IsOK(res1)) {
15451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15452 }
15453 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15454 {
15455 PyThreadState* __tstate = wxPyBeginAllowThreads();
15456 result = (int)(arg1)->GetRudderPosition();
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 resultobj = SWIG_From_int(static_cast< int >(result));
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15468 PyObject *resultobj = 0;
15469 wxJoystick *arg1 = (wxJoystick *) 0 ;
15470 int result;
15471 void *argp1 = 0 ;
15472 int res1 = 0 ;
15473 PyObject *swig_obj[1] ;
15474
15475 if (!args) SWIG_fail;
15476 swig_obj[0] = args;
15477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15478 if (!SWIG_IsOK(res1)) {
15479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15480 }
15481 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (int)(arg1)->GetUPosition();
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 resultobj = SWIG_From_int(static_cast< int >(result));
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15496 PyObject *resultobj = 0;
15497 wxJoystick *arg1 = (wxJoystick *) 0 ;
15498 int result;
15499 void *argp1 = 0 ;
15500 int res1 = 0 ;
15501 PyObject *swig_obj[1] ;
15502
15503 if (!args) SWIG_fail;
15504 swig_obj[0] = args;
15505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15506 if (!SWIG_IsOK(res1)) {
15507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15508 }
15509 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 result = (int)(arg1)->GetVPosition();
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_From_int(static_cast< int >(result));
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15524 PyObject *resultobj = 0;
15525 wxJoystick *arg1 = (wxJoystick *) 0 ;
15526 int result;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 PyObject *swig_obj[1] ;
15530
15531 if (!args) SWIG_fail;
15532 swig_obj[0] = args;
15533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15536 }
15537 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15538 {
15539 PyThreadState* __tstate = wxPyBeginAllowThreads();
15540 result = (int)(arg1)->GetMovementThreshold();
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 resultobj = SWIG_From_int(static_cast< int >(result));
15545 return resultobj;
15546 fail:
15547 return NULL;
15548 }
15549
15550
15551 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15552 PyObject *resultobj = 0;
15553 wxJoystick *arg1 = (wxJoystick *) 0 ;
15554 int arg2 ;
15555 void *argp1 = 0 ;
15556 int res1 = 0 ;
15557 int val2 ;
15558 int ecode2 = 0 ;
15559 PyObject * obj0 = 0 ;
15560 PyObject * obj1 = 0 ;
15561 char * kwnames[] = {
15562 (char *) "self",(char *) "threshold", NULL
15563 };
15564
15565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15569 }
15570 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15571 ecode2 = SWIG_AsVal_int(obj1, &val2);
15572 if (!SWIG_IsOK(ecode2)) {
15573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15574 }
15575 arg2 = static_cast< int >(val2);
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 (arg1)->SetMovementThreshold(arg2);
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 resultobj = SWIG_Py_Void();
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15590 PyObject *resultobj = 0;
15591 wxJoystick *arg1 = (wxJoystick *) 0 ;
15592 bool result;
15593 void *argp1 = 0 ;
15594 int res1 = 0 ;
15595 PyObject *swig_obj[1] ;
15596
15597 if (!args) SWIG_fail;
15598 swig_obj[0] = args;
15599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15602 }
15603 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15604 {
15605 PyThreadState* __tstate = wxPyBeginAllowThreads();
15606 result = (bool)(arg1)->IsOk();
15607 wxPyEndAllowThreads(__tstate);
15608 if (PyErr_Occurred()) SWIG_fail;
15609 }
15610 {
15611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15612 }
15613 return resultobj;
15614 fail:
15615 return NULL;
15616 }
15617
15618
15619 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15620 PyObject *resultobj = 0;
15621 wxJoystick *arg1 = (wxJoystick *) 0 ;
15622 int result;
15623 void *argp1 = 0 ;
15624 int res1 = 0 ;
15625 PyObject *swig_obj[1] ;
15626
15627 if (!args) SWIG_fail;
15628 swig_obj[0] = args;
15629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15630 if (!SWIG_IsOK(res1)) {
15631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15632 }
15633 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = (int)(arg1)->GetNumberJoysticks();
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 resultobj = SWIG_From_int(static_cast< int >(result));
15641 return resultobj;
15642 fail:
15643 return NULL;
15644 }
15645
15646
15647 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15648 PyObject *resultobj = 0;
15649 wxJoystick *arg1 = (wxJoystick *) 0 ;
15650 int result;
15651 void *argp1 = 0 ;
15652 int res1 = 0 ;
15653 PyObject *swig_obj[1] ;
15654
15655 if (!args) SWIG_fail;
15656 swig_obj[0] = args;
15657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15658 if (!SWIG_IsOK(res1)) {
15659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15660 }
15661 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (int)(arg1)->GetManufacturerId();
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 resultobj = SWIG_From_int(static_cast< int >(result));
15669 return resultobj;
15670 fail:
15671 return NULL;
15672 }
15673
15674
15675 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15676 PyObject *resultobj = 0;
15677 wxJoystick *arg1 = (wxJoystick *) 0 ;
15678 int result;
15679 void *argp1 = 0 ;
15680 int res1 = 0 ;
15681 PyObject *swig_obj[1] ;
15682
15683 if (!args) SWIG_fail;
15684 swig_obj[0] = args;
15685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15686 if (!SWIG_IsOK(res1)) {
15687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15688 }
15689 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 result = (int)(arg1)->GetProductId();
15693 wxPyEndAllowThreads(__tstate);
15694 if (PyErr_Occurred()) SWIG_fail;
15695 }
15696 resultobj = SWIG_From_int(static_cast< int >(result));
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15704 PyObject *resultobj = 0;
15705 wxJoystick *arg1 = (wxJoystick *) 0 ;
15706 wxString result;
15707 void *argp1 = 0 ;
15708 int res1 = 0 ;
15709 PyObject *swig_obj[1] ;
15710
15711 if (!args) SWIG_fail;
15712 swig_obj[0] = args;
15713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15714 if (!SWIG_IsOK(res1)) {
15715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15716 }
15717 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15718 {
15719 PyThreadState* __tstate = wxPyBeginAllowThreads();
15720 result = (arg1)->GetProductName();
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 {
15725 #if wxUSE_UNICODE
15726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15727 #else
15728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15729 #endif
15730 }
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxJoystick *arg1 = (wxJoystick *) 0 ;
15740 int result;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 PyObject *swig_obj[1] ;
15744
15745 if (!args) SWIG_fail;
15746 swig_obj[0] = args;
15747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15750 }
15751 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (int)(arg1)->GetXMin();
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_From_int(static_cast< int >(result));
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxJoystick *arg1 = (wxJoystick *) 0 ;
15768 int result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15778 }
15779 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (int)(arg1)->GetYMin();
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_From_int(static_cast< int >(result));
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxJoystick *arg1 = (wxJoystick *) 0 ;
15796 int result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15806 }
15807 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (int)(arg1)->GetZMin();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_From_int(static_cast< int >(result));
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxJoystick *arg1 = (wxJoystick *) 0 ;
15824 int result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15834 }
15835 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (int)(arg1)->GetXMax();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_int(static_cast< int >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15850 PyObject *resultobj = 0;
15851 wxJoystick *arg1 = (wxJoystick *) 0 ;
15852 int result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 PyObject *swig_obj[1] ;
15856
15857 if (!args) SWIG_fail;
15858 swig_obj[0] = args;
15859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15860 if (!SWIG_IsOK(res1)) {
15861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15862 }
15863 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (int)(arg1)->GetYMax();
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_From_int(static_cast< int >(result));
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxJoystick *arg1 = (wxJoystick *) 0 ;
15880 int result;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 PyObject *swig_obj[1] ;
15884
15885 if (!args) SWIG_fail;
15886 swig_obj[0] = args;
15887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15890 }
15891 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (int)(arg1)->GetZMax();
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_From_int(static_cast< int >(result));
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15906 PyObject *resultobj = 0;
15907 wxJoystick *arg1 = (wxJoystick *) 0 ;
15908 int result;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 PyObject *swig_obj[1] ;
15912
15913 if (!args) SWIG_fail;
15914 swig_obj[0] = args;
15915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15918 }
15919 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (int)(arg1)->GetNumberButtons();
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 resultobj = SWIG_From_int(static_cast< int >(result));
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15934 PyObject *resultobj = 0;
15935 wxJoystick *arg1 = (wxJoystick *) 0 ;
15936 int result;
15937 void *argp1 = 0 ;
15938 int res1 = 0 ;
15939 PyObject *swig_obj[1] ;
15940
15941 if (!args) SWIG_fail;
15942 swig_obj[0] = args;
15943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15946 }
15947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (int)(arg1)->GetNumberAxes();
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_From_int(static_cast< int >(result));
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxJoystick *arg1 = (wxJoystick *) 0 ;
15964 int result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject *swig_obj[1] ;
15968
15969 if (!args) SWIG_fail;
15970 swig_obj[0] = args;
15971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15974 }
15975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 result = (int)(arg1)->GetMaxButtons();
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 resultobj = SWIG_From_int(static_cast< int >(result));
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15990 PyObject *resultobj = 0;
15991 wxJoystick *arg1 = (wxJoystick *) 0 ;
15992 int result;
15993 void *argp1 = 0 ;
15994 int res1 = 0 ;
15995 PyObject *swig_obj[1] ;
15996
15997 if (!args) SWIG_fail;
15998 swig_obj[0] = args;
15999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
16002 }
16003 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (int)(arg1)->GetMaxAxes();
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 resultobj = SWIG_From_int(static_cast< int >(result));
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16018 PyObject *resultobj = 0;
16019 wxJoystick *arg1 = (wxJoystick *) 0 ;
16020 int result;
16021 void *argp1 = 0 ;
16022 int res1 = 0 ;
16023 PyObject *swig_obj[1] ;
16024
16025 if (!args) SWIG_fail;
16026 swig_obj[0] = args;
16027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16028 if (!SWIG_IsOK(res1)) {
16029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16030 }
16031 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 result = (int)(arg1)->GetPollingMin();
16035 wxPyEndAllowThreads(__tstate);
16036 if (PyErr_Occurred()) SWIG_fail;
16037 }
16038 resultobj = SWIG_From_int(static_cast< int >(result));
16039 return resultobj;
16040 fail:
16041 return NULL;
16042 }
16043
16044
16045 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16046 PyObject *resultobj = 0;
16047 wxJoystick *arg1 = (wxJoystick *) 0 ;
16048 int result;
16049 void *argp1 = 0 ;
16050 int res1 = 0 ;
16051 PyObject *swig_obj[1] ;
16052
16053 if (!args) SWIG_fail;
16054 swig_obj[0] = args;
16055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16056 if (!SWIG_IsOK(res1)) {
16057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16058 }
16059 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16060 {
16061 PyThreadState* __tstate = wxPyBeginAllowThreads();
16062 result = (int)(arg1)->GetPollingMax();
16063 wxPyEndAllowThreads(__tstate);
16064 if (PyErr_Occurred()) SWIG_fail;
16065 }
16066 resultobj = SWIG_From_int(static_cast< int >(result));
16067 return resultobj;
16068 fail:
16069 return NULL;
16070 }
16071
16072
16073 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16074 PyObject *resultobj = 0;
16075 wxJoystick *arg1 = (wxJoystick *) 0 ;
16076 int result;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 PyObject *swig_obj[1] ;
16080
16081 if (!args) SWIG_fail;
16082 swig_obj[0] = args;
16083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16084 if (!SWIG_IsOK(res1)) {
16085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16086 }
16087 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16088 {
16089 PyThreadState* __tstate = wxPyBeginAllowThreads();
16090 result = (int)(arg1)->GetRudderMin();
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = SWIG_From_int(static_cast< int >(result));
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16102 PyObject *resultobj = 0;
16103 wxJoystick *arg1 = (wxJoystick *) 0 ;
16104 int result;
16105 void *argp1 = 0 ;
16106 int res1 = 0 ;
16107 PyObject *swig_obj[1] ;
16108
16109 if (!args) SWIG_fail;
16110 swig_obj[0] = args;
16111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16112 if (!SWIG_IsOK(res1)) {
16113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16114 }
16115 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16116 {
16117 PyThreadState* __tstate = wxPyBeginAllowThreads();
16118 result = (int)(arg1)->GetRudderMax();
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 resultobj = SWIG_From_int(static_cast< int >(result));
16123 return resultobj;
16124 fail:
16125 return NULL;
16126 }
16127
16128
16129 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16130 PyObject *resultobj = 0;
16131 wxJoystick *arg1 = (wxJoystick *) 0 ;
16132 int result;
16133 void *argp1 = 0 ;
16134 int res1 = 0 ;
16135 PyObject *swig_obj[1] ;
16136
16137 if (!args) SWIG_fail;
16138 swig_obj[0] = args;
16139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16140 if (!SWIG_IsOK(res1)) {
16141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16142 }
16143 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 result = (int)(arg1)->GetUMin();
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 resultobj = SWIG_From_int(static_cast< int >(result));
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16158 PyObject *resultobj = 0;
16159 wxJoystick *arg1 = (wxJoystick *) 0 ;
16160 int result;
16161 void *argp1 = 0 ;
16162 int res1 = 0 ;
16163 PyObject *swig_obj[1] ;
16164
16165 if (!args) SWIG_fail;
16166 swig_obj[0] = args;
16167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16168 if (!SWIG_IsOK(res1)) {
16169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16170 }
16171 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16172 {
16173 PyThreadState* __tstate = wxPyBeginAllowThreads();
16174 result = (int)(arg1)->GetUMax();
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 resultobj = SWIG_From_int(static_cast< int >(result));
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16186 PyObject *resultobj = 0;
16187 wxJoystick *arg1 = (wxJoystick *) 0 ;
16188 int result;
16189 void *argp1 = 0 ;
16190 int res1 = 0 ;
16191 PyObject *swig_obj[1] ;
16192
16193 if (!args) SWIG_fail;
16194 swig_obj[0] = args;
16195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16196 if (!SWIG_IsOK(res1)) {
16197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16198 }
16199 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 result = (int)(arg1)->GetVMin();
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_From_int(static_cast< int >(result));
16207 return resultobj;
16208 fail:
16209 return NULL;
16210 }
16211
16212
16213 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16214 PyObject *resultobj = 0;
16215 wxJoystick *arg1 = (wxJoystick *) 0 ;
16216 int result;
16217 void *argp1 = 0 ;
16218 int res1 = 0 ;
16219 PyObject *swig_obj[1] ;
16220
16221 if (!args) SWIG_fail;
16222 swig_obj[0] = args;
16223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16226 }
16227 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16228 {
16229 PyThreadState* __tstate = wxPyBeginAllowThreads();
16230 result = (int)(arg1)->GetVMax();
16231 wxPyEndAllowThreads(__tstate);
16232 if (PyErr_Occurred()) SWIG_fail;
16233 }
16234 resultobj = SWIG_From_int(static_cast< int >(result));
16235 return resultobj;
16236 fail:
16237 return NULL;
16238 }
16239
16240
16241 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16242 PyObject *resultobj = 0;
16243 wxJoystick *arg1 = (wxJoystick *) 0 ;
16244 bool result;
16245 void *argp1 = 0 ;
16246 int res1 = 0 ;
16247 PyObject *swig_obj[1] ;
16248
16249 if (!args) SWIG_fail;
16250 swig_obj[0] = args;
16251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16252 if (!SWIG_IsOK(res1)) {
16253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16254 }
16255 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16256 {
16257 PyThreadState* __tstate = wxPyBeginAllowThreads();
16258 result = (bool)(arg1)->HasRudder();
16259 wxPyEndAllowThreads(__tstate);
16260 if (PyErr_Occurred()) SWIG_fail;
16261 }
16262 {
16263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16264 }
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16272 PyObject *resultobj = 0;
16273 wxJoystick *arg1 = (wxJoystick *) 0 ;
16274 bool result;
16275 void *argp1 = 0 ;
16276 int res1 = 0 ;
16277 PyObject *swig_obj[1] ;
16278
16279 if (!args) SWIG_fail;
16280 swig_obj[0] = args;
16281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16282 if (!SWIG_IsOK(res1)) {
16283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16284 }
16285 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16286 {
16287 PyThreadState* __tstate = wxPyBeginAllowThreads();
16288 result = (bool)(arg1)->HasZ();
16289 wxPyEndAllowThreads(__tstate);
16290 if (PyErr_Occurred()) SWIG_fail;
16291 }
16292 {
16293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16294 }
16295 return resultobj;
16296 fail:
16297 return NULL;
16298 }
16299
16300
16301 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16302 PyObject *resultobj = 0;
16303 wxJoystick *arg1 = (wxJoystick *) 0 ;
16304 bool result;
16305 void *argp1 = 0 ;
16306 int res1 = 0 ;
16307 PyObject *swig_obj[1] ;
16308
16309 if (!args) SWIG_fail;
16310 swig_obj[0] = args;
16311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16312 if (!SWIG_IsOK(res1)) {
16313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16314 }
16315 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 result = (bool)(arg1)->HasU();
16319 wxPyEndAllowThreads(__tstate);
16320 if (PyErr_Occurred()) SWIG_fail;
16321 }
16322 {
16323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16324 }
16325 return resultobj;
16326 fail:
16327 return NULL;
16328 }
16329
16330
16331 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16332 PyObject *resultobj = 0;
16333 wxJoystick *arg1 = (wxJoystick *) 0 ;
16334 bool result;
16335 void *argp1 = 0 ;
16336 int res1 = 0 ;
16337 PyObject *swig_obj[1] ;
16338
16339 if (!args) SWIG_fail;
16340 swig_obj[0] = args;
16341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16342 if (!SWIG_IsOK(res1)) {
16343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16344 }
16345 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16346 {
16347 PyThreadState* __tstate = wxPyBeginAllowThreads();
16348 result = (bool)(arg1)->HasV();
16349 wxPyEndAllowThreads(__tstate);
16350 if (PyErr_Occurred()) SWIG_fail;
16351 }
16352 {
16353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16354 }
16355 return resultobj;
16356 fail:
16357 return NULL;
16358 }
16359
16360
16361 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16362 PyObject *resultobj = 0;
16363 wxJoystick *arg1 = (wxJoystick *) 0 ;
16364 bool result;
16365 void *argp1 = 0 ;
16366 int res1 = 0 ;
16367 PyObject *swig_obj[1] ;
16368
16369 if (!args) SWIG_fail;
16370 swig_obj[0] = args;
16371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16372 if (!SWIG_IsOK(res1)) {
16373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16374 }
16375 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16376 {
16377 PyThreadState* __tstate = wxPyBeginAllowThreads();
16378 result = (bool)(arg1)->HasPOV();
16379 wxPyEndAllowThreads(__tstate);
16380 if (PyErr_Occurred()) SWIG_fail;
16381 }
16382 {
16383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16384 }
16385 return resultobj;
16386 fail:
16387 return NULL;
16388 }
16389
16390
16391 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16392 PyObject *resultobj = 0;
16393 wxJoystick *arg1 = (wxJoystick *) 0 ;
16394 bool result;
16395 void *argp1 = 0 ;
16396 int res1 = 0 ;
16397 PyObject *swig_obj[1] ;
16398
16399 if (!args) SWIG_fail;
16400 swig_obj[0] = args;
16401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16404 }
16405 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16406 {
16407 PyThreadState* __tstate = wxPyBeginAllowThreads();
16408 result = (bool)(arg1)->HasPOV4Dir();
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 {
16413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16414 }
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16422 PyObject *resultobj = 0;
16423 wxJoystick *arg1 = (wxJoystick *) 0 ;
16424 bool result;
16425 void *argp1 = 0 ;
16426 int res1 = 0 ;
16427 PyObject *swig_obj[1] ;
16428
16429 if (!args) SWIG_fail;
16430 swig_obj[0] = args;
16431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16432 if (!SWIG_IsOK(res1)) {
16433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16434 }
16435 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16436 {
16437 PyThreadState* __tstate = wxPyBeginAllowThreads();
16438 result = (bool)(arg1)->HasPOVCTS();
16439 wxPyEndAllowThreads(__tstate);
16440 if (PyErr_Occurred()) SWIG_fail;
16441 }
16442 {
16443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16444 }
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj = 0;
16453 wxJoystick *arg1 = (wxJoystick *) 0 ;
16454 wxWindow *arg2 = (wxWindow *) 0 ;
16455 int arg3 = (int) 0 ;
16456 bool result;
16457 void *argp1 = 0 ;
16458 int res1 = 0 ;
16459 void *argp2 = 0 ;
16460 int res2 = 0 ;
16461 int val3 ;
16462 int ecode3 = 0 ;
16463 PyObject * obj0 = 0 ;
16464 PyObject * obj1 = 0 ;
16465 PyObject * obj2 = 0 ;
16466 char * kwnames[] = {
16467 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16468 };
16469
16470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16472 if (!SWIG_IsOK(res1)) {
16473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16474 }
16475 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16477 if (!SWIG_IsOK(res2)) {
16478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16479 }
16480 arg2 = reinterpret_cast< wxWindow * >(argp2);
16481 if (obj2) {
16482 ecode3 = SWIG_AsVal_int(obj2, &val3);
16483 if (!SWIG_IsOK(ecode3)) {
16484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16485 }
16486 arg3 = static_cast< int >(val3);
16487 }
16488 {
16489 PyThreadState* __tstate = wxPyBeginAllowThreads();
16490 result = (bool)(arg1)->SetCapture(arg2,arg3);
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 {
16495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16496 }
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16504 PyObject *resultobj = 0;
16505 wxJoystick *arg1 = (wxJoystick *) 0 ;
16506 bool result;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 PyObject *swig_obj[1] ;
16510
16511 if (!args) SWIG_fail;
16512 swig_obj[0] = args;
16513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16514 if (!SWIG_IsOK(res1)) {
16515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16516 }
16517 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16518 {
16519 PyThreadState* __tstate = wxPyBeginAllowThreads();
16520 result = (bool)(arg1)->ReleaseCapture();
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16534 PyObject *obj;
16535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16536 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16537 return SWIG_Py_Void();
16538 }
16539
16540 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16541 return SWIG_Python_InitShadowInstance(args);
16542 }
16543
16544 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16545 PyObject *resultobj = 0;
16546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16547 int arg2 = (int) 0 ;
16548 int arg3 = (int) wxJOYSTICK1 ;
16549 int arg4 = (int) 0 ;
16550 wxJoystickEvent *result = 0 ;
16551 int val1 ;
16552 int ecode1 = 0 ;
16553 int val2 ;
16554 int ecode2 = 0 ;
16555 int val3 ;
16556 int ecode3 = 0 ;
16557 int val4 ;
16558 int ecode4 = 0 ;
16559 PyObject * obj0 = 0 ;
16560 PyObject * obj1 = 0 ;
16561 PyObject * obj2 = 0 ;
16562 PyObject * obj3 = 0 ;
16563 char * kwnames[] = {
16564 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16565 };
16566
16567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16568 if (obj0) {
16569 ecode1 = SWIG_AsVal_int(obj0, &val1);
16570 if (!SWIG_IsOK(ecode1)) {
16571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16572 }
16573 arg1 = static_cast< wxEventType >(val1);
16574 }
16575 if (obj1) {
16576 ecode2 = SWIG_AsVal_int(obj1, &val2);
16577 if (!SWIG_IsOK(ecode2)) {
16578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16579 }
16580 arg2 = static_cast< int >(val2);
16581 }
16582 if (obj2) {
16583 ecode3 = SWIG_AsVal_int(obj2, &val3);
16584 if (!SWIG_IsOK(ecode3)) {
16585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16586 }
16587 arg3 = static_cast< int >(val3);
16588 }
16589 if (obj3) {
16590 ecode4 = SWIG_AsVal_int(obj3, &val4);
16591 if (!SWIG_IsOK(ecode4)) {
16592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16593 }
16594 arg4 = static_cast< int >(val4);
16595 }
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16610 PyObject *resultobj = 0;
16611 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16612 wxPoint result;
16613 void *argp1 = 0 ;
16614 int res1 = 0 ;
16615 PyObject *swig_obj[1] ;
16616
16617 if (!args) SWIG_fail;
16618 swig_obj[0] = args;
16619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16620 if (!SWIG_IsOK(res1)) {
16621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16622 }
16623 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16638 PyObject *resultobj = 0;
16639 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16640 int result;
16641 void *argp1 = 0 ;
16642 int res1 = 0 ;
16643 PyObject *swig_obj[1] ;
16644
16645 if (!args) SWIG_fail;
16646 swig_obj[0] = args;
16647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16648 if (!SWIG_IsOK(res1)) {
16649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16650 }
16651 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 resultobj = SWIG_From_int(static_cast< int >(result));
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16666 PyObject *resultobj = 0;
16667 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16668 int result;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 PyObject *swig_obj[1] ;
16672
16673 if (!args) SWIG_fail;
16674 swig_obj[0] = args;
16675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16676 if (!SWIG_IsOK(res1)) {
16677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16678 }
16679 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_From_int(static_cast< int >(result));
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16694 PyObject *resultobj = 0;
16695 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16696 int result;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 PyObject *swig_obj[1] ;
16700
16701 if (!args) SWIG_fail;
16702 swig_obj[0] = args;
16703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16704 if (!SWIG_IsOK(res1)) {
16705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16706 }
16707 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 resultobj = SWIG_From_int(static_cast< int >(result));
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16722 PyObject *resultobj = 0;
16723 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16724 int result;
16725 void *argp1 = 0 ;
16726 int res1 = 0 ;
16727 PyObject *swig_obj[1] ;
16728
16729 if (!args) SWIG_fail;
16730 swig_obj[0] = args;
16731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16732 if (!SWIG_IsOK(res1)) {
16733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16734 }
16735 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 resultobj = SWIG_From_int(static_cast< int >(result));
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj = 0;
16751 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16752 int arg2 ;
16753 void *argp1 = 0 ;
16754 int res1 = 0 ;
16755 int val2 ;
16756 int ecode2 = 0 ;
16757 PyObject * obj0 = 0 ;
16758 PyObject * obj1 = 0 ;
16759 char * kwnames[] = {
16760 (char *) "self",(char *) "stick", NULL
16761 };
16762
16763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16765 if (!SWIG_IsOK(res1)) {
16766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16767 }
16768 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16769 ecode2 = SWIG_AsVal_int(obj1, &val2);
16770 if (!SWIG_IsOK(ecode2)) {
16771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16772 }
16773 arg2 = static_cast< int >(val2);
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 (arg1)->SetJoystick(arg2);
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 resultobj = SWIG_Py_Void();
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj = 0;
16789 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16790 int arg2 ;
16791 void *argp1 = 0 ;
16792 int res1 = 0 ;
16793 int val2 ;
16794 int ecode2 = 0 ;
16795 PyObject * obj0 = 0 ;
16796 PyObject * obj1 = 0 ;
16797 char * kwnames[] = {
16798 (char *) "self",(char *) "state", NULL
16799 };
16800
16801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16803 if (!SWIG_IsOK(res1)) {
16804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16805 }
16806 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16807 ecode2 = SWIG_AsVal_int(obj1, &val2);
16808 if (!SWIG_IsOK(ecode2)) {
16809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16810 }
16811 arg2 = static_cast< int >(val2);
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 (arg1)->SetButtonState(arg2);
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 resultobj = SWIG_Py_Void();
16819 return resultobj;
16820 fail:
16821 return NULL;
16822 }
16823
16824
16825 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj = 0;
16827 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16828 int arg2 ;
16829 void *argp1 = 0 ;
16830 int res1 = 0 ;
16831 int val2 ;
16832 int ecode2 = 0 ;
16833 PyObject * obj0 = 0 ;
16834 PyObject * obj1 = 0 ;
16835 char * kwnames[] = {
16836 (char *) "self",(char *) "change", NULL
16837 };
16838
16839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16841 if (!SWIG_IsOK(res1)) {
16842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16843 }
16844 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16845 ecode2 = SWIG_AsVal_int(obj1, &val2);
16846 if (!SWIG_IsOK(ecode2)) {
16847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16848 }
16849 arg2 = static_cast< int >(val2);
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 (arg1)->SetButtonChange(arg2);
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 resultobj = SWIG_Py_Void();
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16864 PyObject *resultobj = 0;
16865 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16866 wxPoint *arg2 = 0 ;
16867 void *argp1 = 0 ;
16868 int res1 = 0 ;
16869 wxPoint temp2 ;
16870 PyObject * obj0 = 0 ;
16871 PyObject * obj1 = 0 ;
16872 char * kwnames[] = {
16873 (char *) "self",(char *) "pos", NULL
16874 };
16875
16876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16878 if (!SWIG_IsOK(res1)) {
16879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16880 }
16881 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16882 {
16883 arg2 = &temp2;
16884 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16885 }
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 (arg1)->SetPosition((wxPoint const &)*arg2);
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 resultobj = SWIG_Py_Void();
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16900 PyObject *resultobj = 0;
16901 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16902 int arg2 ;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 int val2 ;
16906 int ecode2 = 0 ;
16907 PyObject * obj0 = 0 ;
16908 PyObject * obj1 = 0 ;
16909 char * kwnames[] = {
16910 (char *) "self",(char *) "zPos", NULL
16911 };
16912
16913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16915 if (!SWIG_IsOK(res1)) {
16916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16917 }
16918 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16919 ecode2 = SWIG_AsVal_int(obj1, &val2);
16920 if (!SWIG_IsOK(ecode2)) {
16921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16922 }
16923 arg2 = static_cast< int >(val2);
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 (arg1)->SetZPosition(arg2);
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 resultobj = SWIG_Py_Void();
16931 return resultobj;
16932 fail:
16933 return NULL;
16934 }
16935
16936
16937 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16938 PyObject *resultobj = 0;
16939 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16940 bool result;
16941 void *argp1 = 0 ;
16942 int res1 = 0 ;
16943 PyObject *swig_obj[1] ;
16944
16945 if (!args) SWIG_fail;
16946 swig_obj[0] = args;
16947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16948 if (!SWIG_IsOK(res1)) {
16949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16950 }
16951 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 {
16959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16960 }
16961 return resultobj;
16962 fail:
16963 return NULL;
16964 }
16965
16966
16967 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16968 PyObject *resultobj = 0;
16969 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16970 bool result;
16971 void *argp1 = 0 ;
16972 int res1 = 0 ;
16973 PyObject *swig_obj[1] ;
16974
16975 if (!args) SWIG_fail;
16976 swig_obj[0] = args;
16977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16978 if (!SWIG_IsOK(res1)) {
16979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16980 }
16981 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16982 {
16983 PyThreadState* __tstate = wxPyBeginAllowThreads();
16984 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16985 wxPyEndAllowThreads(__tstate);
16986 if (PyErr_Occurred()) SWIG_fail;
16987 }
16988 {
16989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16990 }
16991 return resultobj;
16992 fail:
16993 return NULL;
16994 }
16995
16996
16997 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16998 PyObject *resultobj = 0;
16999 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17000 bool result;
17001 void *argp1 = 0 ;
17002 int res1 = 0 ;
17003 PyObject *swig_obj[1] ;
17004
17005 if (!args) SWIG_fail;
17006 swig_obj[0] = args;
17007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17008 if (!SWIG_IsOK(res1)) {
17009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17010 }
17011 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 {
17019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17020 }
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj = 0;
17029 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17030 int arg2 = (int) wxJOY_BUTTON_ANY ;
17031 bool result;
17032 void *argp1 = 0 ;
17033 int res1 = 0 ;
17034 int val2 ;
17035 int ecode2 = 0 ;
17036 PyObject * obj0 = 0 ;
17037 PyObject * obj1 = 0 ;
17038 char * kwnames[] = {
17039 (char *) "self",(char *) "but", NULL
17040 };
17041
17042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17044 if (!SWIG_IsOK(res1)) {
17045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17046 }
17047 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17048 if (obj1) {
17049 ecode2 = SWIG_AsVal_int(obj1, &val2);
17050 if (!SWIG_IsOK(ecode2)) {
17051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17052 }
17053 arg2 = static_cast< int >(val2);
17054 }
17055 {
17056 PyThreadState* __tstate = wxPyBeginAllowThreads();
17057 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj = 0;
17072 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17073 int arg2 = (int) wxJOY_BUTTON_ANY ;
17074 bool result;
17075 void *argp1 = 0 ;
17076 int res1 = 0 ;
17077 int val2 ;
17078 int ecode2 = 0 ;
17079 PyObject * obj0 = 0 ;
17080 PyObject * obj1 = 0 ;
17081 char * kwnames[] = {
17082 (char *) "self",(char *) "but", NULL
17083 };
17084
17085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17087 if (!SWIG_IsOK(res1)) {
17088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17089 }
17090 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17091 if (obj1) {
17092 ecode2 = SWIG_AsVal_int(obj1, &val2);
17093 if (!SWIG_IsOK(ecode2)) {
17094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17095 }
17096 arg2 = static_cast< int >(val2);
17097 }
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17101 wxPyEndAllowThreads(__tstate);
17102 if (PyErr_Occurred()) SWIG_fail;
17103 }
17104 {
17105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17106 }
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj = 0;
17115 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17116 int arg2 = (int) wxJOY_BUTTON_ANY ;
17117 bool result;
17118 void *argp1 = 0 ;
17119 int res1 = 0 ;
17120 int val2 ;
17121 int ecode2 = 0 ;
17122 PyObject * obj0 = 0 ;
17123 PyObject * obj1 = 0 ;
17124 char * kwnames[] = {
17125 (char *) "self",(char *) "but", NULL
17126 };
17127
17128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17130 if (!SWIG_IsOK(res1)) {
17131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17132 }
17133 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17134 if (obj1) {
17135 ecode2 = SWIG_AsVal_int(obj1, &val2);
17136 if (!SWIG_IsOK(ecode2)) {
17137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17138 }
17139 arg2 = static_cast< int >(val2);
17140 }
17141 {
17142 PyThreadState* __tstate = wxPyBeginAllowThreads();
17143 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17149 }
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17157 PyObject *obj;
17158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17159 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17160 return SWIG_Py_Void();
17161 }
17162
17163 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17164 return SWIG_Python_InitShadowInstance(args);
17165 }
17166
17167 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17168 PyObject *resultobj = 0;
17169 wxString const &arg1_defvalue = wxPyEmptyString ;
17170 wxString *arg1 = (wxString *) &arg1_defvalue ;
17171 wxSound *result = 0 ;
17172 bool temp1 = false ;
17173 PyObject * obj0 = 0 ;
17174 char * kwnames[] = {
17175 (char *) "fileName", NULL
17176 };
17177
17178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17179 if (obj0) {
17180 {
17181 arg1 = wxString_in_helper(obj0);
17182 if (arg1 == NULL) SWIG_fail;
17183 temp1 = true;
17184 }
17185 }
17186 {
17187 if (!wxPyCheckForApp()) SWIG_fail;
17188 PyThreadState* __tstate = wxPyBeginAllowThreads();
17189 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17190 wxPyEndAllowThreads(__tstate);
17191 if (PyErr_Occurred()) SWIG_fail;
17192 }
17193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17194 {
17195 if (temp1)
17196 delete arg1;
17197 }
17198 return resultobj;
17199 fail:
17200 {
17201 if (temp1)
17202 delete arg1;
17203 }
17204 return NULL;
17205 }
17206
17207
17208 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17209 PyObject *resultobj = 0;
17210 PyObject *arg1 = (PyObject *) 0 ;
17211 wxSound *result = 0 ;
17212 PyObject * obj0 = 0 ;
17213 char * kwnames[] = {
17214 (char *) "data", NULL
17215 };
17216
17217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17218 arg1 = obj0;
17219 {
17220 if (!wxPyCheckForApp()) SWIG_fail;
17221 PyThreadState* __tstate = wxPyBeginAllowThreads();
17222 result = (wxSound *)new_wxSound(arg1);
17223 wxPyEndAllowThreads(__tstate);
17224 if (PyErr_Occurred()) SWIG_fail;
17225 }
17226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17234 PyObject *resultobj = 0;
17235 wxSound *arg1 = (wxSound *) 0 ;
17236 void *argp1 = 0 ;
17237 int res1 = 0 ;
17238 PyObject *swig_obj[1] ;
17239
17240 if (!args) SWIG_fail;
17241 swig_obj[0] = args;
17242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17243 if (!SWIG_IsOK(res1)) {
17244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17245 }
17246 arg1 = reinterpret_cast< wxSound * >(argp1);
17247 {
17248 PyThreadState* __tstate = wxPyBeginAllowThreads();
17249 delete arg1;
17250
17251 wxPyEndAllowThreads(__tstate);
17252 if (PyErr_Occurred()) SWIG_fail;
17253 }
17254 resultobj = SWIG_Py_Void();
17255 return resultobj;
17256 fail:
17257 return NULL;
17258 }
17259
17260
17261 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj = 0;
17263 wxSound *arg1 = (wxSound *) 0 ;
17264 wxString *arg2 = 0 ;
17265 bool result;
17266 void *argp1 = 0 ;
17267 int res1 = 0 ;
17268 bool temp2 = false ;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271 char * kwnames[] = {
17272 (char *) "self",(char *) "fileName", NULL
17273 };
17274
17275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17277 if (!SWIG_IsOK(res1)) {
17278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17279 }
17280 arg1 = reinterpret_cast< wxSound * >(argp1);
17281 {
17282 arg2 = wxString_in_helper(obj1);
17283 if (arg2 == NULL) SWIG_fail;
17284 temp2 = true;
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (bool)(arg1)->Create((wxString const &)*arg2);
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 {
17293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17294 }
17295 {
17296 if (temp2)
17297 delete arg2;
17298 }
17299 return resultobj;
17300 fail:
17301 {
17302 if (temp2)
17303 delete arg2;
17304 }
17305 return NULL;
17306 }
17307
17308
17309 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj = 0;
17311 wxSound *arg1 = (wxSound *) 0 ;
17312 PyObject *arg2 = (PyObject *) 0 ;
17313 bool result;
17314 void *argp1 = 0 ;
17315 int res1 = 0 ;
17316 PyObject * obj0 = 0 ;
17317 PyObject * obj1 = 0 ;
17318 char * kwnames[] = {
17319 (char *) "self",(char *) "data", NULL
17320 };
17321
17322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17324 if (!SWIG_IsOK(res1)) {
17325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17326 }
17327 arg1 = reinterpret_cast< wxSound * >(argp1);
17328 arg2 = obj1;
17329 {
17330 PyThreadState* __tstate = wxPyBeginAllowThreads();
17331 result = (bool)wxSound_CreateFromData(arg1,arg2);
17332 wxPyEndAllowThreads(__tstate);
17333 if (PyErr_Occurred()) SWIG_fail;
17334 }
17335 {
17336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17337 }
17338 return resultobj;
17339 fail:
17340 return NULL;
17341 }
17342
17343
17344 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17345 PyObject *resultobj = 0;
17346 wxSound *arg1 = (wxSound *) 0 ;
17347 bool result;
17348 void *argp1 = 0 ;
17349 int res1 = 0 ;
17350 PyObject *swig_obj[1] ;
17351
17352 if (!args) SWIG_fail;
17353 swig_obj[0] = args;
17354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17355 if (!SWIG_IsOK(res1)) {
17356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17357 }
17358 arg1 = reinterpret_cast< wxSound * >(argp1);
17359 {
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 result = (bool)(arg1)->IsOk();
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 {
17366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17367 }
17368 return resultobj;
17369 fail:
17370 return NULL;
17371 }
17372
17373
17374 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17375 PyObject *resultobj = 0;
17376 wxSound *arg1 = (wxSound *) 0 ;
17377 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17378 bool result;
17379 void *argp1 = 0 ;
17380 int res1 = 0 ;
17381 unsigned int val2 ;
17382 int ecode2 = 0 ;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 char * kwnames[] = {
17386 (char *) "self",(char *) "flags", NULL
17387 };
17388
17389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17391 if (!SWIG_IsOK(res1)) {
17392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17393 }
17394 arg1 = reinterpret_cast< wxSound * >(argp1);
17395 if (obj1) {
17396 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17397 if (!SWIG_IsOK(ecode2)) {
17398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17399 }
17400 arg2 = static_cast< unsigned int >(val2);
17401 }
17402 {
17403 if (!wxPyCheckForApp()) SWIG_fail;
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 result = (bool)((wxSound const *)arg1)->Play(arg2);
17406 wxPyEndAllowThreads(__tstate);
17407 if (PyErr_Occurred()) SWIG_fail;
17408 }
17409 {
17410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17411 }
17412 return resultobj;
17413 fail:
17414 return NULL;
17415 }
17416
17417
17418 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17419 PyObject *resultobj = 0;
17420 wxString *arg1 = 0 ;
17421 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17422 bool result;
17423 bool temp1 = false ;
17424 unsigned int val2 ;
17425 int ecode2 = 0 ;
17426 PyObject * obj0 = 0 ;
17427 PyObject * obj1 = 0 ;
17428 char * kwnames[] = {
17429 (char *) "filename",(char *) "flags", NULL
17430 };
17431
17432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17433 {
17434 arg1 = wxString_in_helper(obj0);
17435 if (arg1 == NULL) SWIG_fail;
17436 temp1 = true;
17437 }
17438 if (obj1) {
17439 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17440 if (!SWIG_IsOK(ecode2)) {
17441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17442 }
17443 arg2 = static_cast< unsigned int >(val2);
17444 }
17445 {
17446 if (!wxPyCheckForApp()) SWIG_fail;
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 {
17453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17454 }
17455 {
17456 if (temp1)
17457 delete arg1;
17458 }
17459 return resultobj;
17460 fail:
17461 {
17462 if (temp1)
17463 delete arg1;
17464 }
17465 return NULL;
17466 }
17467
17468
17469 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 PyObject *resultobj = 0;
17471
17472 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17473 {
17474 if (!wxPyCheckForApp()) SWIG_fail;
17475 PyThreadState* __tstate = wxPyBeginAllowThreads();
17476 wxSound::Stop();
17477 wxPyEndAllowThreads(__tstate);
17478 if (PyErr_Occurred()) SWIG_fail;
17479 }
17480 resultobj = SWIG_Py_Void();
17481 return resultobj;
17482 fail:
17483 return NULL;
17484 }
17485
17486
17487 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17488 PyObject *obj;
17489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17490 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17491 return SWIG_Py_Void();
17492 }
17493
17494 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17495 return SWIG_Python_InitShadowInstance(args);
17496 }
17497
17498 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj = 0;
17500 wxString *arg1 = 0 ;
17501 wxString *arg2 = 0 ;
17502 wxString *arg3 = 0 ;
17503 wxString *arg4 = 0 ;
17504 wxFileTypeInfo *result = 0 ;
17505 bool temp1 = false ;
17506 bool temp2 = false ;
17507 bool temp3 = false ;
17508 bool temp4 = false ;
17509 PyObject * obj0 = 0 ;
17510 PyObject * obj1 = 0 ;
17511 PyObject * obj2 = 0 ;
17512 PyObject * obj3 = 0 ;
17513 char * kwnames[] = {
17514 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17515 };
17516
17517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17518 {
17519 arg1 = wxString_in_helper(obj0);
17520 if (arg1 == NULL) SWIG_fail;
17521 temp1 = true;
17522 }
17523 {
17524 arg2 = wxString_in_helper(obj1);
17525 if (arg2 == NULL) SWIG_fail;
17526 temp2 = true;
17527 }
17528 {
17529 arg3 = wxString_in_helper(obj2);
17530 if (arg3 == NULL) SWIG_fail;
17531 temp3 = true;
17532 }
17533 {
17534 arg4 = wxString_in_helper(obj3);
17535 if (arg4 == NULL) SWIG_fail;
17536 temp4 = true;
17537 }
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17541 wxPyEndAllowThreads(__tstate);
17542 if (PyErr_Occurred()) SWIG_fail;
17543 }
17544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17545 {
17546 if (temp1)
17547 delete arg1;
17548 }
17549 {
17550 if (temp2)
17551 delete arg2;
17552 }
17553 {
17554 if (temp3)
17555 delete arg3;
17556 }
17557 {
17558 if (temp4)
17559 delete arg4;
17560 }
17561 return resultobj;
17562 fail:
17563 {
17564 if (temp1)
17565 delete arg1;
17566 }
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 {
17572 if (temp3)
17573 delete arg3;
17574 }
17575 {
17576 if (temp4)
17577 delete arg4;
17578 }
17579 return NULL;
17580 }
17581
17582
17583 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17584 PyObject *resultobj = 0;
17585 wxArrayString *arg1 = 0 ;
17586 wxFileTypeInfo *result = 0 ;
17587 bool temp1 = false ;
17588 PyObject * obj0 = 0 ;
17589 char * kwnames[] = {
17590 (char *) "sArray", NULL
17591 };
17592
17593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17594 {
17595 if (! PySequence_Check(obj0)) {
17596 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17597 SWIG_fail;
17598 }
17599 arg1 = new wxArrayString;
17600 temp1 = true;
17601 int i, len=PySequence_Length(obj0);
17602 for (i=0; i<len; i++) {
17603 PyObject* item = PySequence_GetItem(obj0, i);
17604 wxString* s = wxString_in_helper(item);
17605 if (PyErr_Occurred()) SWIG_fail;
17606 arg1->Add(*s);
17607 delete s;
17608 Py_DECREF(item);
17609 }
17610 }
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17618 {
17619 if (temp1) delete arg1;
17620 }
17621 return resultobj;
17622 fail:
17623 {
17624 if (temp1) delete arg1;
17625 }
17626 return NULL;
17627 }
17628
17629
17630 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17631 PyObject *resultobj = 0;
17632 wxFileTypeInfo *result = 0 ;
17633
17634 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17635 {
17636 PyThreadState* __tstate = wxPyBeginAllowThreads();
17637 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17638 wxPyEndAllowThreads(__tstate);
17639 if (PyErr_Occurred()) SWIG_fail;
17640 }
17641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17649 PyObject *resultobj = 0;
17650 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17651 bool result;
17652 void *argp1 = 0 ;
17653 int res1 = 0 ;
17654 PyObject *swig_obj[1] ;
17655
17656 if (!args) SWIG_fail;
17657 swig_obj[0] = args;
17658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17659 if (!SWIG_IsOK(res1)) {
17660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17661 }
17662 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17663 {
17664 PyThreadState* __tstate = wxPyBeginAllowThreads();
17665 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17666 wxPyEndAllowThreads(__tstate);
17667 if (PyErr_Occurred()) SWIG_fail;
17668 }
17669 {
17670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17671 }
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17679 PyObject *resultobj = 0;
17680 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17681 wxString *arg2 = 0 ;
17682 int arg3 = (int) 0 ;
17683 void *argp1 = 0 ;
17684 int res1 = 0 ;
17685 bool temp2 = false ;
17686 int val3 ;
17687 int ecode3 = 0 ;
17688 PyObject * obj0 = 0 ;
17689 PyObject * obj1 = 0 ;
17690 PyObject * obj2 = 0 ;
17691 char * kwnames[] = {
17692 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17693 };
17694
17695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17697 if (!SWIG_IsOK(res1)) {
17698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17699 }
17700 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17701 {
17702 arg2 = wxString_in_helper(obj1);
17703 if (arg2 == NULL) SWIG_fail;
17704 temp2 = true;
17705 }
17706 if (obj2) {
17707 ecode3 = SWIG_AsVal_int(obj2, &val3);
17708 if (!SWIG_IsOK(ecode3)) {
17709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17710 }
17711 arg3 = static_cast< int >(val3);
17712 }
17713 {
17714 PyThreadState* __tstate = wxPyBeginAllowThreads();
17715 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17716 wxPyEndAllowThreads(__tstate);
17717 if (PyErr_Occurred()) SWIG_fail;
17718 }
17719 resultobj = SWIG_Py_Void();
17720 {
17721 if (temp2)
17722 delete arg2;
17723 }
17724 return resultobj;
17725 fail:
17726 {
17727 if (temp2)
17728 delete arg2;
17729 }
17730 return NULL;
17731 }
17732
17733
17734 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17735 PyObject *resultobj = 0;
17736 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17737 wxString *arg2 = 0 ;
17738 void *argp1 = 0 ;
17739 int res1 = 0 ;
17740 bool temp2 = false ;
17741 PyObject * obj0 = 0 ;
17742 PyObject * obj1 = 0 ;
17743 char * kwnames[] = {
17744 (char *) "self",(char *) "shortDesc", NULL
17745 };
17746
17747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17749 if (!SWIG_IsOK(res1)) {
17750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17751 }
17752 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17753 {
17754 arg2 = wxString_in_helper(obj1);
17755 if (arg2 == NULL) SWIG_fail;
17756 temp2 = true;
17757 }
17758 {
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 (arg1)->SetShortDesc((wxString const &)*arg2);
17761 wxPyEndAllowThreads(__tstate);
17762 if (PyErr_Occurred()) SWIG_fail;
17763 }
17764 resultobj = SWIG_Py_Void();
17765 {
17766 if (temp2)
17767 delete arg2;
17768 }
17769 return resultobj;
17770 fail:
17771 {
17772 if (temp2)
17773 delete arg2;
17774 }
17775 return NULL;
17776 }
17777
17778
17779 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17780 PyObject *resultobj = 0;
17781 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17782 wxString *result = 0 ;
17783 void *argp1 = 0 ;
17784 int res1 = 0 ;
17785 PyObject *swig_obj[1] ;
17786
17787 if (!args) SWIG_fail;
17788 swig_obj[0] = args;
17789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17790 if (!SWIG_IsOK(res1)) {
17791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17792 }
17793 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17794 {
17795 PyThreadState* __tstate = wxPyBeginAllowThreads();
17796 {
17797 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17798 result = (wxString *) &_result_ref;
17799 }
17800 wxPyEndAllowThreads(__tstate);
17801 if (PyErr_Occurred()) SWIG_fail;
17802 }
17803 {
17804 #if wxUSE_UNICODE
17805 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17806 #else
17807 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17808 #endif
17809 }
17810 return resultobj;
17811 fail:
17812 return NULL;
17813 }
17814
17815
17816 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17817 PyObject *resultobj = 0;
17818 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17819 wxString *result = 0 ;
17820 void *argp1 = 0 ;
17821 int res1 = 0 ;
17822 PyObject *swig_obj[1] ;
17823
17824 if (!args) SWIG_fail;
17825 swig_obj[0] = args;
17826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17827 if (!SWIG_IsOK(res1)) {
17828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17829 }
17830 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17831 {
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 {
17834 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17835 result = (wxString *) &_result_ref;
17836 }
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 {
17841 #if wxUSE_UNICODE
17842 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17843 #else
17844 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17845 #endif
17846 }
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17854 PyObject *resultobj = 0;
17855 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17856 wxString *result = 0 ;
17857 void *argp1 = 0 ;
17858 int res1 = 0 ;
17859 PyObject *swig_obj[1] ;
17860
17861 if (!args) SWIG_fail;
17862 swig_obj[0] = args;
17863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17864 if (!SWIG_IsOK(res1)) {
17865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17866 }
17867 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17868 {
17869 PyThreadState* __tstate = wxPyBeginAllowThreads();
17870 {
17871 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17872 result = (wxString *) &_result_ref;
17873 }
17874 wxPyEndAllowThreads(__tstate);
17875 if (PyErr_Occurred()) SWIG_fail;
17876 }
17877 {
17878 #if wxUSE_UNICODE
17879 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17880 #else
17881 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17882 #endif
17883 }
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17891 PyObject *resultobj = 0;
17892 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17893 wxString *result = 0 ;
17894 void *argp1 = 0 ;
17895 int res1 = 0 ;
17896 PyObject *swig_obj[1] ;
17897
17898 if (!args) SWIG_fail;
17899 swig_obj[0] = args;
17900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17901 if (!SWIG_IsOK(res1)) {
17902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17903 }
17904 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17905 {
17906 PyThreadState* __tstate = wxPyBeginAllowThreads();
17907 {
17908 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17909 result = (wxString *) &_result_ref;
17910 }
17911 wxPyEndAllowThreads(__tstate);
17912 if (PyErr_Occurred()) SWIG_fail;
17913 }
17914 {
17915 #if wxUSE_UNICODE
17916 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17917 #else
17918 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17919 #endif
17920 }
17921 return resultobj;
17922 fail:
17923 return NULL;
17924 }
17925
17926
17927 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17928 PyObject *resultobj = 0;
17929 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17930 wxString *result = 0 ;
17931 void *argp1 = 0 ;
17932 int res1 = 0 ;
17933 PyObject *swig_obj[1] ;
17934
17935 if (!args) SWIG_fail;
17936 swig_obj[0] = args;
17937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17938 if (!SWIG_IsOK(res1)) {
17939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17940 }
17941 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17942 {
17943 PyThreadState* __tstate = wxPyBeginAllowThreads();
17944 {
17945 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17946 result = (wxString *) &_result_ref;
17947 }
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 {
17952 #if wxUSE_UNICODE
17953 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17954 #else
17955 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17956 #endif
17957 }
17958 return resultobj;
17959 fail:
17960 return NULL;
17961 }
17962
17963
17964 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17965 PyObject *resultobj = 0;
17966 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17967 wxArrayString *result = 0 ;
17968 void *argp1 = 0 ;
17969 int res1 = 0 ;
17970 PyObject *swig_obj[1] ;
17971
17972 if (!args) SWIG_fail;
17973 swig_obj[0] = args;
17974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17975 if (!SWIG_IsOK(res1)) {
17976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17977 }
17978 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 {
17982 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17983 result = (wxArrayString *) &_result_ref;
17984 }
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 {
17989 resultobj = wxArrayString2PyList_helper(*result);
17990 }
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17998 PyObject *resultobj = 0;
17999 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18000 size_t result;
18001 void *argp1 = 0 ;
18002 int res1 = 0 ;
18003 PyObject *swig_obj[1] ;
18004
18005 if (!args) SWIG_fail;
18006 swig_obj[0] = args;
18007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18008 if (!SWIG_IsOK(res1)) {
18009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18010 }
18011 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18012 {
18013 PyThreadState* __tstate = wxPyBeginAllowThreads();
18014 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
18015 wxPyEndAllowThreads(__tstate);
18016 if (PyErr_Occurred()) SWIG_fail;
18017 }
18018 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18019 return resultobj;
18020 fail:
18021 return NULL;
18022 }
18023
18024
18025 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18026 PyObject *resultobj = 0;
18027 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18028 wxString *result = 0 ;
18029 void *argp1 = 0 ;
18030 int res1 = 0 ;
18031 PyObject *swig_obj[1] ;
18032
18033 if (!args) SWIG_fail;
18034 swig_obj[0] = args;
18035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18036 if (!SWIG_IsOK(res1)) {
18037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18038 }
18039 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 {
18043 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18044 result = (wxString *) &_result_ref;
18045 }
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 {
18050 #if wxUSE_UNICODE
18051 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18052 #else
18053 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18054 #endif
18055 }
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063 PyObject *resultobj = 0;
18064 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18065 int result;
18066 void *argp1 = 0 ;
18067 int res1 = 0 ;
18068 PyObject *swig_obj[1] ;
18069
18070 if (!args) SWIG_fail;
18071 swig_obj[0] = args;
18072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18073 if (!SWIG_IsOK(res1)) {
18074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18075 }
18076 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18077 {
18078 PyThreadState* __tstate = wxPyBeginAllowThreads();
18079 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 resultobj = SWIG_From_int(static_cast< int >(result));
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18091 PyObject *obj;
18092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18093 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18094 return SWIG_Py_Void();
18095 }
18096
18097 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18098 return SWIG_Python_InitShadowInstance(args);
18099 }
18100
18101 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18102 PyObject *resultobj = 0;
18103 wxFileTypeInfo *arg1 = 0 ;
18104 wxFileType *result = 0 ;
18105 void *argp1 = 0 ;
18106 int res1 = 0 ;
18107 PyObject * obj0 = 0 ;
18108 char * kwnames[] = {
18109 (char *) "ftInfo", NULL
18110 };
18111
18112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18113 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18116 }
18117 if (!argp1) {
18118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18119 }
18120 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18128 return resultobj;
18129 fail:
18130 return NULL;
18131 }
18132
18133
18134 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18135 PyObject *resultobj = 0;
18136 wxFileType *arg1 = (wxFileType *) 0 ;
18137 void *argp1 = 0 ;
18138 int res1 = 0 ;
18139 PyObject *swig_obj[1] ;
18140
18141 if (!args) SWIG_fail;
18142 swig_obj[0] = args;
18143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18144 if (!SWIG_IsOK(res1)) {
18145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18146 }
18147 arg1 = reinterpret_cast< wxFileType * >(argp1);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 delete arg1;
18151
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_Py_Void();
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18163 PyObject *resultobj = 0;
18164 wxFileType *arg1 = (wxFileType *) 0 ;
18165 PyObject *result = 0 ;
18166 void *argp1 = 0 ;
18167 int res1 = 0 ;
18168 PyObject *swig_obj[1] ;
18169
18170 if (!args) SWIG_fail;
18171 swig_obj[0] = args;
18172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18173 if (!SWIG_IsOK(res1)) {
18174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18175 }
18176 arg1 = reinterpret_cast< wxFileType * >(argp1);
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (PyObject *)wxFileType_GetMimeType(arg1);
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = result;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18191 PyObject *resultobj = 0;
18192 wxFileType *arg1 = (wxFileType *) 0 ;
18193 PyObject *result = 0 ;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
18196 PyObject *swig_obj[1] ;
18197
18198 if (!args) SWIG_fail;
18199 swig_obj[0] = args;
18200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18201 if (!SWIG_IsOK(res1)) {
18202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18203 }
18204 arg1 = reinterpret_cast< wxFileType * >(argp1);
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 resultobj = result;
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18219 PyObject *resultobj = 0;
18220 wxFileType *arg1 = (wxFileType *) 0 ;
18221 PyObject *result = 0 ;
18222 void *argp1 = 0 ;
18223 int res1 = 0 ;
18224 PyObject *swig_obj[1] ;
18225
18226 if (!args) SWIG_fail;
18227 swig_obj[0] = args;
18228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18229 if (!SWIG_IsOK(res1)) {
18230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18231 }
18232 arg1 = reinterpret_cast< wxFileType * >(argp1);
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 result = (PyObject *)wxFileType_GetExtensions(arg1);
18236 wxPyEndAllowThreads(__tstate);
18237 if (PyErr_Occurred()) SWIG_fail;
18238 }
18239 resultobj = result;
18240 return resultobj;
18241 fail:
18242 return NULL;
18243 }
18244
18245
18246 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18247 PyObject *resultobj = 0;
18248 wxFileType *arg1 = (wxFileType *) 0 ;
18249 wxIcon *result = 0 ;
18250 void *argp1 = 0 ;
18251 int res1 = 0 ;
18252 PyObject *swig_obj[1] ;
18253
18254 if (!args) SWIG_fail;
18255 swig_obj[0] = args;
18256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18257 if (!SWIG_IsOK(res1)) {
18258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18259 }
18260 arg1 = reinterpret_cast< wxFileType * >(argp1);
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = (wxIcon *)wxFileType_GetIcon(arg1);
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18268 return resultobj;
18269 fail:
18270 return NULL;
18271 }
18272
18273
18274 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18275 PyObject *resultobj = 0;
18276 wxFileType *arg1 = (wxFileType *) 0 ;
18277 PyObject *result = 0 ;
18278 void *argp1 = 0 ;
18279 int res1 = 0 ;
18280 PyObject *swig_obj[1] ;
18281
18282 if (!args) SWIG_fail;
18283 swig_obj[0] = args;
18284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18285 if (!SWIG_IsOK(res1)) {
18286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18287 }
18288 arg1 = reinterpret_cast< wxFileType * >(argp1);
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18292 wxPyEndAllowThreads(__tstate);
18293 if (PyErr_Occurred()) SWIG_fail;
18294 }
18295 resultobj = result;
18296 return resultobj;
18297 fail:
18298 return NULL;
18299 }
18300
18301
18302 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18303 PyObject *resultobj = 0;
18304 wxFileType *arg1 = (wxFileType *) 0 ;
18305 PyObject *result = 0 ;
18306 void *argp1 = 0 ;
18307 int res1 = 0 ;
18308 PyObject *swig_obj[1] ;
18309
18310 if (!args) SWIG_fail;
18311 swig_obj[0] = args;
18312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18313 if (!SWIG_IsOK(res1)) {
18314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18315 }
18316 arg1 = reinterpret_cast< wxFileType * >(argp1);
18317 {
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 result = (PyObject *)wxFileType_GetDescription(arg1);
18320 wxPyEndAllowThreads(__tstate);
18321 if (PyErr_Occurred()) SWIG_fail;
18322 }
18323 resultobj = result;
18324 return resultobj;
18325 fail:
18326 return NULL;
18327 }
18328
18329
18330 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18331 PyObject *resultobj = 0;
18332 wxFileType *arg1 = (wxFileType *) 0 ;
18333 wxString *arg2 = 0 ;
18334 wxString const &arg3_defvalue = wxPyEmptyString ;
18335 wxString *arg3 = (wxString *) &arg3_defvalue ;
18336 PyObject *result = 0 ;
18337 void *argp1 = 0 ;
18338 int res1 = 0 ;
18339 bool temp2 = false ;
18340 bool temp3 = false ;
18341 PyObject * obj0 = 0 ;
18342 PyObject * obj1 = 0 ;
18343 PyObject * obj2 = 0 ;
18344 char * kwnames[] = {
18345 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18346 };
18347
18348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18350 if (!SWIG_IsOK(res1)) {
18351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18352 }
18353 arg1 = reinterpret_cast< wxFileType * >(argp1);
18354 {
18355 arg2 = wxString_in_helper(obj1);
18356 if (arg2 == NULL) SWIG_fail;
18357 temp2 = true;
18358 }
18359 if (obj2) {
18360 {
18361 arg3 = wxString_in_helper(obj2);
18362 if (arg3 == NULL) SWIG_fail;
18363 temp3 = true;
18364 }
18365 }
18366 {
18367 PyThreadState* __tstate = wxPyBeginAllowThreads();
18368 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18369 wxPyEndAllowThreads(__tstate);
18370 if (PyErr_Occurred()) SWIG_fail;
18371 }
18372 resultobj = result;
18373 {
18374 if (temp2)
18375 delete arg2;
18376 }
18377 {
18378 if (temp3)
18379 delete arg3;
18380 }
18381 return resultobj;
18382 fail:
18383 {
18384 if (temp2)
18385 delete arg2;
18386 }
18387 {
18388 if (temp3)
18389 delete arg3;
18390 }
18391 return NULL;
18392 }
18393
18394
18395 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18396 PyObject *resultobj = 0;
18397 wxFileType *arg1 = (wxFileType *) 0 ;
18398 wxString *arg2 = 0 ;
18399 wxString const &arg3_defvalue = wxPyEmptyString ;
18400 wxString *arg3 = (wxString *) &arg3_defvalue ;
18401 PyObject *result = 0 ;
18402 void *argp1 = 0 ;
18403 int res1 = 0 ;
18404 bool temp2 = false ;
18405 bool temp3 = false ;
18406 PyObject * obj0 = 0 ;
18407 PyObject * obj1 = 0 ;
18408 PyObject * obj2 = 0 ;
18409 char * kwnames[] = {
18410 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18411 };
18412
18413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18415 if (!SWIG_IsOK(res1)) {
18416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18417 }
18418 arg1 = reinterpret_cast< wxFileType * >(argp1);
18419 {
18420 arg2 = wxString_in_helper(obj1);
18421 if (arg2 == NULL) SWIG_fail;
18422 temp2 = true;
18423 }
18424 if (obj2) {
18425 {
18426 arg3 = wxString_in_helper(obj2);
18427 if (arg3 == NULL) SWIG_fail;
18428 temp3 = true;
18429 }
18430 }
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 resultobj = result;
18438 {
18439 if (temp2)
18440 delete arg2;
18441 }
18442 {
18443 if (temp3)
18444 delete arg3;
18445 }
18446 return resultobj;
18447 fail:
18448 {
18449 if (temp2)
18450 delete arg2;
18451 }
18452 {
18453 if (temp3)
18454 delete arg3;
18455 }
18456 return NULL;
18457 }
18458
18459
18460 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18461 PyObject *resultobj = 0;
18462 wxFileType *arg1 = (wxFileType *) 0 ;
18463 wxString *arg2 = 0 ;
18464 wxString const &arg3_defvalue = wxPyEmptyString ;
18465 wxString *arg3 = (wxString *) &arg3_defvalue ;
18466 PyObject *result = 0 ;
18467 void *argp1 = 0 ;
18468 int res1 = 0 ;
18469 bool temp2 = false ;
18470 bool temp3 = false ;
18471 PyObject * obj0 = 0 ;
18472 PyObject * obj1 = 0 ;
18473 PyObject * obj2 = 0 ;
18474 char * kwnames[] = {
18475 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18476 };
18477
18478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18480 if (!SWIG_IsOK(res1)) {
18481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18482 }
18483 arg1 = reinterpret_cast< wxFileType * >(argp1);
18484 {
18485 arg2 = wxString_in_helper(obj1);
18486 if (arg2 == NULL) SWIG_fail;
18487 temp2 = true;
18488 }
18489 if (obj2) {
18490 {
18491 arg3 = wxString_in_helper(obj2);
18492 if (arg3 == NULL) SWIG_fail;
18493 temp3 = true;
18494 }
18495 }
18496 {
18497 PyThreadState* __tstate = wxPyBeginAllowThreads();
18498 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18499 wxPyEndAllowThreads(__tstate);
18500 if (PyErr_Occurred()) SWIG_fail;
18501 }
18502 resultobj = result;
18503 {
18504 if (temp2)
18505 delete arg2;
18506 }
18507 {
18508 if (temp3)
18509 delete arg3;
18510 }
18511 return resultobj;
18512 fail:
18513 {
18514 if (temp2)
18515 delete arg2;
18516 }
18517 {
18518 if (temp3)
18519 delete arg3;
18520 }
18521 return NULL;
18522 }
18523
18524
18525 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj = 0;
18527 wxFileType *arg1 = (wxFileType *) 0 ;
18528 wxString *arg2 = 0 ;
18529 wxString *arg3 = 0 ;
18530 bool arg4 = (bool) true ;
18531 bool result;
18532 void *argp1 = 0 ;
18533 int res1 = 0 ;
18534 bool temp2 = false ;
18535 bool temp3 = false ;
18536 bool val4 ;
18537 int ecode4 = 0 ;
18538 PyObject * obj0 = 0 ;
18539 PyObject * obj1 = 0 ;
18540 PyObject * obj2 = 0 ;
18541 PyObject * obj3 = 0 ;
18542 char * kwnames[] = {
18543 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18544 };
18545
18546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18548 if (!SWIG_IsOK(res1)) {
18549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18550 }
18551 arg1 = reinterpret_cast< wxFileType * >(argp1);
18552 {
18553 arg2 = wxString_in_helper(obj1);
18554 if (arg2 == NULL) SWIG_fail;
18555 temp2 = true;
18556 }
18557 {
18558 arg3 = wxString_in_helper(obj2);
18559 if (arg3 == NULL) SWIG_fail;
18560 temp3 = true;
18561 }
18562 if (obj3) {
18563 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18564 if (!SWIG_IsOK(ecode4)) {
18565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18566 }
18567 arg4 = static_cast< bool >(val4);
18568 }
18569 {
18570 PyThreadState* __tstate = wxPyBeginAllowThreads();
18571 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 {
18576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18577 }
18578 {
18579 if (temp2)
18580 delete arg2;
18581 }
18582 {
18583 if (temp3)
18584 delete arg3;
18585 }
18586 return resultobj;
18587 fail:
18588 {
18589 if (temp2)
18590 delete arg2;
18591 }
18592 {
18593 if (temp3)
18594 delete arg3;
18595 }
18596 return NULL;
18597 }
18598
18599
18600 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18601 PyObject *resultobj = 0;
18602 wxFileType *arg1 = (wxFileType *) 0 ;
18603 wxString const &arg2_defvalue = wxPyEmptyString ;
18604 wxString *arg2 = (wxString *) &arg2_defvalue ;
18605 int arg3 = (int) 0 ;
18606 bool result;
18607 void *argp1 = 0 ;
18608 int res1 = 0 ;
18609 bool temp2 = false ;
18610 int val3 ;
18611 int ecode3 = 0 ;
18612 PyObject * obj0 = 0 ;
18613 PyObject * obj1 = 0 ;
18614 PyObject * obj2 = 0 ;
18615 char * kwnames[] = {
18616 (char *) "self",(char *) "cmd",(char *) "index", NULL
18617 };
18618
18619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18623 }
18624 arg1 = reinterpret_cast< wxFileType * >(argp1);
18625 if (obj1) {
18626 {
18627 arg2 = wxString_in_helper(obj1);
18628 if (arg2 == NULL) SWIG_fail;
18629 temp2 = true;
18630 }
18631 }
18632 if (obj2) {
18633 ecode3 = SWIG_AsVal_int(obj2, &val3);
18634 if (!SWIG_IsOK(ecode3)) {
18635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18636 }
18637 arg3 = static_cast< int >(val3);
18638 }
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18642 wxPyEndAllowThreads(__tstate);
18643 if (PyErr_Occurred()) SWIG_fail;
18644 }
18645 {
18646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18647 }
18648 {
18649 if (temp2)
18650 delete arg2;
18651 }
18652 return resultobj;
18653 fail:
18654 {
18655 if (temp2)
18656 delete arg2;
18657 }
18658 return NULL;
18659 }
18660
18661
18662 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18663 PyObject *resultobj = 0;
18664 wxFileType *arg1 = (wxFileType *) 0 ;
18665 bool result;
18666 void *argp1 = 0 ;
18667 int res1 = 0 ;
18668 PyObject *swig_obj[1] ;
18669
18670 if (!args) SWIG_fail;
18671 swig_obj[0] = args;
18672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18675 }
18676 arg1 = reinterpret_cast< wxFileType * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 result = (bool)(arg1)->Unassociate();
18680 wxPyEndAllowThreads(__tstate);
18681 if (PyErr_Occurred()) SWIG_fail;
18682 }
18683 {
18684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18685 }
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj = 0;
18694 wxString *arg1 = 0 ;
18695 wxString *arg2 = 0 ;
18696 wxString const &arg3_defvalue = wxPyEmptyString ;
18697 wxString *arg3 = (wxString *) &arg3_defvalue ;
18698 wxString result;
18699 bool temp1 = false ;
18700 bool temp2 = false ;
18701 bool temp3 = false ;
18702 PyObject * obj0 = 0 ;
18703 PyObject * obj1 = 0 ;
18704 PyObject * obj2 = 0 ;
18705 char * kwnames[] = {
18706 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18707 };
18708
18709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18710 {
18711 arg1 = wxString_in_helper(obj0);
18712 if (arg1 == NULL) SWIG_fail;
18713 temp1 = true;
18714 }
18715 {
18716 arg2 = wxString_in_helper(obj1);
18717 if (arg2 == NULL) SWIG_fail;
18718 temp2 = true;
18719 }
18720 if (obj2) {
18721 {
18722 arg3 = wxString_in_helper(obj2);
18723 if (arg3 == NULL) SWIG_fail;
18724 temp3 = true;
18725 }
18726 }
18727 {
18728 PyThreadState* __tstate = wxPyBeginAllowThreads();
18729 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18730 wxPyEndAllowThreads(__tstate);
18731 if (PyErr_Occurred()) SWIG_fail;
18732 }
18733 {
18734 #if wxUSE_UNICODE
18735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18736 #else
18737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18738 #endif
18739 }
18740 {
18741 if (temp1)
18742 delete arg1;
18743 }
18744 {
18745 if (temp2)
18746 delete arg2;
18747 }
18748 {
18749 if (temp3)
18750 delete arg3;
18751 }
18752 return resultobj;
18753 fail:
18754 {
18755 if (temp1)
18756 delete arg1;
18757 }
18758 {
18759 if (temp2)
18760 delete arg2;
18761 }
18762 {
18763 if (temp3)
18764 delete arg3;
18765 }
18766 return NULL;
18767 }
18768
18769
18770 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771 PyObject *obj;
18772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18773 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18774 return SWIG_Py_Void();
18775 }
18776
18777 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18778 return SWIG_Python_InitShadowInstance(args);
18779 }
18780
18781 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18782 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18783 return 1;
18784 }
18785
18786
18787 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18788 PyObject *pyobj = 0;
18789
18790 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18791 return pyobj;
18792 }
18793
18794
18795 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18796 PyObject *resultobj = 0;
18797 wxString *arg1 = 0 ;
18798 wxString *arg2 = 0 ;
18799 bool result;
18800 bool temp1 = false ;
18801 bool temp2 = false ;
18802 PyObject * obj0 = 0 ;
18803 PyObject * obj1 = 0 ;
18804 char * kwnames[] = {
18805 (char *) "mimeType",(char *) "wildcard", NULL
18806 };
18807
18808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18809 {
18810 arg1 = wxString_in_helper(obj0);
18811 if (arg1 == NULL) SWIG_fail;
18812 temp1 = true;
18813 }
18814 {
18815 arg2 = wxString_in_helper(obj1);
18816 if (arg2 == NULL) SWIG_fail;
18817 temp2 = true;
18818 }
18819 {
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 {
18826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18827 }
18828 {
18829 if (temp1)
18830 delete arg1;
18831 }
18832 {
18833 if (temp2)
18834 delete arg2;
18835 }
18836 return resultobj;
18837 fail:
18838 {
18839 if (temp1)
18840 delete arg1;
18841 }
18842 {
18843 if (temp2)
18844 delete arg2;
18845 }
18846 return NULL;
18847 }
18848
18849
18850 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18851 PyObject *resultobj = 0;
18852 wxMimeTypesManager *result = 0 ;
18853
18854 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18869 PyObject *resultobj = 0;
18870 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18871 int arg2 = (int) wxMAILCAP_ALL ;
18872 wxString const &arg3_defvalue = wxPyEmptyString ;
18873 wxString *arg3 = (wxString *) &arg3_defvalue ;
18874 void *argp1 = 0 ;
18875 int res1 = 0 ;
18876 int val2 ;
18877 int ecode2 = 0 ;
18878 bool temp3 = false ;
18879 PyObject * obj0 = 0 ;
18880 PyObject * obj1 = 0 ;
18881 PyObject * obj2 = 0 ;
18882 char * kwnames[] = {
18883 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18884 };
18885
18886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18888 if (!SWIG_IsOK(res1)) {
18889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18890 }
18891 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18892 if (obj1) {
18893 ecode2 = SWIG_AsVal_int(obj1, &val2);
18894 if (!SWIG_IsOK(ecode2)) {
18895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18896 }
18897 arg2 = static_cast< int >(val2);
18898 }
18899 if (obj2) {
18900 {
18901 arg3 = wxString_in_helper(obj2);
18902 if (arg3 == NULL) SWIG_fail;
18903 temp3 = true;
18904 }
18905 }
18906 {
18907 PyThreadState* __tstate = wxPyBeginAllowThreads();
18908 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18909 wxPyEndAllowThreads(__tstate);
18910 if (PyErr_Occurred()) SWIG_fail;
18911 }
18912 resultobj = SWIG_Py_Void();
18913 {
18914 if (temp3)
18915 delete arg3;
18916 }
18917 return resultobj;
18918 fail:
18919 {
18920 if (temp3)
18921 delete arg3;
18922 }
18923 return NULL;
18924 }
18925
18926
18927 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18928 PyObject *resultobj = 0;
18929 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18930 void *argp1 = 0 ;
18931 int res1 = 0 ;
18932 PyObject *swig_obj[1] ;
18933
18934 if (!args) SWIG_fail;
18935 swig_obj[0] = args;
18936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18937 if (!SWIG_IsOK(res1)) {
18938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18939 }
18940 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18941 {
18942 PyThreadState* __tstate = wxPyBeginAllowThreads();
18943 (arg1)->ClearData();
18944 wxPyEndAllowThreads(__tstate);
18945 if (PyErr_Occurred()) SWIG_fail;
18946 }
18947 resultobj = SWIG_Py_Void();
18948 return resultobj;
18949 fail:
18950 return NULL;
18951 }
18952
18953
18954 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18955 PyObject *resultobj = 0;
18956 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18957 wxString *arg2 = 0 ;
18958 wxFileType *result = 0 ;
18959 void *argp1 = 0 ;
18960 int res1 = 0 ;
18961 bool temp2 = false ;
18962 PyObject * obj0 = 0 ;
18963 PyObject * obj1 = 0 ;
18964 char * kwnames[] = {
18965 (char *) "self",(char *) "ext", NULL
18966 };
18967
18968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18970 if (!SWIG_IsOK(res1)) {
18971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18972 }
18973 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18974 {
18975 arg2 = wxString_in_helper(obj1);
18976 if (arg2 == NULL) SWIG_fail;
18977 temp2 = true;
18978 }
18979 {
18980 PyThreadState* __tstate = wxPyBeginAllowThreads();
18981 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18982 wxPyEndAllowThreads(__tstate);
18983 if (PyErr_Occurred()) SWIG_fail;
18984 }
18985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18986 {
18987 if (temp2)
18988 delete arg2;
18989 }
18990 return resultobj;
18991 fail:
18992 {
18993 if (temp2)
18994 delete arg2;
18995 }
18996 return NULL;
18997 }
18998
18999
19000 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19001 PyObject *resultobj = 0;
19002 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19003 wxString *arg2 = 0 ;
19004 wxFileType *result = 0 ;
19005 void *argp1 = 0 ;
19006 int res1 = 0 ;
19007 bool temp2 = false ;
19008 PyObject * obj0 = 0 ;
19009 PyObject * obj1 = 0 ;
19010 char * kwnames[] = {
19011 (char *) "self",(char *) "mimeType", NULL
19012 };
19013
19014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
19015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19016 if (!SWIG_IsOK(res1)) {
19017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19018 }
19019 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19020 {
19021 arg2 = wxString_in_helper(obj1);
19022 if (arg2 == NULL) SWIG_fail;
19023 temp2 = true;
19024 }
19025 {
19026 PyThreadState* __tstate = wxPyBeginAllowThreads();
19027 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19028 wxPyEndAllowThreads(__tstate);
19029 if (PyErr_Occurred()) SWIG_fail;
19030 }
19031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19032 {
19033 if (temp2)
19034 delete arg2;
19035 }
19036 return resultobj;
19037 fail:
19038 {
19039 if (temp2)
19040 delete arg2;
19041 }
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj = 0;
19048 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19049 wxString *arg2 = 0 ;
19050 bool arg3 = (bool) false ;
19051 bool result;
19052 void *argp1 = 0 ;
19053 int res1 = 0 ;
19054 bool temp2 = false ;
19055 bool val3 ;
19056 int ecode3 = 0 ;
19057 PyObject * obj0 = 0 ;
19058 PyObject * obj1 = 0 ;
19059 PyObject * obj2 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19066 if (!SWIG_IsOK(res1)) {
19067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19068 }
19069 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19070 {
19071 arg2 = wxString_in_helper(obj1);
19072 if (arg2 == NULL) SWIG_fail;
19073 temp2 = true;
19074 }
19075 if (obj2) {
19076 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19077 if (!SWIG_IsOK(ecode3)) {
19078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19079 }
19080 arg3 = static_cast< bool >(val3);
19081 }
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 {
19089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19090 }
19091 {
19092 if (temp2)
19093 delete arg2;
19094 }
19095 return resultobj;
19096 fail:
19097 {
19098 if (temp2)
19099 delete arg2;
19100 }
19101 return NULL;
19102 }
19103
19104
19105 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj = 0;
19107 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19108 wxString *arg2 = 0 ;
19109 bool result;
19110 void *argp1 = 0 ;
19111 int res1 = 0 ;
19112 bool temp2 = false ;
19113 PyObject * obj0 = 0 ;
19114 PyObject * obj1 = 0 ;
19115 char * kwnames[] = {
19116 (char *) "self",(char *) "filename", NULL
19117 };
19118
19119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19121 if (!SWIG_IsOK(res1)) {
19122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19123 }
19124 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19125 {
19126 arg2 = wxString_in_helper(obj1);
19127 if (arg2 == NULL) SWIG_fail;
19128 temp2 = true;
19129 }
19130 {
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19133 wxPyEndAllowThreads(__tstate);
19134 if (PyErr_Occurred()) SWIG_fail;
19135 }
19136 {
19137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19138 }
19139 {
19140 if (temp2)
19141 delete arg2;
19142 }
19143 return resultobj;
19144 fail:
19145 {
19146 if (temp2)
19147 delete arg2;
19148 }
19149 return NULL;
19150 }
19151
19152
19153 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19154 PyObject *resultobj = 0;
19155 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19156 PyObject *result = 0 ;
19157 void *argp1 = 0 ;
19158 int res1 = 0 ;
19159 PyObject *swig_obj[1] ;
19160
19161 if (!args) SWIG_fail;
19162 swig_obj[0] = args;
19163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19164 if (!SWIG_IsOK(res1)) {
19165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19166 }
19167 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 resultobj = result;
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19182 PyObject *resultobj = 0;
19183 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19184 wxFileTypeInfo *arg2 = 0 ;
19185 void *argp1 = 0 ;
19186 int res1 = 0 ;
19187 void *argp2 = 0 ;
19188 int res2 = 0 ;
19189 PyObject * obj0 = 0 ;
19190 PyObject * obj1 = 0 ;
19191 char * kwnames[] = {
19192 (char *) "self",(char *) "ft", NULL
19193 };
19194
19195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19197 if (!SWIG_IsOK(res1)) {
19198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19199 }
19200 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19201 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19202 if (!SWIG_IsOK(res2)) {
19203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19204 }
19205 if (!argp2) {
19206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19207 }
19208 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19209 {
19210 PyThreadState* __tstate = wxPyBeginAllowThreads();
19211 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19212 wxPyEndAllowThreads(__tstate);
19213 if (PyErr_Occurred()) SWIG_fail;
19214 }
19215 resultobj = SWIG_Py_Void();
19216 return resultobj;
19217 fail:
19218 return NULL;
19219 }
19220
19221
19222 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19223 PyObject *resultobj = 0;
19224 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19225 wxFileTypeInfo *arg2 = 0 ;
19226 wxFileType *result = 0 ;
19227 void *argp1 = 0 ;
19228 int res1 = 0 ;
19229 void *argp2 = 0 ;
19230 int res2 = 0 ;
19231 PyObject * obj0 = 0 ;
19232 PyObject * obj1 = 0 ;
19233 char * kwnames[] = {
19234 (char *) "self",(char *) "ftInfo", NULL
19235 };
19236
19237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19239 if (!SWIG_IsOK(res1)) {
19240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19241 }
19242 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19244 if (!SWIG_IsOK(res2)) {
19245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19246 }
19247 if (!argp2) {
19248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19249 }
19250 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19251 {
19252 PyThreadState* __tstate = wxPyBeginAllowThreads();
19253 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj = 0;
19266 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19267 wxFileType *arg2 = (wxFileType *) 0 ;
19268 bool result;
19269 void *argp1 = 0 ;
19270 int res1 = 0 ;
19271 void *argp2 = 0 ;
19272 int res2 = 0 ;
19273 PyObject * obj0 = 0 ;
19274 PyObject * obj1 = 0 ;
19275 char * kwnames[] = {
19276 (char *) "self",(char *) "ft", NULL
19277 };
19278
19279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19281 if (!SWIG_IsOK(res1)) {
19282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19283 }
19284 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19286 if (!SWIG_IsOK(res2)) {
19287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19288 }
19289 arg2 = reinterpret_cast< wxFileType * >(argp2);
19290 {
19291 PyThreadState* __tstate = wxPyBeginAllowThreads();
19292 result = (bool)(arg1)->Unassociate(arg2);
19293 wxPyEndAllowThreads(__tstate);
19294 if (PyErr_Occurred()) SWIG_fail;
19295 }
19296 {
19297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19298 }
19299 return resultobj;
19300 fail:
19301 return NULL;
19302 }
19303
19304
19305 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19306 PyObject *resultobj = 0;
19307 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19308 void *argp1 = 0 ;
19309 int res1 = 0 ;
19310 PyObject *swig_obj[1] ;
19311
19312 if (!args) SWIG_fail;
19313 swig_obj[0] = args;
19314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19315 if (!SWIG_IsOK(res1)) {
19316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19317 }
19318 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 delete arg1;
19322
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 resultobj = SWIG_Py_Void();
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19334 PyObject *obj;
19335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19336 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19337 return SWIG_Py_Void();
19338 }
19339
19340 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19341 return SWIG_Python_InitShadowInstance(args);
19342 }
19343
19344 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19345 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19346 return 1;
19347 }
19348
19349
19350 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19351 PyObject *pyobj = 0;
19352
19353 {
19354 #if wxUSE_UNICODE
19355 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19356 #else
19357 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19358 #endif
19359 }
19360 return pyobj;
19361 }
19362
19363
19364 SWIGINTERN int ART_MENU_set(PyObject *) {
19365 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19366 return 1;
19367 }
19368
19369
19370 SWIGINTERN PyObject *ART_MENU_get(void) {
19371 PyObject *pyobj = 0;
19372
19373 {
19374 #if wxUSE_UNICODE
19375 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19376 #else
19377 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19378 #endif
19379 }
19380 return pyobj;
19381 }
19382
19383
19384 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19385 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19386 return 1;
19387 }
19388
19389
19390 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19391 PyObject *pyobj = 0;
19392
19393 {
19394 #if wxUSE_UNICODE
19395 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19396 #else
19397 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19398 #endif
19399 }
19400 return pyobj;
19401 }
19402
19403
19404 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19405 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19406 return 1;
19407 }
19408
19409
19410 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19411 PyObject *pyobj = 0;
19412
19413 {
19414 #if wxUSE_UNICODE
19415 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19416 #else
19417 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19418 #endif
19419 }
19420 return pyobj;
19421 }
19422
19423
19424 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19425 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19426 return 1;
19427 }
19428
19429
19430 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19431 PyObject *pyobj = 0;
19432
19433 {
19434 #if wxUSE_UNICODE
19435 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19436 #else
19437 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19438 #endif
19439 }
19440 return pyobj;
19441 }
19442
19443
19444 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19445 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19446 return 1;
19447 }
19448
19449
19450 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19451 PyObject *pyobj = 0;
19452
19453 {
19454 #if wxUSE_UNICODE
19455 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19456 #else
19457 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19458 #endif
19459 }
19460 return pyobj;
19461 }
19462
19463
19464 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19465 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19466 return 1;
19467 }
19468
19469
19470 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19471 PyObject *pyobj = 0;
19472
19473 {
19474 #if wxUSE_UNICODE
19475 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19476 #else
19477 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19478 #endif
19479 }
19480 return pyobj;
19481 }
19482
19483
19484 SWIGINTERN int ART_OTHER_set(PyObject *) {
19485 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19486 return 1;
19487 }
19488
19489
19490 SWIGINTERN PyObject *ART_OTHER_get(void) {
19491 PyObject *pyobj = 0;
19492
19493 {
19494 #if wxUSE_UNICODE
19495 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19496 #else
19497 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19498 #endif
19499 }
19500 return pyobj;
19501 }
19502
19503
19504 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19505 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19506 return 1;
19507 }
19508
19509
19510 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19511 PyObject *pyobj = 0;
19512
19513 {
19514 #if wxUSE_UNICODE
19515 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19516 #else
19517 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19518 #endif
19519 }
19520 return pyobj;
19521 }
19522
19523
19524 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19525 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19526 return 1;
19527 }
19528
19529
19530 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19531 PyObject *pyobj = 0;
19532
19533 {
19534 #if wxUSE_UNICODE
19535 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19536 #else
19537 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19538 #endif
19539 }
19540 return pyobj;
19541 }
19542
19543
19544 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19545 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19546 return 1;
19547 }
19548
19549
19550 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19551 PyObject *pyobj = 0;
19552
19553 {
19554 #if wxUSE_UNICODE
19555 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19556 #else
19557 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19558 #endif
19559 }
19560 return pyobj;
19561 }
19562
19563
19564 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19565 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19566 return 1;
19567 }
19568
19569
19570 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19571 PyObject *pyobj = 0;
19572
19573 {
19574 #if wxUSE_UNICODE
19575 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19576 #else
19577 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19578 #endif
19579 }
19580 return pyobj;
19581 }
19582
19583
19584 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19585 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19586 return 1;
19587 }
19588
19589
19590 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19591 PyObject *pyobj = 0;
19592
19593 {
19594 #if wxUSE_UNICODE
19595 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19596 #else
19597 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19598 #endif
19599 }
19600 return pyobj;
19601 }
19602
19603
19604 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19605 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19606 return 1;
19607 }
19608
19609
19610 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19611 PyObject *pyobj = 0;
19612
19613 {
19614 #if wxUSE_UNICODE
19615 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19616 #else
19617 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19618 #endif
19619 }
19620 return pyobj;
19621 }
19622
19623
19624 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19625 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19626 return 1;
19627 }
19628
19629
19630 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19631 PyObject *pyobj = 0;
19632
19633 {
19634 #if wxUSE_UNICODE
19635 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19636 #else
19637 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19638 #endif
19639 }
19640 return pyobj;
19641 }
19642
19643
19644 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19645 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19646 return 1;
19647 }
19648
19649
19650 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19651 PyObject *pyobj = 0;
19652
19653 {
19654 #if wxUSE_UNICODE
19655 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19656 #else
19657 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19658 #endif
19659 }
19660 return pyobj;
19661 }
19662
19663
19664 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19665 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19666 return 1;
19667 }
19668
19669
19670 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19671 PyObject *pyobj = 0;
19672
19673 {
19674 #if wxUSE_UNICODE
19675 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19676 #else
19677 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19678 #endif
19679 }
19680 return pyobj;
19681 }
19682
19683
19684 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19685 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19686 return 1;
19687 }
19688
19689
19690 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19691 PyObject *pyobj = 0;
19692
19693 {
19694 #if wxUSE_UNICODE
19695 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19696 #else
19697 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19698 #endif
19699 }
19700 return pyobj;
19701 }
19702
19703
19704 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19705 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19706 return 1;
19707 }
19708
19709
19710 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19711 PyObject *pyobj = 0;
19712
19713 {
19714 #if wxUSE_UNICODE
19715 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19716 #else
19717 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19718 #endif
19719 }
19720 return pyobj;
19721 }
19722
19723
19724 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19725 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19726 return 1;
19727 }
19728
19729
19730 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19731 PyObject *pyobj = 0;
19732
19733 {
19734 #if wxUSE_UNICODE
19735 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19736 #else
19737 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19738 #endif
19739 }
19740 return pyobj;
19741 }
19742
19743
19744 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19745 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19746 return 1;
19747 }
19748
19749
19750 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19751 PyObject *pyobj = 0;
19752
19753 {
19754 #if wxUSE_UNICODE
19755 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19756 #else
19757 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19758 #endif
19759 }
19760 return pyobj;
19761 }
19762
19763
19764 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19765 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19766 return 1;
19767 }
19768
19769
19770 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19771 PyObject *pyobj = 0;
19772
19773 {
19774 #if wxUSE_UNICODE
19775 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19776 #else
19777 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19778 #endif
19779 }
19780 return pyobj;
19781 }
19782
19783
19784 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19785 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19786 return 1;
19787 }
19788
19789
19790 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19791 PyObject *pyobj = 0;
19792
19793 {
19794 #if wxUSE_UNICODE
19795 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19796 #else
19797 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19798 #endif
19799 }
19800 return pyobj;
19801 }
19802
19803
19804 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19805 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19806 return 1;
19807 }
19808
19809
19810 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19811 PyObject *pyobj = 0;
19812
19813 {
19814 #if wxUSE_UNICODE
19815 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19816 #else
19817 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19818 #endif
19819 }
19820 return pyobj;
19821 }
19822
19823
19824 SWIGINTERN int ART_PRINT_set(PyObject *) {
19825 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19826 return 1;
19827 }
19828
19829
19830 SWIGINTERN PyObject *ART_PRINT_get(void) {
19831 PyObject *pyobj = 0;
19832
19833 {
19834 #if wxUSE_UNICODE
19835 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19836 #else
19837 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19838 #endif
19839 }
19840 return pyobj;
19841 }
19842
19843
19844 SWIGINTERN int ART_HELP_set(PyObject *) {
19845 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19846 return 1;
19847 }
19848
19849
19850 SWIGINTERN PyObject *ART_HELP_get(void) {
19851 PyObject *pyobj = 0;
19852
19853 {
19854 #if wxUSE_UNICODE
19855 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19856 #else
19857 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19858 #endif
19859 }
19860 return pyobj;
19861 }
19862
19863
19864 SWIGINTERN int ART_TIP_set(PyObject *) {
19865 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19866 return 1;
19867 }
19868
19869
19870 SWIGINTERN PyObject *ART_TIP_get(void) {
19871 PyObject *pyobj = 0;
19872
19873 {
19874 #if wxUSE_UNICODE
19875 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19876 #else
19877 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19878 #endif
19879 }
19880 return pyobj;
19881 }
19882
19883
19884 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19885 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19886 return 1;
19887 }
19888
19889
19890 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19891 PyObject *pyobj = 0;
19892
19893 {
19894 #if wxUSE_UNICODE
19895 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19896 #else
19897 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19898 #endif
19899 }
19900 return pyobj;
19901 }
19902
19903
19904 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19905 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19906 return 1;
19907 }
19908
19909
19910 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19911 PyObject *pyobj = 0;
19912
19913 {
19914 #if wxUSE_UNICODE
19915 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19916 #else
19917 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19918 #endif
19919 }
19920 return pyobj;
19921 }
19922
19923
19924 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19925 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19926 return 1;
19927 }
19928
19929
19930 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19931 PyObject *pyobj = 0;
19932
19933 {
19934 #if wxUSE_UNICODE
19935 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19936 #else
19937 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19938 #endif
19939 }
19940 return pyobj;
19941 }
19942
19943
19944 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19945 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19946 return 1;
19947 }
19948
19949
19950 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19951 PyObject *pyobj = 0;
19952
19953 {
19954 #if wxUSE_UNICODE
19955 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19956 #else
19957 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19958 #endif
19959 }
19960 return pyobj;
19961 }
19962
19963
19964 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19965 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19966 return 1;
19967 }
19968
19969
19970 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19971 PyObject *pyobj = 0;
19972
19973 {
19974 #if wxUSE_UNICODE
19975 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19976 #else
19977 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19978 #endif
19979 }
19980 return pyobj;
19981 }
19982
19983
19984 SWIGINTERN int ART_CDROM_set(PyObject *) {
19985 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19986 return 1;
19987 }
19988
19989
19990 SWIGINTERN PyObject *ART_CDROM_get(void) {
19991 PyObject *pyobj = 0;
19992
19993 {
19994 #if wxUSE_UNICODE
19995 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19996 #else
19997 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19998 #endif
19999 }
20000 return pyobj;
20001 }
20002
20003
20004 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
20005 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
20006 return 1;
20007 }
20008
20009
20010 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20011 PyObject *pyobj = 0;
20012
20013 {
20014 #if wxUSE_UNICODE
20015 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20016 #else
20017 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20018 #endif
20019 }
20020 return pyobj;
20021 }
20022
20023
20024 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20025 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20026 return 1;
20027 }
20028
20029
20030 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20031 PyObject *pyobj = 0;
20032
20033 {
20034 #if wxUSE_UNICODE
20035 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20036 #else
20037 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20038 #endif
20039 }
20040 return pyobj;
20041 }
20042
20043
20044 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20045 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20046 return 1;
20047 }
20048
20049
20050 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20051 PyObject *pyobj = 0;
20052
20053 {
20054 #if wxUSE_UNICODE
20055 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20056 #else
20057 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20058 #endif
20059 }
20060 return pyobj;
20061 }
20062
20063
20064 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20065 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20066 return 1;
20067 }
20068
20069
20070 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20071 PyObject *pyobj = 0;
20072
20073 {
20074 #if wxUSE_UNICODE
20075 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20076 #else
20077 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20078 #endif
20079 }
20080 return pyobj;
20081 }
20082
20083
20084 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20085 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20086 return 1;
20087 }
20088
20089
20090 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20091 PyObject *pyobj = 0;
20092
20093 {
20094 #if wxUSE_UNICODE
20095 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20096 #else
20097 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20098 #endif
20099 }
20100 return pyobj;
20101 }
20102
20103
20104 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20105 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20106 return 1;
20107 }
20108
20109
20110 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20111 PyObject *pyobj = 0;
20112
20113 {
20114 #if wxUSE_UNICODE
20115 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20116 #else
20117 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20118 #endif
20119 }
20120 return pyobj;
20121 }
20122
20123
20124 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20125 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20126 return 1;
20127 }
20128
20129
20130 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20131 PyObject *pyobj = 0;
20132
20133 {
20134 #if wxUSE_UNICODE
20135 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20136 #else
20137 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20138 #endif
20139 }
20140 return pyobj;
20141 }
20142
20143
20144 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20145 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20146 return 1;
20147 }
20148
20149
20150 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20151 PyObject *pyobj = 0;
20152
20153 {
20154 #if wxUSE_UNICODE
20155 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20156 #else
20157 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20158 #endif
20159 }
20160 return pyobj;
20161 }
20162
20163
20164 SWIGINTERN int ART_ERROR_set(PyObject *) {
20165 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20166 return 1;
20167 }
20168
20169
20170 SWIGINTERN PyObject *ART_ERROR_get(void) {
20171 PyObject *pyobj = 0;
20172
20173 {
20174 #if wxUSE_UNICODE
20175 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20176 #else
20177 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20178 #endif
20179 }
20180 return pyobj;
20181 }
20182
20183
20184 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20185 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20186 return 1;
20187 }
20188
20189
20190 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20191 PyObject *pyobj = 0;
20192
20193 {
20194 #if wxUSE_UNICODE
20195 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20196 #else
20197 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20198 #endif
20199 }
20200 return pyobj;
20201 }
20202
20203
20204 SWIGINTERN int ART_WARNING_set(PyObject *) {
20205 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20206 return 1;
20207 }
20208
20209
20210 SWIGINTERN PyObject *ART_WARNING_get(void) {
20211 PyObject *pyobj = 0;
20212
20213 {
20214 #if wxUSE_UNICODE
20215 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20216 #else
20217 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20218 #endif
20219 }
20220 return pyobj;
20221 }
20222
20223
20224 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20225 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20226 return 1;
20227 }
20228
20229
20230 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20231 PyObject *pyobj = 0;
20232
20233 {
20234 #if wxUSE_UNICODE
20235 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20236 #else
20237 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20238 #endif
20239 }
20240 return pyobj;
20241 }
20242
20243
20244 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20245 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20246 return 1;
20247 }
20248
20249
20250 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20251 PyObject *pyobj = 0;
20252
20253 {
20254 #if wxUSE_UNICODE
20255 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20256 #else
20257 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20258 #endif
20259 }
20260 return pyobj;
20261 }
20262
20263
20264 SWIGINTERN int ART_COPY_set(PyObject *) {
20265 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20266 return 1;
20267 }
20268
20269
20270 SWIGINTERN PyObject *ART_COPY_get(void) {
20271 PyObject *pyobj = 0;
20272
20273 {
20274 #if wxUSE_UNICODE
20275 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20276 #else
20277 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20278 #endif
20279 }
20280 return pyobj;
20281 }
20282
20283
20284 SWIGINTERN int ART_CUT_set(PyObject *) {
20285 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20286 return 1;
20287 }
20288
20289
20290 SWIGINTERN PyObject *ART_CUT_get(void) {
20291 PyObject *pyobj = 0;
20292
20293 {
20294 #if wxUSE_UNICODE
20295 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20296 #else
20297 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20298 #endif
20299 }
20300 return pyobj;
20301 }
20302
20303
20304 SWIGINTERN int ART_PASTE_set(PyObject *) {
20305 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20306 return 1;
20307 }
20308
20309
20310 SWIGINTERN PyObject *ART_PASTE_get(void) {
20311 PyObject *pyobj = 0;
20312
20313 {
20314 #if wxUSE_UNICODE
20315 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20316 #else
20317 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20318 #endif
20319 }
20320 return pyobj;
20321 }
20322
20323
20324 SWIGINTERN int ART_DELETE_set(PyObject *) {
20325 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20326 return 1;
20327 }
20328
20329
20330 SWIGINTERN PyObject *ART_DELETE_get(void) {
20331 PyObject *pyobj = 0;
20332
20333 {
20334 #if wxUSE_UNICODE
20335 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20336 #else
20337 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20338 #endif
20339 }
20340 return pyobj;
20341 }
20342
20343
20344 SWIGINTERN int ART_NEW_set(PyObject *) {
20345 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20346 return 1;
20347 }
20348
20349
20350 SWIGINTERN PyObject *ART_NEW_get(void) {
20351 PyObject *pyobj = 0;
20352
20353 {
20354 #if wxUSE_UNICODE
20355 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20356 #else
20357 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20358 #endif
20359 }
20360 return pyobj;
20361 }
20362
20363
20364 SWIGINTERN int ART_UNDO_set(PyObject *) {
20365 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20366 return 1;
20367 }
20368
20369
20370 SWIGINTERN PyObject *ART_UNDO_get(void) {
20371 PyObject *pyobj = 0;
20372
20373 {
20374 #if wxUSE_UNICODE
20375 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20376 #else
20377 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20378 #endif
20379 }
20380 return pyobj;
20381 }
20382
20383
20384 SWIGINTERN int ART_REDO_set(PyObject *) {
20385 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20386 return 1;
20387 }
20388
20389
20390 SWIGINTERN PyObject *ART_REDO_get(void) {
20391 PyObject *pyobj = 0;
20392
20393 {
20394 #if wxUSE_UNICODE
20395 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20396 #else
20397 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20398 #endif
20399 }
20400 return pyobj;
20401 }
20402
20403
20404 SWIGINTERN int ART_QUIT_set(PyObject *) {
20405 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20406 return 1;
20407 }
20408
20409
20410 SWIGINTERN PyObject *ART_QUIT_get(void) {
20411 PyObject *pyobj = 0;
20412
20413 {
20414 #if wxUSE_UNICODE
20415 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20416 #else
20417 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20418 #endif
20419 }
20420 return pyobj;
20421 }
20422
20423
20424 SWIGINTERN int ART_FIND_set(PyObject *) {
20425 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20426 return 1;
20427 }
20428
20429
20430 SWIGINTERN PyObject *ART_FIND_get(void) {
20431 PyObject *pyobj = 0;
20432
20433 {
20434 #if wxUSE_UNICODE
20435 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20436 #else
20437 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20438 #endif
20439 }
20440 return pyobj;
20441 }
20442
20443
20444 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20445 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20446 return 1;
20447 }
20448
20449
20450 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20451 PyObject *pyobj = 0;
20452
20453 {
20454 #if wxUSE_UNICODE
20455 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20456 #else
20457 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20458 #endif
20459 }
20460 return pyobj;
20461 }
20462
20463
20464 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465 PyObject *resultobj = 0;
20466 wxPyArtProvider *result = 0 ;
20467
20468 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20469 {
20470 if (!wxPyCheckForApp()) SWIG_fail;
20471 PyThreadState* __tstate = wxPyBeginAllowThreads();
20472 result = (wxPyArtProvider *)new wxPyArtProvider();
20473 wxPyEndAllowThreads(__tstate);
20474 if (PyErr_Occurred()) SWIG_fail;
20475 }
20476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20484 PyObject *resultobj = 0;
20485 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20486 void *argp1 = 0 ;
20487 int res1 = 0 ;
20488 PyObject *swig_obj[1] ;
20489
20490 if (!args) SWIG_fail;
20491 swig_obj[0] = args;
20492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20493 if (!SWIG_IsOK(res1)) {
20494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20495 }
20496 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 delete arg1;
20500
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 resultobj = SWIG_Py_Void();
20505 return resultobj;
20506 fail:
20507 return NULL;
20508 }
20509
20510
20511 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20512 PyObject *resultobj = 0;
20513 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20514 PyObject *arg2 = (PyObject *) 0 ;
20515 PyObject *arg3 = (PyObject *) 0 ;
20516 void *argp1 = 0 ;
20517 int res1 = 0 ;
20518 PyObject * obj0 = 0 ;
20519 PyObject * obj1 = 0 ;
20520 PyObject * obj2 = 0 ;
20521 char * kwnames[] = {
20522 (char *) "self",(char *) "self",(char *) "_class", NULL
20523 };
20524
20525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20527 if (!SWIG_IsOK(res1)) {
20528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20529 }
20530 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20531 arg2 = obj1;
20532 arg3 = obj2;
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 (arg1)->_setCallbackInfo(arg2,arg3);
20536 wxPyEndAllowThreads(__tstate);
20537 if (PyErr_Occurred()) SWIG_fail;
20538 }
20539 resultobj = SWIG_Py_Void();
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20547 PyObject *resultobj = 0;
20548 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20549 int res1 = 0 ;
20550 PyObject * obj0 = 0 ;
20551 char * kwnames[] = {
20552 (char *) "provider", NULL
20553 };
20554
20555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20556 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20559 }
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 wxPyArtProvider::Push(arg1);
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 resultobj = SWIG_Py_Void();
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj = 0;
20575 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20576 int res1 = 0 ;
20577 PyObject * obj0 = 0 ;
20578 char * kwnames[] = {
20579 (char *) "provider", NULL
20580 };
20581
20582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20583 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20584 if (!SWIG_IsOK(res1)) {
20585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20586 }
20587 {
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 wxPyArtProvider::Insert(arg1);
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 resultobj = SWIG_Py_Void();
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20601 PyObject *resultobj = 0;
20602 bool result;
20603
20604 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20605 {
20606 PyThreadState* __tstate = wxPyBeginAllowThreads();
20607 result = (bool)wxPyArtProvider::Pop();
20608 wxPyEndAllowThreads(__tstate);
20609 if (PyErr_Occurred()) SWIG_fail;
20610 }
20611 {
20612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20613 }
20614 return resultobj;
20615 fail:
20616 return NULL;
20617 }
20618
20619
20620 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj = 0;
20622 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20623 bool result;
20624 void *argp1 = 0 ;
20625 int res1 = 0 ;
20626 PyObject * obj0 = 0 ;
20627 char * kwnames[] = {
20628 (char *) "provider", NULL
20629 };
20630
20631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20633 if (!SWIG_IsOK(res1)) {
20634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20635 }
20636 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20637 {
20638 PyThreadState* __tstate = wxPyBeginAllowThreads();
20639 result = (bool)wxPyArtProvider::Delete(arg1);
20640 wxPyEndAllowThreads(__tstate);
20641 if (PyErr_Occurred()) SWIG_fail;
20642 }
20643 {
20644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20645 }
20646 return resultobj;
20647 fail:
20648 return NULL;
20649 }
20650
20651
20652 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj = 0;
20654 wxString *arg1 = 0 ;
20655 wxString const &arg2_defvalue = wxPyART_OTHER ;
20656 wxString *arg2 = (wxString *) &arg2_defvalue ;
20657 wxSize const &arg3_defvalue = wxDefaultSize ;
20658 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20659 wxBitmap result;
20660 bool temp1 = false ;
20661 bool temp2 = false ;
20662 wxSize temp3 ;
20663 PyObject * obj0 = 0 ;
20664 PyObject * obj1 = 0 ;
20665 PyObject * obj2 = 0 ;
20666 char * kwnames[] = {
20667 (char *) "id",(char *) "client",(char *) "size", NULL
20668 };
20669
20670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20671 {
20672 arg1 = wxString_in_helper(obj0);
20673 if (arg1 == NULL) SWIG_fail;
20674 temp1 = true;
20675 }
20676 if (obj1) {
20677 {
20678 arg2 = wxString_in_helper(obj1);
20679 if (arg2 == NULL) SWIG_fail;
20680 temp2 = true;
20681 }
20682 }
20683 if (obj2) {
20684 {
20685 arg3 = &temp3;
20686 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20687 }
20688 }
20689 {
20690 if (!wxPyCheckForApp()) SWIG_fail;
20691 PyThreadState* __tstate = wxPyBeginAllowThreads();
20692 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20693 wxPyEndAllowThreads(__tstate);
20694 if (PyErr_Occurred()) SWIG_fail;
20695 }
20696 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20697 {
20698 if (temp1)
20699 delete arg1;
20700 }
20701 {
20702 if (temp2)
20703 delete arg2;
20704 }
20705 return resultobj;
20706 fail:
20707 {
20708 if (temp1)
20709 delete arg1;
20710 }
20711 {
20712 if (temp2)
20713 delete arg2;
20714 }
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj = 0;
20721 wxString *arg1 = 0 ;
20722 wxString const &arg2_defvalue = wxPyART_OTHER ;
20723 wxString *arg2 = (wxString *) &arg2_defvalue ;
20724 wxSize const &arg3_defvalue = wxDefaultSize ;
20725 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20726 wxIcon result;
20727 bool temp1 = false ;
20728 bool temp2 = false ;
20729 wxSize temp3 ;
20730 PyObject * obj0 = 0 ;
20731 PyObject * obj1 = 0 ;
20732 PyObject * obj2 = 0 ;
20733 char * kwnames[] = {
20734 (char *) "id",(char *) "client",(char *) "size", NULL
20735 };
20736
20737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20738 {
20739 arg1 = wxString_in_helper(obj0);
20740 if (arg1 == NULL) SWIG_fail;
20741 temp1 = true;
20742 }
20743 if (obj1) {
20744 {
20745 arg2 = wxString_in_helper(obj1);
20746 if (arg2 == NULL) SWIG_fail;
20747 temp2 = true;
20748 }
20749 }
20750 if (obj2) {
20751 {
20752 arg3 = &temp3;
20753 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20754 }
20755 }
20756 {
20757 if (!wxPyCheckForApp()) SWIG_fail;
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20764 {
20765 if (temp1)
20766 delete arg1;
20767 }
20768 {
20769 if (temp2)
20770 delete arg2;
20771 }
20772 return resultobj;
20773 fail:
20774 {
20775 if (temp1)
20776 delete arg1;
20777 }
20778 {
20779 if (temp2)
20780 delete arg2;
20781 }
20782 return NULL;
20783 }
20784
20785
20786 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20787 PyObject *resultobj = 0;
20788 wxString *arg1 = 0 ;
20789 bool arg2 = (bool) false ;
20790 wxSize result;
20791 bool temp1 = false ;
20792 bool val2 ;
20793 int ecode2 = 0 ;
20794 PyObject * obj0 = 0 ;
20795 PyObject * obj1 = 0 ;
20796 char * kwnames[] = {
20797 (char *) "client",(char *) "platform_dependent", NULL
20798 };
20799
20800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20801 {
20802 arg1 = wxString_in_helper(obj0);
20803 if (arg1 == NULL) SWIG_fail;
20804 temp1 = true;
20805 }
20806 if (obj1) {
20807 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20808 if (!SWIG_IsOK(ecode2)) {
20809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20810 }
20811 arg2 = static_cast< bool >(val2);
20812 }
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20820 {
20821 if (temp1)
20822 delete arg1;
20823 }
20824 return resultobj;
20825 fail:
20826 {
20827 if (temp1)
20828 delete arg1;
20829 }
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20835 PyObject *resultobj = 0;
20836 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 PyObject *swig_obj[1] ;
20840
20841 if (!args) SWIG_fail;
20842 swig_obj[0] = args;
20843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20844 if (!SWIG_IsOK(res1)) {
20845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20846 }
20847 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 wxPyArtProvider_Destroy(arg1);
20851 wxPyEndAllowThreads(__tstate);
20852 if (PyErr_Occurred()) SWIG_fail;
20853 }
20854 resultobj = SWIG_Py_Void();
20855 return resultobj;
20856 fail:
20857 return NULL;
20858 }
20859
20860
20861 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20862 PyObject *obj;
20863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20864 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20865 return SWIG_Py_Void();
20866 }
20867
20868 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20869 return SWIG_Python_InitShadowInstance(args);
20870 }
20871
20872 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20873 PyObject *resultobj = 0;
20874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20875 void *argp1 = 0 ;
20876 int res1 = 0 ;
20877 PyObject *swig_obj[1] ;
20878
20879 if (!args) SWIG_fail;
20880 swig_obj[0] = args;
20881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20882 if (!SWIG_IsOK(res1)) {
20883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20884 }
20885 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20886 {
20887 PyThreadState* __tstate = wxPyBeginAllowThreads();
20888 delete arg1;
20889
20890 wxPyEndAllowThreads(__tstate);
20891 if (PyErr_Occurred()) SWIG_fail;
20892 }
20893 resultobj = SWIG_Py_Void();
20894 return resultobj;
20895 fail:
20896 return NULL;
20897 }
20898
20899
20900 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20901 PyObject *resultobj = 0;
20902 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20903 wxConfigBase *result = 0 ;
20904 int res1 = 0 ;
20905 PyObject * obj0 = 0 ;
20906 char * kwnames[] = {
20907 (char *) "config", NULL
20908 };
20909
20910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20911 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20912 if (!SWIG_IsOK(res1)) {
20913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20914 }
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20929 PyObject *resultobj = 0;
20930 bool arg1 = (bool) true ;
20931 wxConfigBase *result = 0 ;
20932 bool val1 ;
20933 int ecode1 = 0 ;
20934 PyObject * obj0 = 0 ;
20935 char * kwnames[] = {
20936 (char *) "createOnDemand", NULL
20937 };
20938
20939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20940 if (obj0) {
20941 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20942 if (!SWIG_IsOK(ecode1)) {
20943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20944 }
20945 arg1 = static_cast< bool >(val1);
20946 }
20947 {
20948 PyThreadState* __tstate = wxPyBeginAllowThreads();
20949 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20961 PyObject *resultobj = 0;
20962 wxConfigBase *result = 0 ;
20963
20964 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 result = (wxConfigBase *)wxConfigBase::Create();
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980
20981 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 wxConfigBase::DontCreateOnDemand();
20985 wxPyEndAllowThreads(__tstate);
20986 if (PyErr_Occurred()) SWIG_fail;
20987 }
20988 resultobj = SWIG_Py_Void();
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj = 0;
20997 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20998 wxString *arg2 = 0 ;
20999 void *argp1 = 0 ;
21000 int res1 = 0 ;
21001 bool temp2 = false ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 char * kwnames[] = {
21005 (char *) "self",(char *) "path", NULL
21006 };
21007
21008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21010 if (!SWIG_IsOK(res1)) {
21011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21012 }
21013 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21014 {
21015 arg2 = wxString_in_helper(obj1);
21016 if (arg2 == NULL) SWIG_fail;
21017 temp2 = true;
21018 }
21019 {
21020 PyThreadState* __tstate = wxPyBeginAllowThreads();
21021 (arg1)->SetPath((wxString const &)*arg2);
21022 wxPyEndAllowThreads(__tstate);
21023 if (PyErr_Occurred()) SWIG_fail;
21024 }
21025 resultobj = SWIG_Py_Void();
21026 {
21027 if (temp2)
21028 delete arg2;
21029 }
21030 return resultobj;
21031 fail:
21032 {
21033 if (temp2)
21034 delete arg2;
21035 }
21036 return NULL;
21037 }
21038
21039
21040 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21041 PyObject *resultobj = 0;
21042 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21043 wxString *result = 0 ;
21044 void *argp1 = 0 ;
21045 int res1 = 0 ;
21046 PyObject *swig_obj[1] ;
21047
21048 if (!args) SWIG_fail;
21049 swig_obj[0] = args;
21050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21051 if (!SWIG_IsOK(res1)) {
21052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21053 }
21054 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21055 {
21056 PyThreadState* __tstate = wxPyBeginAllowThreads();
21057 {
21058 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21059 result = (wxString *) &_result_ref;
21060 }
21061 wxPyEndAllowThreads(__tstate);
21062 if (PyErr_Occurred()) SWIG_fail;
21063 }
21064 {
21065 #if wxUSE_UNICODE
21066 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21067 #else
21068 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21069 #endif
21070 }
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21078 PyObject *resultobj = 0;
21079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21080 PyObject *result = 0 ;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 PyObject *swig_obj[1] ;
21084
21085 if (!args) SWIG_fail;
21086 swig_obj[0] = args;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21090 }
21091 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21092 {
21093 PyThreadState* __tstate = wxPyBeginAllowThreads();
21094 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21095 wxPyEndAllowThreads(__tstate);
21096 if (PyErr_Occurred()) SWIG_fail;
21097 }
21098 resultobj = result;
21099 return resultobj;
21100 fail:
21101 return NULL;
21102 }
21103
21104
21105 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21106 PyObject *resultobj = 0;
21107 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21108 long arg2 ;
21109 PyObject *result = 0 ;
21110 void *argp1 = 0 ;
21111 int res1 = 0 ;
21112 long val2 ;
21113 int ecode2 = 0 ;
21114 PyObject * obj0 = 0 ;
21115 PyObject * obj1 = 0 ;
21116 char * kwnames[] = {
21117 (char *) "self",(char *) "index", NULL
21118 };
21119
21120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21122 if (!SWIG_IsOK(res1)) {
21123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21124 }
21125 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21126 ecode2 = SWIG_AsVal_long(obj1, &val2);
21127 if (!SWIG_IsOK(ecode2)) {
21128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21129 }
21130 arg2 = static_cast< long >(val2);
21131 {
21132 PyThreadState* __tstate = wxPyBeginAllowThreads();
21133 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 resultobj = result;
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21145 PyObject *resultobj = 0;
21146 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21147 PyObject *result = 0 ;
21148 void *argp1 = 0 ;
21149 int res1 = 0 ;
21150 PyObject *swig_obj[1] ;
21151
21152 if (!args) SWIG_fail;
21153 swig_obj[0] = args;
21154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21155 if (!SWIG_IsOK(res1)) {
21156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21157 }
21158 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21162 wxPyEndAllowThreads(__tstate);
21163 if (PyErr_Occurred()) SWIG_fail;
21164 }
21165 resultobj = result;
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21173 PyObject *resultobj = 0;
21174 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21175 long arg2 ;
21176 PyObject *result = 0 ;
21177 void *argp1 = 0 ;
21178 int res1 = 0 ;
21179 long val2 ;
21180 int ecode2 = 0 ;
21181 PyObject * obj0 = 0 ;
21182 PyObject * obj1 = 0 ;
21183 char * kwnames[] = {
21184 (char *) "self",(char *) "index", NULL
21185 };
21186
21187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21189 if (!SWIG_IsOK(res1)) {
21190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21191 }
21192 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21193 ecode2 = SWIG_AsVal_long(obj1, &val2);
21194 if (!SWIG_IsOK(ecode2)) {
21195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21196 }
21197 arg2 = static_cast< long >(val2);
21198 {
21199 PyThreadState* __tstate = wxPyBeginAllowThreads();
21200 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21201 wxPyEndAllowThreads(__tstate);
21202 if (PyErr_Occurred()) SWIG_fail;
21203 }
21204 resultobj = result;
21205 return resultobj;
21206 fail:
21207 return NULL;
21208 }
21209
21210
21211 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21212 PyObject *resultobj = 0;
21213 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21214 bool arg2 = (bool) false ;
21215 size_t result;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 bool val2 ;
21219 int ecode2 = 0 ;
21220 PyObject * obj0 = 0 ;
21221 PyObject * obj1 = 0 ;
21222 char * kwnames[] = {
21223 (char *) "self",(char *) "recursive", NULL
21224 };
21225
21226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21228 if (!SWIG_IsOK(res1)) {
21229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21230 }
21231 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21232 if (obj1) {
21233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21234 if (!SWIG_IsOK(ecode2)) {
21235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21236 }
21237 arg2 = static_cast< bool >(val2);
21238 }
21239 {
21240 PyThreadState* __tstate = wxPyBeginAllowThreads();
21241 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21242 wxPyEndAllowThreads(__tstate);
21243 if (PyErr_Occurred()) SWIG_fail;
21244 }
21245 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21246 return resultobj;
21247 fail:
21248 return NULL;
21249 }
21250
21251
21252 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21253 PyObject *resultobj = 0;
21254 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21255 bool arg2 = (bool) false ;
21256 size_t result;
21257 void *argp1 = 0 ;
21258 int res1 = 0 ;
21259 bool val2 ;
21260 int ecode2 = 0 ;
21261 PyObject * obj0 = 0 ;
21262 PyObject * obj1 = 0 ;
21263 char * kwnames[] = {
21264 (char *) "self",(char *) "recursive", NULL
21265 };
21266
21267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21271 }
21272 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21273 if (obj1) {
21274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21275 if (!SWIG_IsOK(ecode2)) {
21276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21277 }
21278 arg2 = static_cast< bool >(val2);
21279 }
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21283 wxPyEndAllowThreads(__tstate);
21284 if (PyErr_Occurred()) SWIG_fail;
21285 }
21286 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21294 PyObject *resultobj = 0;
21295 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21296 wxString *arg2 = 0 ;
21297 bool result;
21298 void *argp1 = 0 ;
21299 int res1 = 0 ;
21300 bool temp2 = false ;
21301 PyObject * obj0 = 0 ;
21302 PyObject * obj1 = 0 ;
21303 char * kwnames[] = {
21304 (char *) "self",(char *) "name", NULL
21305 };
21306
21307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21311 }
21312 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21313 {
21314 arg2 = wxString_in_helper(obj1);
21315 if (arg2 == NULL) SWIG_fail;
21316 temp2 = true;
21317 }
21318 {
21319 PyThreadState* __tstate = wxPyBeginAllowThreads();
21320 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21321 wxPyEndAllowThreads(__tstate);
21322 if (PyErr_Occurred()) SWIG_fail;
21323 }
21324 {
21325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21326 }
21327 {
21328 if (temp2)
21329 delete arg2;
21330 }
21331 return resultobj;
21332 fail:
21333 {
21334 if (temp2)
21335 delete arg2;
21336 }
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21342 PyObject *resultobj = 0;
21343 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21344 wxString *arg2 = 0 ;
21345 bool result;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 bool temp2 = false ;
21349 PyObject * obj0 = 0 ;
21350 PyObject * obj1 = 0 ;
21351 char * kwnames[] = {
21352 (char *) "self",(char *) "name", NULL
21353 };
21354
21355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21357 if (!SWIG_IsOK(res1)) {
21358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21359 }
21360 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21361 {
21362 arg2 = wxString_in_helper(obj1);
21363 if (arg2 == NULL) SWIG_fail;
21364 temp2 = true;
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 {
21373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21374 }
21375 {
21376 if (temp2)
21377 delete arg2;
21378 }
21379 return resultobj;
21380 fail:
21381 {
21382 if (temp2)
21383 delete arg2;
21384 }
21385 return NULL;
21386 }
21387
21388
21389 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj = 0;
21391 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21392 wxString *arg2 = 0 ;
21393 bool result;
21394 void *argp1 = 0 ;
21395 int res1 = 0 ;
21396 bool temp2 = false ;
21397 PyObject * obj0 = 0 ;
21398 PyObject * obj1 = 0 ;
21399 char * kwnames[] = {
21400 (char *) "self",(char *) "name", NULL
21401 };
21402
21403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21405 if (!SWIG_IsOK(res1)) {
21406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21407 }
21408 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21409 {
21410 arg2 = wxString_in_helper(obj1);
21411 if (arg2 == NULL) SWIG_fail;
21412 temp2 = true;
21413 }
21414 {
21415 PyThreadState* __tstate = wxPyBeginAllowThreads();
21416 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 {
21421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21422 }
21423 {
21424 if (temp2)
21425 delete arg2;
21426 }
21427 return resultobj;
21428 fail:
21429 {
21430 if (temp2)
21431 delete arg2;
21432 }
21433 return NULL;
21434 }
21435
21436
21437 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21438 PyObject *resultobj = 0;
21439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21440 wxString *arg2 = 0 ;
21441 wxConfigBase::EntryType result;
21442 void *argp1 = 0 ;
21443 int res1 = 0 ;
21444 bool temp2 = false ;
21445 PyObject * obj0 = 0 ;
21446 PyObject * obj1 = 0 ;
21447 char * kwnames[] = {
21448 (char *) "self",(char *) "name", NULL
21449 };
21450
21451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21453 if (!SWIG_IsOK(res1)) {
21454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21455 }
21456 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21457 {
21458 arg2 = wxString_in_helper(obj1);
21459 if (arg2 == NULL) SWIG_fail;
21460 temp2 = true;
21461 }
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 resultobj = SWIG_From_int(static_cast< int >(result));
21469 {
21470 if (temp2)
21471 delete arg2;
21472 }
21473 return resultobj;
21474 fail:
21475 {
21476 if (temp2)
21477 delete arg2;
21478 }
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21484 PyObject *resultobj = 0;
21485 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21486 wxString *arg2 = 0 ;
21487 wxString const &arg3_defvalue = wxPyEmptyString ;
21488 wxString *arg3 = (wxString *) &arg3_defvalue ;
21489 wxString result;
21490 void *argp1 = 0 ;
21491 int res1 = 0 ;
21492 bool temp2 = false ;
21493 bool temp3 = false ;
21494 PyObject * obj0 = 0 ;
21495 PyObject * obj1 = 0 ;
21496 PyObject * obj2 = 0 ;
21497 char * kwnames[] = {
21498 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21499 };
21500
21501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21503 if (!SWIG_IsOK(res1)) {
21504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21505 }
21506 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21507 {
21508 arg2 = wxString_in_helper(obj1);
21509 if (arg2 == NULL) SWIG_fail;
21510 temp2 = true;
21511 }
21512 if (obj2) {
21513 {
21514 arg3 = wxString_in_helper(obj2);
21515 if (arg3 == NULL) SWIG_fail;
21516 temp3 = true;
21517 }
21518 }
21519 {
21520 PyThreadState* __tstate = wxPyBeginAllowThreads();
21521 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 {
21526 #if wxUSE_UNICODE
21527 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21528 #else
21529 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21530 #endif
21531 }
21532 {
21533 if (temp2)
21534 delete arg2;
21535 }
21536 {
21537 if (temp3)
21538 delete arg3;
21539 }
21540 return resultobj;
21541 fail:
21542 {
21543 if (temp2)
21544 delete arg2;
21545 }
21546 {
21547 if (temp3)
21548 delete arg3;
21549 }
21550 return NULL;
21551 }
21552
21553
21554 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21555 PyObject *resultobj = 0;
21556 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21557 wxString *arg2 = 0 ;
21558 long arg3 = (long) 0 ;
21559 long result;
21560 void *argp1 = 0 ;
21561 int res1 = 0 ;
21562 bool temp2 = false ;
21563 long val3 ;
21564 int ecode3 = 0 ;
21565 PyObject * obj0 = 0 ;
21566 PyObject * obj1 = 0 ;
21567 PyObject * obj2 = 0 ;
21568 char * kwnames[] = {
21569 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21570 };
21571
21572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21574 if (!SWIG_IsOK(res1)) {
21575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21576 }
21577 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21578 {
21579 arg2 = wxString_in_helper(obj1);
21580 if (arg2 == NULL) SWIG_fail;
21581 temp2 = true;
21582 }
21583 if (obj2) {
21584 ecode3 = SWIG_AsVal_long(obj2, &val3);
21585 if (!SWIG_IsOK(ecode3)) {
21586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21587 }
21588 arg3 = static_cast< long >(val3);
21589 }
21590 {
21591 PyThreadState* __tstate = wxPyBeginAllowThreads();
21592 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21593 wxPyEndAllowThreads(__tstate);
21594 if (PyErr_Occurred()) SWIG_fail;
21595 }
21596 resultobj = SWIG_From_long(static_cast< long >(result));
21597 {
21598 if (temp2)
21599 delete arg2;
21600 }
21601 return resultobj;
21602 fail:
21603 {
21604 if (temp2)
21605 delete arg2;
21606 }
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21612 PyObject *resultobj = 0;
21613 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21614 wxString *arg2 = 0 ;
21615 double arg3 = (double) 0.0 ;
21616 double result;
21617 void *argp1 = 0 ;
21618 int res1 = 0 ;
21619 bool temp2 = false ;
21620 double val3 ;
21621 int ecode3 = 0 ;
21622 PyObject * obj0 = 0 ;
21623 PyObject * obj1 = 0 ;
21624 PyObject * obj2 = 0 ;
21625 char * kwnames[] = {
21626 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21627 };
21628
21629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21631 if (!SWIG_IsOK(res1)) {
21632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21633 }
21634 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21635 {
21636 arg2 = wxString_in_helper(obj1);
21637 if (arg2 == NULL) SWIG_fail;
21638 temp2 = true;
21639 }
21640 if (obj2) {
21641 ecode3 = SWIG_AsVal_double(obj2, &val3);
21642 if (!SWIG_IsOK(ecode3)) {
21643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21644 }
21645 arg3 = static_cast< double >(val3);
21646 }
21647 {
21648 PyThreadState* __tstate = wxPyBeginAllowThreads();
21649 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21650 wxPyEndAllowThreads(__tstate);
21651 if (PyErr_Occurred()) SWIG_fail;
21652 }
21653 resultobj = SWIG_From_double(static_cast< double >(result));
21654 {
21655 if (temp2)
21656 delete arg2;
21657 }
21658 return resultobj;
21659 fail:
21660 {
21661 if (temp2)
21662 delete arg2;
21663 }
21664 return NULL;
21665 }
21666
21667
21668 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21669 PyObject *resultobj = 0;
21670 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21671 wxString *arg2 = 0 ;
21672 bool arg3 = (bool) false ;
21673 bool result;
21674 void *argp1 = 0 ;
21675 int res1 = 0 ;
21676 bool temp2 = false ;
21677 bool val3 ;
21678 int ecode3 = 0 ;
21679 PyObject * obj0 = 0 ;
21680 PyObject * obj1 = 0 ;
21681 PyObject * obj2 = 0 ;
21682 char * kwnames[] = {
21683 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21684 };
21685
21686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21688 if (!SWIG_IsOK(res1)) {
21689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21690 }
21691 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21692 {
21693 arg2 = wxString_in_helper(obj1);
21694 if (arg2 == NULL) SWIG_fail;
21695 temp2 = true;
21696 }
21697 if (obj2) {
21698 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21699 if (!SWIG_IsOK(ecode3)) {
21700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21701 }
21702 arg3 = static_cast< bool >(val3);
21703 }
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 {
21711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21712 }
21713 {
21714 if (temp2)
21715 delete arg2;
21716 }
21717 return resultobj;
21718 fail:
21719 {
21720 if (temp2)
21721 delete arg2;
21722 }
21723 return NULL;
21724 }
21725
21726
21727 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21728 PyObject *resultobj = 0;
21729 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21730 wxString *arg2 = 0 ;
21731 wxString *arg3 = 0 ;
21732 bool result;
21733 void *argp1 = 0 ;
21734 int res1 = 0 ;
21735 bool temp2 = false ;
21736 bool temp3 = false ;
21737 PyObject * obj0 = 0 ;
21738 PyObject * obj1 = 0 ;
21739 PyObject * obj2 = 0 ;
21740 char * kwnames[] = {
21741 (char *) "self",(char *) "key",(char *) "value", NULL
21742 };
21743
21744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21746 if (!SWIG_IsOK(res1)) {
21747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21748 }
21749 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21750 {
21751 arg2 = wxString_in_helper(obj1);
21752 if (arg2 == NULL) SWIG_fail;
21753 temp2 = true;
21754 }
21755 {
21756 arg3 = wxString_in_helper(obj2);
21757 if (arg3 == NULL) SWIG_fail;
21758 temp3 = true;
21759 }
21760 {
21761 PyThreadState* __tstate = wxPyBeginAllowThreads();
21762 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 {
21767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21768 }
21769 {
21770 if (temp2)
21771 delete arg2;
21772 }
21773 {
21774 if (temp3)
21775 delete arg3;
21776 }
21777 return resultobj;
21778 fail:
21779 {
21780 if (temp2)
21781 delete arg2;
21782 }
21783 {
21784 if (temp3)
21785 delete arg3;
21786 }
21787 return NULL;
21788 }
21789
21790
21791 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21792 PyObject *resultobj = 0;
21793 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21794 wxString *arg2 = 0 ;
21795 long arg3 ;
21796 bool result;
21797 void *argp1 = 0 ;
21798 int res1 = 0 ;
21799 bool temp2 = false ;
21800 long val3 ;
21801 int ecode3 = 0 ;
21802 PyObject * obj0 = 0 ;
21803 PyObject * obj1 = 0 ;
21804 PyObject * obj2 = 0 ;
21805 char * kwnames[] = {
21806 (char *) "self",(char *) "key",(char *) "value", NULL
21807 };
21808
21809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21811 if (!SWIG_IsOK(res1)) {
21812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21813 }
21814 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21815 {
21816 arg2 = wxString_in_helper(obj1);
21817 if (arg2 == NULL) SWIG_fail;
21818 temp2 = true;
21819 }
21820 ecode3 = SWIG_AsVal_long(obj2, &val3);
21821 if (!SWIG_IsOK(ecode3)) {
21822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21823 }
21824 arg3 = static_cast< long >(val3);
21825 {
21826 PyThreadState* __tstate = wxPyBeginAllowThreads();
21827 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21828 wxPyEndAllowThreads(__tstate);
21829 if (PyErr_Occurred()) SWIG_fail;
21830 }
21831 {
21832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21833 }
21834 {
21835 if (temp2)
21836 delete arg2;
21837 }
21838 return resultobj;
21839 fail:
21840 {
21841 if (temp2)
21842 delete arg2;
21843 }
21844 return NULL;
21845 }
21846
21847
21848 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21849 PyObject *resultobj = 0;
21850 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21851 wxString *arg2 = 0 ;
21852 double arg3 ;
21853 bool result;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 bool temp2 = false ;
21857 double val3 ;
21858 int ecode3 = 0 ;
21859 PyObject * obj0 = 0 ;
21860 PyObject * obj1 = 0 ;
21861 PyObject * obj2 = 0 ;
21862 char * kwnames[] = {
21863 (char *) "self",(char *) "key",(char *) "value", NULL
21864 };
21865
21866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21868 if (!SWIG_IsOK(res1)) {
21869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21870 }
21871 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21872 {
21873 arg2 = wxString_in_helper(obj1);
21874 if (arg2 == NULL) SWIG_fail;
21875 temp2 = true;
21876 }
21877 ecode3 = SWIG_AsVal_double(obj2, &val3);
21878 if (!SWIG_IsOK(ecode3)) {
21879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21880 }
21881 arg3 = static_cast< double >(val3);
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 {
21889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21890 }
21891 {
21892 if (temp2)
21893 delete arg2;
21894 }
21895 return resultobj;
21896 fail:
21897 {
21898 if (temp2)
21899 delete arg2;
21900 }
21901 return NULL;
21902 }
21903
21904
21905 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21906 PyObject *resultobj = 0;
21907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21908 wxString *arg2 = 0 ;
21909 bool arg3 ;
21910 bool result;
21911 void *argp1 = 0 ;
21912 int res1 = 0 ;
21913 bool temp2 = false ;
21914 bool val3 ;
21915 int ecode3 = 0 ;
21916 PyObject * obj0 = 0 ;
21917 PyObject * obj1 = 0 ;
21918 PyObject * obj2 = 0 ;
21919 char * kwnames[] = {
21920 (char *) "self",(char *) "key",(char *) "value", NULL
21921 };
21922
21923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21925 if (!SWIG_IsOK(res1)) {
21926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21927 }
21928 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21929 {
21930 arg2 = wxString_in_helper(obj1);
21931 if (arg2 == NULL) SWIG_fail;
21932 temp2 = true;
21933 }
21934 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21935 if (!SWIG_IsOK(ecode3)) {
21936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21937 }
21938 arg3 = static_cast< bool >(val3);
21939 {
21940 PyThreadState* __tstate = wxPyBeginAllowThreads();
21941 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21942 wxPyEndAllowThreads(__tstate);
21943 if (PyErr_Occurred()) SWIG_fail;
21944 }
21945 {
21946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21947 }
21948 {
21949 if (temp2)
21950 delete arg2;
21951 }
21952 return resultobj;
21953 fail:
21954 {
21955 if (temp2)
21956 delete arg2;
21957 }
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj = 0;
21964 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21965 bool arg2 = (bool) false ;
21966 bool result;
21967 void *argp1 = 0 ;
21968 int res1 = 0 ;
21969 bool val2 ;
21970 int ecode2 = 0 ;
21971 PyObject * obj0 = 0 ;
21972 PyObject * obj1 = 0 ;
21973 char * kwnames[] = {
21974 (char *) "self",(char *) "currentOnly", NULL
21975 };
21976
21977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21979 if (!SWIG_IsOK(res1)) {
21980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21981 }
21982 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21983 if (obj1) {
21984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21985 if (!SWIG_IsOK(ecode2)) {
21986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21987 }
21988 arg2 = static_cast< bool >(val2);
21989 }
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 result = (bool)(arg1)->Flush(arg2);
21993 wxPyEndAllowThreads(__tstate);
21994 if (PyErr_Occurred()) SWIG_fail;
21995 }
21996 {
21997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21998 }
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22006 PyObject *resultobj = 0;
22007 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22008 wxString *arg2 = 0 ;
22009 wxString *arg3 = 0 ;
22010 bool result;
22011 void *argp1 = 0 ;
22012 int res1 = 0 ;
22013 bool temp2 = false ;
22014 bool temp3 = false ;
22015 PyObject * obj0 = 0 ;
22016 PyObject * obj1 = 0 ;
22017 PyObject * obj2 = 0 ;
22018 char * kwnames[] = {
22019 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22020 };
22021
22022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22024 if (!SWIG_IsOK(res1)) {
22025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22026 }
22027 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22028 {
22029 arg2 = wxString_in_helper(obj1);
22030 if (arg2 == NULL) SWIG_fail;
22031 temp2 = true;
22032 }
22033 {
22034 arg3 = wxString_in_helper(obj2);
22035 if (arg3 == NULL) SWIG_fail;
22036 temp3 = true;
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 {
22045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22046 }
22047 {
22048 if (temp2)
22049 delete arg2;
22050 }
22051 {
22052 if (temp3)
22053 delete arg3;
22054 }
22055 return resultobj;
22056 fail:
22057 {
22058 if (temp2)
22059 delete arg2;
22060 }
22061 {
22062 if (temp3)
22063 delete arg3;
22064 }
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22070 PyObject *resultobj = 0;
22071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22072 wxString *arg2 = 0 ;
22073 wxString *arg3 = 0 ;
22074 bool result;
22075 void *argp1 = 0 ;
22076 int res1 = 0 ;
22077 bool temp2 = false ;
22078 bool temp3 = false ;
22079 PyObject * obj0 = 0 ;
22080 PyObject * obj1 = 0 ;
22081 PyObject * obj2 = 0 ;
22082 char * kwnames[] = {
22083 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22084 };
22085
22086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22088 if (!SWIG_IsOK(res1)) {
22089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22090 }
22091 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22092 {
22093 arg2 = wxString_in_helper(obj1);
22094 if (arg2 == NULL) SWIG_fail;
22095 temp2 = true;
22096 }
22097 {
22098 arg3 = wxString_in_helper(obj2);
22099 if (arg3 == NULL) SWIG_fail;
22100 temp3 = true;
22101 }
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 {
22109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22110 }
22111 {
22112 if (temp2)
22113 delete arg2;
22114 }
22115 {
22116 if (temp3)
22117 delete arg3;
22118 }
22119 return resultobj;
22120 fail:
22121 {
22122 if (temp2)
22123 delete arg2;
22124 }
22125 {
22126 if (temp3)
22127 delete arg3;
22128 }
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22134 PyObject *resultobj = 0;
22135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22136 wxString *arg2 = 0 ;
22137 bool arg3 = (bool) true ;
22138 bool result;
22139 void *argp1 = 0 ;
22140 int res1 = 0 ;
22141 bool temp2 = false ;
22142 bool val3 ;
22143 int ecode3 = 0 ;
22144 PyObject * obj0 = 0 ;
22145 PyObject * obj1 = 0 ;
22146 PyObject * obj2 = 0 ;
22147 char * kwnames[] = {
22148 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22149 };
22150
22151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22153 if (!SWIG_IsOK(res1)) {
22154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22155 }
22156 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22157 {
22158 arg2 = wxString_in_helper(obj1);
22159 if (arg2 == NULL) SWIG_fail;
22160 temp2 = true;
22161 }
22162 if (obj2) {
22163 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22164 if (!SWIG_IsOK(ecode3)) {
22165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22166 }
22167 arg3 = static_cast< bool >(val3);
22168 }
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 {
22176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22177 }
22178 {
22179 if (temp2)
22180 delete arg2;
22181 }
22182 return resultobj;
22183 fail:
22184 {
22185 if (temp2)
22186 delete arg2;
22187 }
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj = 0;
22194 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22195 wxString *arg2 = 0 ;
22196 bool result;
22197 void *argp1 = 0 ;
22198 int res1 = 0 ;
22199 bool temp2 = false ;
22200 PyObject * obj0 = 0 ;
22201 PyObject * obj1 = 0 ;
22202 char * kwnames[] = {
22203 (char *) "self",(char *) "key", NULL
22204 };
22205
22206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22208 if (!SWIG_IsOK(res1)) {
22209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22210 }
22211 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22212 {
22213 arg2 = wxString_in_helper(obj1);
22214 if (arg2 == NULL) SWIG_fail;
22215 temp2 = true;
22216 }
22217 {
22218 PyThreadState* __tstate = wxPyBeginAllowThreads();
22219 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22220 wxPyEndAllowThreads(__tstate);
22221 if (PyErr_Occurred()) SWIG_fail;
22222 }
22223 {
22224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22225 }
22226 {
22227 if (temp2)
22228 delete arg2;
22229 }
22230 return resultobj;
22231 fail:
22232 {
22233 if (temp2)
22234 delete arg2;
22235 }
22236 return NULL;
22237 }
22238
22239
22240 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22241 PyObject *resultobj = 0;
22242 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22243 bool result;
22244 void *argp1 = 0 ;
22245 int res1 = 0 ;
22246 PyObject *swig_obj[1] ;
22247
22248 if (!args) SWIG_fail;
22249 swig_obj[0] = args;
22250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22251 if (!SWIG_IsOK(res1)) {
22252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22253 }
22254 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22255 {
22256 PyThreadState* __tstate = wxPyBeginAllowThreads();
22257 result = (bool)(arg1)->DeleteAll();
22258 wxPyEndAllowThreads(__tstate);
22259 if (PyErr_Occurred()) SWIG_fail;
22260 }
22261 {
22262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22263 }
22264 return resultobj;
22265 fail:
22266 return NULL;
22267 }
22268
22269
22270 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22271 PyObject *resultobj = 0;
22272 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22273 bool arg2 = (bool) true ;
22274 void *argp1 = 0 ;
22275 int res1 = 0 ;
22276 bool val2 ;
22277 int ecode2 = 0 ;
22278 PyObject * obj0 = 0 ;
22279 PyObject * obj1 = 0 ;
22280 char * kwnames[] = {
22281 (char *) "self",(char *) "doIt", NULL
22282 };
22283
22284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22286 if (!SWIG_IsOK(res1)) {
22287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22288 }
22289 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22290 if (obj1) {
22291 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22292 if (!SWIG_IsOK(ecode2)) {
22293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22294 }
22295 arg2 = static_cast< bool >(val2);
22296 }
22297 {
22298 PyThreadState* __tstate = wxPyBeginAllowThreads();
22299 (arg1)->SetExpandEnvVars(arg2);
22300 wxPyEndAllowThreads(__tstate);
22301 if (PyErr_Occurred()) SWIG_fail;
22302 }
22303 resultobj = SWIG_Py_Void();
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22311 PyObject *resultobj = 0;
22312 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22313 bool result;
22314 void *argp1 = 0 ;
22315 int res1 = 0 ;
22316 PyObject *swig_obj[1] ;
22317
22318 if (!args) SWIG_fail;
22319 swig_obj[0] = args;
22320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22321 if (!SWIG_IsOK(res1)) {
22322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22323 }
22324 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22325 {
22326 PyThreadState* __tstate = wxPyBeginAllowThreads();
22327 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 {
22332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22333 }
22334 return resultobj;
22335 fail:
22336 return NULL;
22337 }
22338
22339
22340 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22341 PyObject *resultobj = 0;
22342 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22343 bool arg2 = (bool) true ;
22344 void *argp1 = 0 ;
22345 int res1 = 0 ;
22346 bool val2 ;
22347 int ecode2 = 0 ;
22348 PyObject * obj0 = 0 ;
22349 PyObject * obj1 = 0 ;
22350 char * kwnames[] = {
22351 (char *) "self",(char *) "doIt", NULL
22352 };
22353
22354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22356 if (!SWIG_IsOK(res1)) {
22357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22358 }
22359 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22360 if (obj1) {
22361 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22362 if (!SWIG_IsOK(ecode2)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22364 }
22365 arg2 = static_cast< bool >(val2);
22366 }
22367 {
22368 PyThreadState* __tstate = wxPyBeginAllowThreads();
22369 (arg1)->SetRecordDefaults(arg2);
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 resultobj = SWIG_Py_Void();
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22383 bool result;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 PyObject *swig_obj[1] ;
22387
22388 if (!args) SWIG_fail;
22389 swig_obj[0] = args;
22390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22393 }
22394 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22395 {
22396 PyThreadState* __tstate = wxPyBeginAllowThreads();
22397 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22398 wxPyEndAllowThreads(__tstate);
22399 if (PyErr_Occurred()) SWIG_fail;
22400 }
22401 {
22402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22403 }
22404 return resultobj;
22405 fail:
22406 return NULL;
22407 }
22408
22409
22410 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22411 PyObject *resultobj = 0;
22412 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22413 wxString *arg2 = 0 ;
22414 wxString result;
22415 void *argp1 = 0 ;
22416 int res1 = 0 ;
22417 bool temp2 = false ;
22418 PyObject * obj0 = 0 ;
22419 PyObject * obj1 = 0 ;
22420 char * kwnames[] = {
22421 (char *) "self",(char *) "str", NULL
22422 };
22423
22424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22426 if (!SWIG_IsOK(res1)) {
22427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22428 }
22429 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22430 {
22431 arg2 = wxString_in_helper(obj1);
22432 if (arg2 == NULL) SWIG_fail;
22433 temp2 = true;
22434 }
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22438 wxPyEndAllowThreads(__tstate);
22439 if (PyErr_Occurred()) SWIG_fail;
22440 }
22441 {
22442 #if wxUSE_UNICODE
22443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22444 #else
22445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22446 #endif
22447 }
22448 {
22449 if (temp2)
22450 delete arg2;
22451 }
22452 return resultobj;
22453 fail:
22454 {
22455 if (temp2)
22456 delete arg2;
22457 }
22458 return NULL;
22459 }
22460
22461
22462 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22463 PyObject *resultobj = 0;
22464 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22465 wxString result;
22466 void *argp1 = 0 ;
22467 int res1 = 0 ;
22468 PyObject *swig_obj[1] ;
22469
22470 if (!args) SWIG_fail;
22471 swig_obj[0] = args;
22472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22473 if (!SWIG_IsOK(res1)) {
22474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22475 }
22476 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 result = ((wxConfigBase const *)arg1)->GetAppName();
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 {
22484 #if wxUSE_UNICODE
22485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22486 #else
22487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22488 #endif
22489 }
22490 return resultobj;
22491 fail:
22492 return NULL;
22493 }
22494
22495
22496 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22497 PyObject *resultobj = 0;
22498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22499 wxString result;
22500 void *argp1 = 0 ;
22501 int res1 = 0 ;
22502 PyObject *swig_obj[1] ;
22503
22504 if (!args) SWIG_fail;
22505 swig_obj[0] = args;
22506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22507 if (!SWIG_IsOK(res1)) {
22508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22509 }
22510 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22511 {
22512 PyThreadState* __tstate = wxPyBeginAllowThreads();
22513 result = ((wxConfigBase const *)arg1)->GetVendorName();
22514 wxPyEndAllowThreads(__tstate);
22515 if (PyErr_Occurred()) SWIG_fail;
22516 }
22517 {
22518 #if wxUSE_UNICODE
22519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22520 #else
22521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22522 #endif
22523 }
22524 return resultobj;
22525 fail:
22526 return NULL;
22527 }
22528
22529
22530 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22531 PyObject *resultobj = 0;
22532 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22533 wxString *arg2 = 0 ;
22534 void *argp1 = 0 ;
22535 int res1 = 0 ;
22536 bool temp2 = false ;
22537 PyObject * obj0 = 0 ;
22538 PyObject * obj1 = 0 ;
22539 char * kwnames[] = {
22540 (char *) "self",(char *) "appName", NULL
22541 };
22542
22543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22545 if (!SWIG_IsOK(res1)) {
22546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22547 }
22548 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22549 {
22550 arg2 = wxString_in_helper(obj1);
22551 if (arg2 == NULL) SWIG_fail;
22552 temp2 = true;
22553 }
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 (arg1)->SetAppName((wxString const &)*arg2);
22557 wxPyEndAllowThreads(__tstate);
22558 if (PyErr_Occurred()) SWIG_fail;
22559 }
22560 resultobj = SWIG_Py_Void();
22561 {
22562 if (temp2)
22563 delete arg2;
22564 }
22565 return resultobj;
22566 fail:
22567 {
22568 if (temp2)
22569 delete arg2;
22570 }
22571 return NULL;
22572 }
22573
22574
22575 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22576 PyObject *resultobj = 0;
22577 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22578 wxString *arg2 = 0 ;
22579 void *argp1 = 0 ;
22580 int res1 = 0 ;
22581 bool temp2 = false ;
22582 PyObject * obj0 = 0 ;
22583 PyObject * obj1 = 0 ;
22584 char * kwnames[] = {
22585 (char *) "self",(char *) "vendorName", NULL
22586 };
22587
22588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22592 }
22593 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22594 {
22595 arg2 = wxString_in_helper(obj1);
22596 if (arg2 == NULL) SWIG_fail;
22597 temp2 = true;
22598 }
22599 {
22600 PyThreadState* __tstate = wxPyBeginAllowThreads();
22601 (arg1)->SetVendorName((wxString const &)*arg2);
22602 wxPyEndAllowThreads(__tstate);
22603 if (PyErr_Occurred()) SWIG_fail;
22604 }
22605 resultobj = SWIG_Py_Void();
22606 {
22607 if (temp2)
22608 delete arg2;
22609 }
22610 return resultobj;
22611 fail:
22612 {
22613 if (temp2)
22614 delete arg2;
22615 }
22616 return NULL;
22617 }
22618
22619
22620 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22621 PyObject *resultobj = 0;
22622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22623 long arg2 ;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 long val2 ;
22627 int ecode2 = 0 ;
22628 PyObject * obj0 = 0 ;
22629 PyObject * obj1 = 0 ;
22630 char * kwnames[] = {
22631 (char *) "self",(char *) "style", NULL
22632 };
22633
22634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22638 }
22639 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22640 ecode2 = SWIG_AsVal_long(obj1, &val2);
22641 if (!SWIG_IsOK(ecode2)) {
22642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22643 }
22644 arg2 = static_cast< long >(val2);
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 (arg1)->SetStyle(arg2);
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 resultobj = SWIG_Py_Void();
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22659 PyObject *resultobj = 0;
22660 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22661 long result;
22662 void *argp1 = 0 ;
22663 int res1 = 0 ;
22664 PyObject *swig_obj[1] ;
22665
22666 if (!args) SWIG_fail;
22667 swig_obj[0] = args;
22668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22669 if (!SWIG_IsOK(res1)) {
22670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22671 }
22672 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 resultobj = SWIG_From_long(static_cast< long >(result));
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22687 PyObject *obj;
22688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22689 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22690 return SWIG_Py_Void();
22691 }
22692
22693 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22694 PyObject *resultobj = 0;
22695 wxString const &arg1_defvalue = wxPyEmptyString ;
22696 wxString *arg1 = (wxString *) &arg1_defvalue ;
22697 wxString const &arg2_defvalue = wxPyEmptyString ;
22698 wxString *arg2 = (wxString *) &arg2_defvalue ;
22699 wxString const &arg3_defvalue = wxPyEmptyString ;
22700 wxString *arg3 = (wxString *) &arg3_defvalue ;
22701 wxString const &arg4_defvalue = wxPyEmptyString ;
22702 wxString *arg4 = (wxString *) &arg4_defvalue ;
22703 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22704 wxConfig *result = 0 ;
22705 bool temp1 = false ;
22706 bool temp2 = false ;
22707 bool temp3 = false ;
22708 bool temp4 = false ;
22709 long val5 ;
22710 int ecode5 = 0 ;
22711 PyObject * obj0 = 0 ;
22712 PyObject * obj1 = 0 ;
22713 PyObject * obj2 = 0 ;
22714 PyObject * obj3 = 0 ;
22715 PyObject * obj4 = 0 ;
22716 char * kwnames[] = {
22717 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22718 };
22719
22720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22721 if (obj0) {
22722 {
22723 arg1 = wxString_in_helper(obj0);
22724 if (arg1 == NULL) SWIG_fail;
22725 temp1 = true;
22726 }
22727 }
22728 if (obj1) {
22729 {
22730 arg2 = wxString_in_helper(obj1);
22731 if (arg2 == NULL) SWIG_fail;
22732 temp2 = true;
22733 }
22734 }
22735 if (obj2) {
22736 {
22737 arg3 = wxString_in_helper(obj2);
22738 if (arg3 == NULL) SWIG_fail;
22739 temp3 = true;
22740 }
22741 }
22742 if (obj3) {
22743 {
22744 arg4 = wxString_in_helper(obj3);
22745 if (arg4 == NULL) SWIG_fail;
22746 temp4 = true;
22747 }
22748 }
22749 if (obj4) {
22750 ecode5 = SWIG_AsVal_long(obj4, &val5);
22751 if (!SWIG_IsOK(ecode5)) {
22752 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22753 }
22754 arg5 = static_cast< long >(val5);
22755 }
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22763 {
22764 if (temp1)
22765 delete arg1;
22766 }
22767 {
22768 if (temp2)
22769 delete arg2;
22770 }
22771 {
22772 if (temp3)
22773 delete arg3;
22774 }
22775 {
22776 if (temp4)
22777 delete arg4;
22778 }
22779 return resultobj;
22780 fail:
22781 {
22782 if (temp1)
22783 delete arg1;
22784 }
22785 {
22786 if (temp2)
22787 delete arg2;
22788 }
22789 {
22790 if (temp3)
22791 delete arg3;
22792 }
22793 {
22794 if (temp4)
22795 delete arg4;
22796 }
22797 return NULL;
22798 }
22799
22800
22801 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802 PyObject *resultobj = 0;
22803 wxConfig *arg1 = (wxConfig *) 0 ;
22804 void *argp1 = 0 ;
22805 int res1 = 0 ;
22806 PyObject *swig_obj[1] ;
22807
22808 if (!args) SWIG_fail;
22809 swig_obj[0] = args;
22810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22811 if (!SWIG_IsOK(res1)) {
22812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22813 }
22814 arg1 = reinterpret_cast< wxConfig * >(argp1);
22815 {
22816 PyThreadState* __tstate = wxPyBeginAllowThreads();
22817 delete arg1;
22818
22819 wxPyEndAllowThreads(__tstate);
22820 if (PyErr_Occurred()) SWIG_fail;
22821 }
22822 resultobj = SWIG_Py_Void();
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22830 PyObject *obj;
22831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22832 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22833 return SWIG_Py_Void();
22834 }
22835
22836 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22837 return SWIG_Python_InitShadowInstance(args);
22838 }
22839
22840 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22841 PyObject *resultobj = 0;
22842 wxString const &arg1_defvalue = wxPyEmptyString ;
22843 wxString *arg1 = (wxString *) &arg1_defvalue ;
22844 wxString const &arg2_defvalue = wxPyEmptyString ;
22845 wxString *arg2 = (wxString *) &arg2_defvalue ;
22846 wxString const &arg3_defvalue = wxPyEmptyString ;
22847 wxString *arg3 = (wxString *) &arg3_defvalue ;
22848 wxString const &arg4_defvalue = wxPyEmptyString ;
22849 wxString *arg4 = (wxString *) &arg4_defvalue ;
22850 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22851 wxFileConfig *result = 0 ;
22852 bool temp1 = false ;
22853 bool temp2 = false ;
22854 bool temp3 = false ;
22855 bool temp4 = false ;
22856 long val5 ;
22857 int ecode5 = 0 ;
22858 PyObject * obj0 = 0 ;
22859 PyObject * obj1 = 0 ;
22860 PyObject * obj2 = 0 ;
22861 PyObject * obj3 = 0 ;
22862 PyObject * obj4 = 0 ;
22863 char * kwnames[] = {
22864 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22865 };
22866
22867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22868 if (obj0) {
22869 {
22870 arg1 = wxString_in_helper(obj0);
22871 if (arg1 == NULL) SWIG_fail;
22872 temp1 = true;
22873 }
22874 }
22875 if (obj1) {
22876 {
22877 arg2 = wxString_in_helper(obj1);
22878 if (arg2 == NULL) SWIG_fail;
22879 temp2 = true;
22880 }
22881 }
22882 if (obj2) {
22883 {
22884 arg3 = wxString_in_helper(obj2);
22885 if (arg3 == NULL) SWIG_fail;
22886 temp3 = true;
22887 }
22888 }
22889 if (obj3) {
22890 {
22891 arg4 = wxString_in_helper(obj3);
22892 if (arg4 == NULL) SWIG_fail;
22893 temp4 = true;
22894 }
22895 }
22896 if (obj4) {
22897 ecode5 = SWIG_AsVal_long(obj4, &val5);
22898 if (!SWIG_IsOK(ecode5)) {
22899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22900 }
22901 arg5 = static_cast< long >(val5);
22902 }
22903 {
22904 PyThreadState* __tstate = wxPyBeginAllowThreads();
22905 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22906 wxPyEndAllowThreads(__tstate);
22907 if (PyErr_Occurred()) SWIG_fail;
22908 }
22909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22910 {
22911 if (temp1)
22912 delete arg1;
22913 }
22914 {
22915 if (temp2)
22916 delete arg2;
22917 }
22918 {
22919 if (temp3)
22920 delete arg3;
22921 }
22922 {
22923 if (temp4)
22924 delete arg4;
22925 }
22926 return resultobj;
22927 fail:
22928 {
22929 if (temp1)
22930 delete arg1;
22931 }
22932 {
22933 if (temp2)
22934 delete arg2;
22935 }
22936 {
22937 if (temp3)
22938 delete arg3;
22939 }
22940 {
22941 if (temp4)
22942 delete arg4;
22943 }
22944 return NULL;
22945 }
22946
22947
22948 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22949 PyObject *resultobj = 0;
22950 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22951 void *argp1 = 0 ;
22952 int res1 = 0 ;
22953 PyObject *swig_obj[1] ;
22954
22955 if (!args) SWIG_fail;
22956 swig_obj[0] = args;
22957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22958 if (!SWIG_IsOK(res1)) {
22959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22960 }
22961 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22962 {
22963 PyThreadState* __tstate = wxPyBeginAllowThreads();
22964 delete arg1;
22965
22966 wxPyEndAllowThreads(__tstate);
22967 if (PyErr_Occurred()) SWIG_fail;
22968 }
22969 resultobj = SWIG_Py_Void();
22970 return resultobj;
22971 fail:
22972 return NULL;
22973 }
22974
22975
22976 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22977 PyObject *obj;
22978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22979 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22980 return SWIG_Py_Void();
22981 }
22982
22983 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22984 return SWIG_Python_InitShadowInstance(args);
22985 }
22986
22987 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22988 PyObject *resultobj = 0;
22989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22990 wxString *arg2 = 0 ;
22991 wxConfigPathChanger *result = 0 ;
22992 void *argp1 = 0 ;
22993 int res1 = 0 ;
22994 bool temp2 = false ;
22995 PyObject * obj0 = 0 ;
22996 PyObject * obj1 = 0 ;
22997 char * kwnames[] = {
22998 (char *) "config",(char *) "entry", NULL
22999 };
23000
23001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
23002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
23003 if (!SWIG_IsOK(res1)) {
23004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
23005 }
23006 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23007 {
23008 arg2 = wxString_in_helper(obj1);
23009 if (arg2 == NULL) SWIG_fail;
23010 temp2 = true;
23011 }
23012 {
23013 PyThreadState* __tstate = wxPyBeginAllowThreads();
23014 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23015 wxPyEndAllowThreads(__tstate);
23016 if (PyErr_Occurred()) SWIG_fail;
23017 }
23018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23019 {
23020 if (temp2)
23021 delete arg2;
23022 }
23023 return resultobj;
23024 fail:
23025 {
23026 if (temp2)
23027 delete arg2;
23028 }
23029 return NULL;
23030 }
23031
23032
23033 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23034 PyObject *resultobj = 0;
23035 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23036 void *argp1 = 0 ;
23037 int res1 = 0 ;
23038 PyObject *swig_obj[1] ;
23039
23040 if (!args) SWIG_fail;
23041 swig_obj[0] = args;
23042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23043 if (!SWIG_IsOK(res1)) {
23044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23045 }
23046 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23047 {
23048 PyThreadState* __tstate = wxPyBeginAllowThreads();
23049 delete arg1;
23050
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 resultobj = SWIG_Py_Void();
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23062 PyObject *resultobj = 0;
23063 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23064 wxString *result = 0 ;
23065 void *argp1 = 0 ;
23066 int res1 = 0 ;
23067 PyObject *swig_obj[1] ;
23068
23069 if (!args) SWIG_fail;
23070 swig_obj[0] = args;
23071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23072 if (!SWIG_IsOK(res1)) {
23073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23074 }
23075 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23076 {
23077 PyThreadState* __tstate = wxPyBeginAllowThreads();
23078 {
23079 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23080 result = (wxString *) &_result_ref;
23081 }
23082 wxPyEndAllowThreads(__tstate);
23083 if (PyErr_Occurred()) SWIG_fail;
23084 }
23085 {
23086 #if wxUSE_UNICODE
23087 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23088 #else
23089 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23090 #endif
23091 }
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23099 PyObject *obj;
23100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23101 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23102 return SWIG_Py_Void();
23103 }
23104
23105 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23106 return SWIG_Python_InitShadowInstance(args);
23107 }
23108
23109 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23110 PyObject *resultobj = 0;
23111 wxString *arg1 = 0 ;
23112 wxString result;
23113 bool temp1 = false ;
23114 PyObject * obj0 = 0 ;
23115 char * kwnames[] = {
23116 (char *) "sz", NULL
23117 };
23118
23119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23120 {
23121 arg1 = wxString_in_helper(obj0);
23122 if (arg1 == NULL) SWIG_fail;
23123 temp1 = true;
23124 }
23125 {
23126 PyThreadState* __tstate = wxPyBeginAllowThreads();
23127 result = wxExpandEnvVars((wxString const &)*arg1);
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 {
23132 #if wxUSE_UNICODE
23133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23134 #else
23135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23136 #endif
23137 }
23138 {
23139 if (temp1)
23140 delete arg1;
23141 }
23142 return resultobj;
23143 fail:
23144 {
23145 if (temp1)
23146 delete arg1;
23147 }
23148 return NULL;
23149 }
23150
23151
23152 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23153 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23154 return 1;
23155 }
23156
23157
23158 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23159 PyObject *pyobj = 0;
23160
23161 {
23162 #if wxUSE_UNICODE
23163 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23164 #else
23165 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23166 #endif
23167 }
23168 return pyobj;
23169 }
23170
23171
23172 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23173 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23174 return 1;
23175 }
23176
23177
23178 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23179 PyObject *pyobj = 0;
23180
23181 {
23182 #if wxUSE_UNICODE
23183 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23184 #else
23185 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23186 #endif
23187 }
23188 return pyobj;
23189 }
23190
23191
23192 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23193 PyObject *resultobj = 0;
23194 wxDateTime::Country arg1 ;
23195 int val1 ;
23196 int ecode1 = 0 ;
23197 PyObject * obj0 = 0 ;
23198 char * kwnames[] = {
23199 (char *) "country", NULL
23200 };
23201
23202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23203 ecode1 = SWIG_AsVal_int(obj0, &val1);
23204 if (!SWIG_IsOK(ecode1)) {
23205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23206 }
23207 arg1 = static_cast< wxDateTime::Country >(val1);
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 wxDateTime::SetCountry(arg1);
23211 wxPyEndAllowThreads(__tstate);
23212 if (PyErr_Occurred()) SWIG_fail;
23213 }
23214 resultobj = SWIG_Py_Void();
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23222 PyObject *resultobj = 0;
23223 wxDateTime::Country result;
23224
23225 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (wxDateTime::Country)wxDateTime::GetCountry();
23229 wxPyEndAllowThreads(__tstate);
23230 if (PyErr_Occurred()) SWIG_fail;
23231 }
23232 resultobj = SWIG_From_int(static_cast< int >(result));
23233 return resultobj;
23234 fail:
23235 return NULL;
23236 }
23237
23238
23239 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23240 PyObject *resultobj = 0;
23241 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23242 bool result;
23243 int val1 ;
23244 int ecode1 = 0 ;
23245 PyObject * obj0 = 0 ;
23246 char * kwnames[] = {
23247 (char *) "country", NULL
23248 };
23249
23250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23251 if (obj0) {
23252 ecode1 = SWIG_AsVal_int(obj0, &val1);
23253 if (!SWIG_IsOK(ecode1)) {
23254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23255 }
23256 arg1 = static_cast< wxDateTime::Country >(val1);
23257 }
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 {
23265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23266 }
23267 return resultobj;
23268 fail:
23269 return NULL;
23270 }
23271
23272
23273 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23274 PyObject *resultobj = 0;
23275 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23276 int result;
23277 int val1 ;
23278 int ecode1 = 0 ;
23279 PyObject * obj0 = 0 ;
23280 char * kwnames[] = {
23281 (char *) "cal", NULL
23282 };
23283
23284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23285 if (obj0) {
23286 ecode1 = SWIG_AsVal_int(obj0, &val1);
23287 if (!SWIG_IsOK(ecode1)) {
23288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23289 }
23290 arg1 = static_cast< wxDateTime::Calendar >(val1);
23291 }
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 result = (int)wxDateTime::GetCurrentYear(arg1);
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 resultobj = SWIG_From_int(static_cast< int >(result));
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = 0;
23307 int arg1 ;
23308 int result;
23309 int val1 ;
23310 int ecode1 = 0 ;
23311 PyObject * obj0 = 0 ;
23312 char * kwnames[] = {
23313 (char *) "year", NULL
23314 };
23315
23316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23317 ecode1 = SWIG_AsVal_int(obj0, &val1);
23318 if (!SWIG_IsOK(ecode1)) {
23319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23320 }
23321 arg1 = static_cast< int >(val1);
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = (int)wxDateTime::ConvertYearToBC(arg1);
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 resultobj = SWIG_From_int(static_cast< int >(result));
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj = 0;
23337 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23338 wxDateTime::Month result;
23339 int val1 ;
23340 int ecode1 = 0 ;
23341 PyObject * obj0 = 0 ;
23342 char * kwnames[] = {
23343 (char *) "cal", NULL
23344 };
23345
23346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23347 if (obj0) {
23348 ecode1 = SWIG_AsVal_int(obj0, &val1);
23349 if (!SWIG_IsOK(ecode1)) {
23350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23351 }
23352 arg1 = static_cast< wxDateTime::Calendar >(val1);
23353 }
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 resultobj = SWIG_From_int(static_cast< int >(result));
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj = 0;
23369 int arg1 = (int) wxDateTime::Inv_Year ;
23370 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23371 bool result;
23372 int val1 ;
23373 int ecode1 = 0 ;
23374 int val2 ;
23375 int ecode2 = 0 ;
23376 PyObject * obj0 = 0 ;
23377 PyObject * obj1 = 0 ;
23378 char * kwnames[] = {
23379 (char *) "year",(char *) "cal", NULL
23380 };
23381
23382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23383 if (obj0) {
23384 ecode1 = SWIG_AsVal_int(obj0, &val1);
23385 if (!SWIG_IsOK(ecode1)) {
23386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23387 }
23388 arg1 = static_cast< int >(val1);
23389 }
23390 if (obj1) {
23391 ecode2 = SWIG_AsVal_int(obj1, &val2);
23392 if (!SWIG_IsOK(ecode2)) {
23393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23394 }
23395 arg2 = static_cast< wxDateTime::Calendar >(val2);
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23400 wxPyEndAllowThreads(__tstate);
23401 if (PyErr_Occurred()) SWIG_fail;
23402 }
23403 {
23404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23405 }
23406 return resultobj;
23407 fail:
23408 return NULL;
23409 }
23410
23411
23412 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23413 PyObject *resultobj = 0;
23414 int arg1 = (int) wxDateTime::Inv_Year ;
23415 int result;
23416 int val1 ;
23417 int ecode1 = 0 ;
23418 PyObject * obj0 = 0 ;
23419 char * kwnames[] = {
23420 (char *) "year", NULL
23421 };
23422
23423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23424 if (obj0) {
23425 ecode1 = SWIG_AsVal_int(obj0, &val1);
23426 if (!SWIG_IsOK(ecode1)) {
23427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23428 }
23429 arg1 = static_cast< int >(val1);
23430 }
23431 {
23432 PyThreadState* __tstate = wxPyBeginAllowThreads();
23433 result = (int)wxDateTime::GetCentury(arg1);
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 resultobj = SWIG_From_int(static_cast< int >(result));
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj = 0;
23446 int arg1 ;
23447 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23448 int result;
23449 int val1 ;
23450 int ecode1 = 0 ;
23451 int val2 ;
23452 int ecode2 = 0 ;
23453 PyObject * obj0 = 0 ;
23454 PyObject * obj1 = 0 ;
23455 char * kwnames[] = {
23456 (char *) "year",(char *) "cal", NULL
23457 };
23458
23459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23460 ecode1 = SWIG_AsVal_int(obj0, &val1);
23461 if (!SWIG_IsOK(ecode1)) {
23462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23463 }
23464 arg1 = static_cast< int >(val1);
23465 if (obj1) {
23466 ecode2 = SWIG_AsVal_int(obj1, &val2);
23467 if (!SWIG_IsOK(ecode2)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23469 }
23470 arg2 = static_cast< wxDateTime::Calendar >(val2);
23471 }
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 resultobj = SWIG_From_int(static_cast< int >(result));
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj = 0;
23487 wxDateTime::Month arg1 ;
23488 int arg2 = (int) wxDateTime::Inv_Year ;
23489 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23490 int result;
23491 int val1 ;
23492 int ecode1 = 0 ;
23493 int val2 ;
23494 int ecode2 = 0 ;
23495 int val3 ;
23496 int ecode3 = 0 ;
23497 PyObject * obj0 = 0 ;
23498 PyObject * obj1 = 0 ;
23499 PyObject * obj2 = 0 ;
23500 char * kwnames[] = {
23501 (char *) "month",(char *) "year",(char *) "cal", NULL
23502 };
23503
23504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23505 ecode1 = SWIG_AsVal_int(obj0, &val1);
23506 if (!SWIG_IsOK(ecode1)) {
23507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23508 }
23509 arg1 = static_cast< wxDateTime::Month >(val1);
23510 if (obj1) {
23511 ecode2 = SWIG_AsVal_int(obj1, &val2);
23512 if (!SWIG_IsOK(ecode2)) {
23513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23514 }
23515 arg2 = static_cast< int >(val2);
23516 }
23517 if (obj2) {
23518 ecode3 = SWIG_AsVal_int(obj2, &val3);
23519 if (!SWIG_IsOK(ecode3)) {
23520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23521 }
23522 arg3 = static_cast< wxDateTime::Calendar >(val3);
23523 }
23524 {
23525 PyThreadState* __tstate = wxPyBeginAllowThreads();
23526 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23527 wxPyEndAllowThreads(__tstate);
23528 if (PyErr_Occurred()) SWIG_fail;
23529 }
23530 resultobj = SWIG_From_int(static_cast< int >(result));
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23538 PyObject *resultobj = 0;
23539 wxDateTime::Month arg1 ;
23540 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23541 wxString result;
23542 int val1 ;
23543 int ecode1 = 0 ;
23544 int val2 ;
23545 int ecode2 = 0 ;
23546 PyObject * obj0 = 0 ;
23547 PyObject * obj1 = 0 ;
23548 char * kwnames[] = {
23549 (char *) "month",(char *) "flags", NULL
23550 };
23551
23552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23553 ecode1 = SWIG_AsVal_int(obj0, &val1);
23554 if (!SWIG_IsOK(ecode1)) {
23555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23556 }
23557 arg1 = static_cast< wxDateTime::Month >(val1);
23558 if (obj1) {
23559 ecode2 = SWIG_AsVal_int(obj1, &val2);
23560 if (!SWIG_IsOK(ecode2)) {
23561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23562 }
23563 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23564 }
23565 {
23566 PyThreadState* __tstate = wxPyBeginAllowThreads();
23567 result = wxDateTime::GetMonthName(arg1,arg2);
23568 wxPyEndAllowThreads(__tstate);
23569 if (PyErr_Occurred()) SWIG_fail;
23570 }
23571 {
23572 #if wxUSE_UNICODE
23573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23574 #else
23575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23576 #endif
23577 }
23578 return resultobj;
23579 fail:
23580 return NULL;
23581 }
23582
23583
23584 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23585 PyObject *resultobj = 0;
23586 wxDateTime::WeekDay arg1 ;
23587 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23588 wxString result;
23589 int val1 ;
23590 int ecode1 = 0 ;
23591 int val2 ;
23592 int ecode2 = 0 ;
23593 PyObject * obj0 = 0 ;
23594 PyObject * obj1 = 0 ;
23595 char * kwnames[] = {
23596 (char *) "weekday",(char *) "flags", NULL
23597 };
23598
23599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23600 ecode1 = SWIG_AsVal_int(obj0, &val1);
23601 if (!SWIG_IsOK(ecode1)) {
23602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23603 }
23604 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23605 if (obj1) {
23606 ecode2 = SWIG_AsVal_int(obj1, &val2);
23607 if (!SWIG_IsOK(ecode2)) {
23608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23609 }
23610 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23611 }
23612 {
23613 PyThreadState* __tstate = wxPyBeginAllowThreads();
23614 result = wxDateTime::GetWeekDayName(arg1,arg2);
23615 wxPyEndAllowThreads(__tstate);
23616 if (PyErr_Occurred()) SWIG_fail;
23617 }
23618 {
23619 #if wxUSE_UNICODE
23620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23621 #else
23622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23623 #endif
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23632 PyObject *resultobj = 0;
23633 PyObject *result = 0 ;
23634
23635 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23636 {
23637 PyThreadState* __tstate = wxPyBeginAllowThreads();
23638 result = (PyObject *)wxDateTime_GetAmPmStrings();
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 resultobj = result;
23643 return resultobj;
23644 fail:
23645 return NULL;
23646 }
23647
23648
23649 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj = 0;
23651 int arg1 = (int) wxDateTime::Inv_Year ;
23652 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23653 bool result;
23654 int val1 ;
23655 int ecode1 = 0 ;
23656 int val2 ;
23657 int ecode2 = 0 ;
23658 PyObject * obj0 = 0 ;
23659 PyObject * obj1 = 0 ;
23660 char * kwnames[] = {
23661 (char *) "year",(char *) "country", NULL
23662 };
23663
23664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23665 if (obj0) {
23666 ecode1 = SWIG_AsVal_int(obj0, &val1);
23667 if (!SWIG_IsOK(ecode1)) {
23668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23669 }
23670 arg1 = static_cast< int >(val1);
23671 }
23672 if (obj1) {
23673 ecode2 = SWIG_AsVal_int(obj1, &val2);
23674 if (!SWIG_IsOK(ecode2)) {
23675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23676 }
23677 arg2 = static_cast< wxDateTime::Country >(val2);
23678 }
23679 {
23680 PyThreadState* __tstate = wxPyBeginAllowThreads();
23681 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23682 wxPyEndAllowThreads(__tstate);
23683 if (PyErr_Occurred()) SWIG_fail;
23684 }
23685 {
23686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23687 }
23688 return resultobj;
23689 fail:
23690 return NULL;
23691 }
23692
23693
23694 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23695 PyObject *resultobj = 0;
23696 int arg1 = (int) wxDateTime::Inv_Year ;
23697 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23698 wxDateTime result;
23699 int val1 ;
23700 int ecode1 = 0 ;
23701 int val2 ;
23702 int ecode2 = 0 ;
23703 PyObject * obj0 = 0 ;
23704 PyObject * obj1 = 0 ;
23705 char * kwnames[] = {
23706 (char *) "year",(char *) "country", NULL
23707 };
23708
23709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23710 if (obj0) {
23711 ecode1 = SWIG_AsVal_int(obj0, &val1);
23712 if (!SWIG_IsOK(ecode1)) {
23713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23714 }
23715 arg1 = static_cast< int >(val1);
23716 }
23717 if (obj1) {
23718 ecode2 = SWIG_AsVal_int(obj1, &val2);
23719 if (!SWIG_IsOK(ecode2)) {
23720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23721 }
23722 arg2 = static_cast< wxDateTime::Country >(val2);
23723 }
23724 {
23725 PyThreadState* __tstate = wxPyBeginAllowThreads();
23726 result = wxDateTime::GetBeginDST(arg1,arg2);
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj = 0;
23739 int arg1 = (int) wxDateTime::Inv_Year ;
23740 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23741 wxDateTime result;
23742 int val1 ;
23743 int ecode1 = 0 ;
23744 int val2 ;
23745 int ecode2 = 0 ;
23746 PyObject * obj0 = 0 ;
23747 PyObject * obj1 = 0 ;
23748 char * kwnames[] = {
23749 (char *) "year",(char *) "country", NULL
23750 };
23751
23752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23753 if (obj0) {
23754 ecode1 = SWIG_AsVal_int(obj0, &val1);
23755 if (!SWIG_IsOK(ecode1)) {
23756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23757 }
23758 arg1 = static_cast< int >(val1);
23759 }
23760 if (obj1) {
23761 ecode2 = SWIG_AsVal_int(obj1, &val2);
23762 if (!SWIG_IsOK(ecode2)) {
23763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23764 }
23765 arg2 = static_cast< wxDateTime::Country >(val2);
23766 }
23767 {
23768 PyThreadState* __tstate = wxPyBeginAllowThreads();
23769 result = wxDateTime::GetEndDST(arg1,arg2);
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23781 PyObject *resultobj = 0;
23782 wxDateTime result;
23783
23784 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23785 {
23786 PyThreadState* __tstate = wxPyBeginAllowThreads();
23787 result = wxDateTime::Now();
23788 wxPyEndAllowThreads(__tstate);
23789 if (PyErr_Occurred()) SWIG_fail;
23790 }
23791 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23792 return resultobj;
23793 fail:
23794 return NULL;
23795 }
23796
23797
23798 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23799 PyObject *resultobj = 0;
23800 wxDateTime result;
23801
23802 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23803 {
23804 PyThreadState* __tstate = wxPyBeginAllowThreads();
23805 result = wxDateTime::UNow();
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23810 return resultobj;
23811 fail:
23812 return NULL;
23813 }
23814
23815
23816 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23817 PyObject *resultobj = 0;
23818 wxDateTime result;
23819
23820 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23821 {
23822 PyThreadState* __tstate = wxPyBeginAllowThreads();
23823 result = wxDateTime::Today();
23824 wxPyEndAllowThreads(__tstate);
23825 if (PyErr_Occurred()) SWIG_fail;
23826 }
23827 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23828 return resultobj;
23829 fail:
23830 return NULL;
23831 }
23832
23833
23834 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23835 PyObject *resultobj = 0;
23836 wxDateTime *result = 0 ;
23837
23838 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (wxDateTime *)new wxDateTime();
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23853 PyObject *resultobj = 0;
23854 time_t arg1 ;
23855 wxDateTime *result = 0 ;
23856 unsigned int val1 ;
23857 int ecode1 = 0 ;
23858 PyObject * obj0 = 0 ;
23859 char * kwnames[] = {
23860 (char *) "timet", NULL
23861 };
23862
23863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23864 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23865 if (!SWIG_IsOK(ecode1)) {
23866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23867 }
23868 arg1 = static_cast< time_t >(val1);
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = (wxDateTime *)new wxDateTime(arg1);
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23883 PyObject *resultobj = 0;
23884 double arg1 ;
23885 wxDateTime *result = 0 ;
23886 double val1 ;
23887 int ecode1 = 0 ;
23888 PyObject * obj0 = 0 ;
23889 char * kwnames[] = {
23890 (char *) "jdn", NULL
23891 };
23892
23893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23894 ecode1 = SWIG_AsVal_double(obj0, &val1);
23895 if (!SWIG_IsOK(ecode1)) {
23896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23897 }
23898 arg1 = static_cast< double >(val1);
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 result = (wxDateTime *)new wxDateTime(arg1);
23902 wxPyEndAllowThreads(__tstate);
23903 if (PyErr_Occurred()) SWIG_fail;
23904 }
23905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23913 PyObject *resultobj = 0;
23914 int arg1 ;
23915 int arg2 = (int) 0 ;
23916 int arg3 = (int) 0 ;
23917 int arg4 = (int) 0 ;
23918 wxDateTime *result = 0 ;
23919 int val1 ;
23920 int ecode1 = 0 ;
23921 int val2 ;
23922 int ecode2 = 0 ;
23923 int val3 ;
23924 int ecode3 = 0 ;
23925 int val4 ;
23926 int ecode4 = 0 ;
23927 PyObject * obj0 = 0 ;
23928 PyObject * obj1 = 0 ;
23929 PyObject * obj2 = 0 ;
23930 PyObject * obj3 = 0 ;
23931 char * kwnames[] = {
23932 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23933 };
23934
23935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23936 ecode1 = SWIG_AsVal_int(obj0, &val1);
23937 if (!SWIG_IsOK(ecode1)) {
23938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23939 }
23940 arg1 = static_cast< int >(val1);
23941 if (obj1) {
23942 ecode2 = SWIG_AsVal_int(obj1, &val2);
23943 if (!SWIG_IsOK(ecode2)) {
23944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23945 }
23946 arg2 = static_cast< int >(val2);
23947 }
23948 if (obj2) {
23949 ecode3 = SWIG_AsVal_int(obj2, &val3);
23950 if (!SWIG_IsOK(ecode3)) {
23951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23952 }
23953 arg3 = static_cast< int >(val3);
23954 }
23955 if (obj3) {
23956 ecode4 = SWIG_AsVal_int(obj3, &val4);
23957 if (!SWIG_IsOK(ecode4)) {
23958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23959 }
23960 arg4 = static_cast< int >(val4);
23961 }
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23976 PyObject *resultobj = 0;
23977 int arg1 ;
23978 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23979 int arg3 = (int) wxDateTime::Inv_Year ;
23980 int arg4 = (int) 0 ;
23981 int arg5 = (int) 0 ;
23982 int arg6 = (int) 0 ;
23983 int arg7 = (int) 0 ;
23984 wxDateTime *result = 0 ;
23985 int val1 ;
23986 int ecode1 = 0 ;
23987 int val2 ;
23988 int ecode2 = 0 ;
23989 int val3 ;
23990 int ecode3 = 0 ;
23991 int val4 ;
23992 int ecode4 = 0 ;
23993 int val5 ;
23994 int ecode5 = 0 ;
23995 int val6 ;
23996 int ecode6 = 0 ;
23997 int val7 ;
23998 int ecode7 = 0 ;
23999 PyObject * obj0 = 0 ;
24000 PyObject * obj1 = 0 ;
24001 PyObject * obj2 = 0 ;
24002 PyObject * obj3 = 0 ;
24003 PyObject * obj4 = 0 ;
24004 PyObject * obj5 = 0 ;
24005 PyObject * obj6 = 0 ;
24006 char * kwnames[] = {
24007 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24008 };
24009
24010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24011 ecode1 = SWIG_AsVal_int(obj0, &val1);
24012 if (!SWIG_IsOK(ecode1)) {
24013 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24014 }
24015 arg1 = static_cast< int >(val1);
24016 if (obj1) {
24017 ecode2 = SWIG_AsVal_int(obj1, &val2);
24018 if (!SWIG_IsOK(ecode2)) {
24019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24020 }
24021 arg2 = static_cast< wxDateTime::Month >(val2);
24022 }
24023 if (obj2) {
24024 ecode3 = SWIG_AsVal_int(obj2, &val3);
24025 if (!SWIG_IsOK(ecode3)) {
24026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24027 }
24028 arg3 = static_cast< int >(val3);
24029 }
24030 if (obj3) {
24031 ecode4 = SWIG_AsVal_int(obj3, &val4);
24032 if (!SWIG_IsOK(ecode4)) {
24033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24034 }
24035 arg4 = static_cast< int >(val4);
24036 }
24037 if (obj4) {
24038 ecode5 = SWIG_AsVal_int(obj4, &val5);
24039 if (!SWIG_IsOK(ecode5)) {
24040 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24041 }
24042 arg5 = static_cast< int >(val5);
24043 }
24044 if (obj5) {
24045 ecode6 = SWIG_AsVal_int(obj5, &val6);
24046 if (!SWIG_IsOK(ecode6)) {
24047 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24048 }
24049 arg6 = static_cast< int >(val6);
24050 }
24051 if (obj6) {
24052 ecode7 = SWIG_AsVal_int(obj6, &val7);
24053 if (!SWIG_IsOK(ecode7)) {
24054 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24055 }
24056 arg7 = static_cast< int >(val7);
24057 }
24058 {
24059 PyThreadState* __tstate = wxPyBeginAllowThreads();
24060 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24061 wxPyEndAllowThreads(__tstate);
24062 if (PyErr_Occurred()) SWIG_fail;
24063 }
24064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj = 0;
24073 wxDateTime *arg1 = 0 ;
24074 wxDateTime *result = 0 ;
24075 void *argp1 = 0 ;
24076 int res1 = 0 ;
24077 PyObject * obj0 = 0 ;
24078 char * kwnames[] = {
24079 (char *) "date", NULL
24080 };
24081
24082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24083 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24084 if (!SWIG_IsOK(res1)) {
24085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24086 }
24087 if (!argp1) {
24088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24089 }
24090 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24091 {
24092 PyThreadState* __tstate = wxPyBeginAllowThreads();
24093 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24094 wxPyEndAllowThreads(__tstate);
24095 if (PyErr_Occurred()) SWIG_fail;
24096 }
24097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24105 PyObject *resultobj = 0;
24106 wxDateTime *arg1 = (wxDateTime *) 0 ;
24107 void *argp1 = 0 ;
24108 int res1 = 0 ;
24109 PyObject *swig_obj[1] ;
24110
24111 if (!args) SWIG_fail;
24112 swig_obj[0] = args;
24113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24114 if (!SWIG_IsOK(res1)) {
24115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24116 }
24117 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24118 {
24119 PyThreadState* __tstate = wxPyBeginAllowThreads();
24120 delete arg1;
24121
24122 wxPyEndAllowThreads(__tstate);
24123 if (PyErr_Occurred()) SWIG_fail;
24124 }
24125 resultobj = SWIG_Py_Void();
24126 return resultobj;
24127 fail:
24128 return NULL;
24129 }
24130
24131
24132 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24133 PyObject *resultobj = 0;
24134 wxDateTime *arg1 = (wxDateTime *) 0 ;
24135 wxDateTime *result = 0 ;
24136 void *argp1 = 0 ;
24137 int res1 = 0 ;
24138 PyObject *swig_obj[1] ;
24139
24140 if (!args) SWIG_fail;
24141 swig_obj[0] = args;
24142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24143 if (!SWIG_IsOK(res1)) {
24144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24145 }
24146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24147 {
24148 PyThreadState* __tstate = wxPyBeginAllowThreads();
24149 {
24150 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24151 result = (wxDateTime *) &_result_ref;
24152 }
24153 wxPyEndAllowThreads(__tstate);
24154 if (PyErr_Occurred()) SWIG_fail;
24155 }
24156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj = 0;
24165 wxDateTime *arg1 = (wxDateTime *) 0 ;
24166 time_t arg2 ;
24167 wxDateTime *result = 0 ;
24168 void *argp1 = 0 ;
24169 int res1 = 0 ;
24170 unsigned int val2 ;
24171 int ecode2 = 0 ;
24172 PyObject * obj0 = 0 ;
24173 PyObject * obj1 = 0 ;
24174 char * kwnames[] = {
24175 (char *) "self",(char *) "timet", NULL
24176 };
24177
24178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24180 if (!SWIG_IsOK(res1)) {
24181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24182 }
24183 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24184 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24185 if (!SWIG_IsOK(ecode2)) {
24186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24187 }
24188 arg2 = static_cast< time_t >(val2);
24189 {
24190 PyThreadState* __tstate = wxPyBeginAllowThreads();
24191 {
24192 wxDateTime &_result_ref = (arg1)->Set(arg2);
24193 result = (wxDateTime *) &_result_ref;
24194 }
24195 wxPyEndAllowThreads(__tstate);
24196 if (PyErr_Occurred()) SWIG_fail;
24197 }
24198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24199 return resultobj;
24200 fail:
24201 return NULL;
24202 }
24203
24204
24205 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24206 PyObject *resultobj = 0;
24207 wxDateTime *arg1 = (wxDateTime *) 0 ;
24208 double arg2 ;
24209 wxDateTime *result = 0 ;
24210 void *argp1 = 0 ;
24211 int res1 = 0 ;
24212 double val2 ;
24213 int ecode2 = 0 ;
24214 PyObject * obj0 = 0 ;
24215 PyObject * obj1 = 0 ;
24216 char * kwnames[] = {
24217 (char *) "self",(char *) "jdn", NULL
24218 };
24219
24220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24222 if (!SWIG_IsOK(res1)) {
24223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24224 }
24225 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24226 ecode2 = SWIG_AsVal_double(obj1, &val2);
24227 if (!SWIG_IsOK(ecode2)) {
24228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24229 }
24230 arg2 = static_cast< double >(val2);
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 {
24234 wxDateTime &_result_ref = (arg1)->Set(arg2);
24235 result = (wxDateTime *) &_result_ref;
24236 }
24237 wxPyEndAllowThreads(__tstate);
24238 if (PyErr_Occurred()) SWIG_fail;
24239 }
24240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24241 return resultobj;
24242 fail:
24243 return NULL;
24244 }
24245
24246
24247 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24248 PyObject *resultobj = 0;
24249 wxDateTime *arg1 = (wxDateTime *) 0 ;
24250 int arg2 ;
24251 int arg3 = (int) 0 ;
24252 int arg4 = (int) 0 ;
24253 int arg5 = (int) 0 ;
24254 wxDateTime *result = 0 ;
24255 void *argp1 = 0 ;
24256 int res1 = 0 ;
24257 int val2 ;
24258 int ecode2 = 0 ;
24259 int val3 ;
24260 int ecode3 = 0 ;
24261 int val4 ;
24262 int ecode4 = 0 ;
24263 int val5 ;
24264 int ecode5 = 0 ;
24265 PyObject * obj0 = 0 ;
24266 PyObject * obj1 = 0 ;
24267 PyObject * obj2 = 0 ;
24268 PyObject * obj3 = 0 ;
24269 PyObject * obj4 = 0 ;
24270 char * kwnames[] = {
24271 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24272 };
24273
24274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24278 }
24279 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24280 ecode2 = SWIG_AsVal_int(obj1, &val2);
24281 if (!SWIG_IsOK(ecode2)) {
24282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24283 }
24284 arg2 = static_cast< int >(val2);
24285 if (obj2) {
24286 ecode3 = SWIG_AsVal_int(obj2, &val3);
24287 if (!SWIG_IsOK(ecode3)) {
24288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24289 }
24290 arg3 = static_cast< int >(val3);
24291 }
24292 if (obj3) {
24293 ecode4 = SWIG_AsVal_int(obj3, &val4);
24294 if (!SWIG_IsOK(ecode4)) {
24295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24296 }
24297 arg4 = static_cast< int >(val4);
24298 }
24299 if (obj4) {
24300 ecode5 = SWIG_AsVal_int(obj4, &val5);
24301 if (!SWIG_IsOK(ecode5)) {
24302 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24303 }
24304 arg5 = static_cast< int >(val5);
24305 }
24306 {
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 {
24309 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24310 result = (wxDateTime *) &_result_ref;
24311 }
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24316 return resultobj;
24317 fail:
24318 return NULL;
24319 }
24320
24321
24322 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24323 PyObject *resultobj = 0;
24324 wxDateTime *arg1 = (wxDateTime *) 0 ;
24325 int arg2 ;
24326 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24327 int arg4 = (int) wxDateTime::Inv_Year ;
24328 int arg5 = (int) 0 ;
24329 int arg6 = (int) 0 ;
24330 int arg7 = (int) 0 ;
24331 int arg8 = (int) 0 ;
24332 wxDateTime *result = 0 ;
24333 void *argp1 = 0 ;
24334 int res1 = 0 ;
24335 int val2 ;
24336 int ecode2 = 0 ;
24337 int val3 ;
24338 int ecode3 = 0 ;
24339 int val4 ;
24340 int ecode4 = 0 ;
24341 int val5 ;
24342 int ecode5 = 0 ;
24343 int val6 ;
24344 int ecode6 = 0 ;
24345 int val7 ;
24346 int ecode7 = 0 ;
24347 int val8 ;
24348 int ecode8 = 0 ;
24349 PyObject * obj0 = 0 ;
24350 PyObject * obj1 = 0 ;
24351 PyObject * obj2 = 0 ;
24352 PyObject * obj3 = 0 ;
24353 PyObject * obj4 = 0 ;
24354 PyObject * obj5 = 0 ;
24355 PyObject * obj6 = 0 ;
24356 PyObject * obj7 = 0 ;
24357 char * kwnames[] = {
24358 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24359 };
24360
24361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24363 if (!SWIG_IsOK(res1)) {
24364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24365 }
24366 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24367 ecode2 = SWIG_AsVal_int(obj1, &val2);
24368 if (!SWIG_IsOK(ecode2)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24370 }
24371 arg2 = static_cast< int >(val2);
24372 if (obj2) {
24373 ecode3 = SWIG_AsVal_int(obj2, &val3);
24374 if (!SWIG_IsOK(ecode3)) {
24375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24376 }
24377 arg3 = static_cast< wxDateTime::Month >(val3);
24378 }
24379 if (obj3) {
24380 ecode4 = SWIG_AsVal_int(obj3, &val4);
24381 if (!SWIG_IsOK(ecode4)) {
24382 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24383 }
24384 arg4 = static_cast< int >(val4);
24385 }
24386 if (obj4) {
24387 ecode5 = SWIG_AsVal_int(obj4, &val5);
24388 if (!SWIG_IsOK(ecode5)) {
24389 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24390 }
24391 arg5 = static_cast< int >(val5);
24392 }
24393 if (obj5) {
24394 ecode6 = SWIG_AsVal_int(obj5, &val6);
24395 if (!SWIG_IsOK(ecode6)) {
24396 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24397 }
24398 arg6 = static_cast< int >(val6);
24399 }
24400 if (obj6) {
24401 ecode7 = SWIG_AsVal_int(obj6, &val7);
24402 if (!SWIG_IsOK(ecode7)) {
24403 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24404 }
24405 arg7 = static_cast< int >(val7);
24406 }
24407 if (obj7) {
24408 ecode8 = SWIG_AsVal_int(obj7, &val8);
24409 if (!SWIG_IsOK(ecode8)) {
24410 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24411 }
24412 arg8 = static_cast< int >(val8);
24413 }
24414 {
24415 PyThreadState* __tstate = wxPyBeginAllowThreads();
24416 {
24417 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24418 result = (wxDateTime *) &_result_ref;
24419 }
24420 wxPyEndAllowThreads(__tstate);
24421 if (PyErr_Occurred()) SWIG_fail;
24422 }
24423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24431 PyObject *resultobj = 0;
24432 wxDateTime *arg1 = (wxDateTime *) 0 ;
24433 wxDateTime *result = 0 ;
24434 void *argp1 = 0 ;
24435 int res1 = 0 ;
24436 PyObject *swig_obj[1] ;
24437
24438 if (!args) SWIG_fail;
24439 swig_obj[0] = args;
24440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24441 if (!SWIG_IsOK(res1)) {
24442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24443 }
24444 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24445 {
24446 PyThreadState* __tstate = wxPyBeginAllowThreads();
24447 {
24448 wxDateTime &_result_ref = (arg1)->ResetTime();
24449 result = (wxDateTime *) &_result_ref;
24450 }
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *_wrap_DateTime_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 PyObject *resultobj = 0;
24463 wxDateTime *arg1 = (wxDateTime *) 0 ;
24464 wxDateTime result;
24465 void *argp1 = 0 ;
24466 int res1 = 0 ;
24467 PyObject *swig_obj[1] ;
24468
24469 if (!args) SWIG_fail;
24470 swig_obj[0] = args;
24471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24472 if (!SWIG_IsOK(res1)) {
24473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24474 }
24475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 result = ((wxDateTime const *)arg1)->GetDateOnly();
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24483 return resultobj;
24484 fail:
24485 return NULL;
24486 }
24487
24488
24489 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24490 PyObject *resultobj = 0;
24491 wxDateTime *arg1 = (wxDateTime *) 0 ;
24492 int arg2 ;
24493 wxDateTime *result = 0 ;
24494 void *argp1 = 0 ;
24495 int res1 = 0 ;
24496 int val2 ;
24497 int ecode2 = 0 ;
24498 PyObject * obj0 = 0 ;
24499 PyObject * obj1 = 0 ;
24500 char * kwnames[] = {
24501 (char *) "self",(char *) "year", NULL
24502 };
24503
24504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24506 if (!SWIG_IsOK(res1)) {
24507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24508 }
24509 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24510 ecode2 = SWIG_AsVal_int(obj1, &val2);
24511 if (!SWIG_IsOK(ecode2)) {
24512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24513 }
24514 arg2 = static_cast< int >(val2);
24515 {
24516 PyThreadState* __tstate = wxPyBeginAllowThreads();
24517 {
24518 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24519 result = (wxDateTime *) &_result_ref;
24520 }
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24532 PyObject *resultobj = 0;
24533 wxDateTime *arg1 = (wxDateTime *) 0 ;
24534 wxDateTime::Month arg2 ;
24535 wxDateTime *result = 0 ;
24536 void *argp1 = 0 ;
24537 int res1 = 0 ;
24538 int val2 ;
24539 int ecode2 = 0 ;
24540 PyObject * obj0 = 0 ;
24541 PyObject * obj1 = 0 ;
24542 char * kwnames[] = {
24543 (char *) "self",(char *) "month", NULL
24544 };
24545
24546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24548 if (!SWIG_IsOK(res1)) {
24549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24550 }
24551 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24552 ecode2 = SWIG_AsVal_int(obj1, &val2);
24553 if (!SWIG_IsOK(ecode2)) {
24554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24555 }
24556 arg2 = static_cast< wxDateTime::Month >(val2);
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 {
24560 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24561 result = (wxDateTime *) &_result_ref;
24562 }
24563 wxPyEndAllowThreads(__tstate);
24564 if (PyErr_Occurred()) SWIG_fail;
24565 }
24566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24567 return resultobj;
24568 fail:
24569 return NULL;
24570 }
24571
24572
24573 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24574 PyObject *resultobj = 0;
24575 wxDateTime *arg1 = (wxDateTime *) 0 ;
24576 int arg2 ;
24577 wxDateTime *result = 0 ;
24578 void *argp1 = 0 ;
24579 int res1 = 0 ;
24580 int val2 ;
24581 int ecode2 = 0 ;
24582 PyObject * obj0 = 0 ;
24583 PyObject * obj1 = 0 ;
24584 char * kwnames[] = {
24585 (char *) "self",(char *) "day", NULL
24586 };
24587
24588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24590 if (!SWIG_IsOK(res1)) {
24591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24592 }
24593 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24594 ecode2 = SWIG_AsVal_int(obj1, &val2);
24595 if (!SWIG_IsOK(ecode2)) {
24596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24597 }
24598 arg2 = static_cast< int >(val2);
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 {
24602 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24603 result = (wxDateTime *) &_result_ref;
24604 }
24605 wxPyEndAllowThreads(__tstate);
24606 if (PyErr_Occurred()) SWIG_fail;
24607 }
24608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj = 0;
24617 wxDateTime *arg1 = (wxDateTime *) 0 ;
24618 int arg2 ;
24619 wxDateTime *result = 0 ;
24620 void *argp1 = 0 ;
24621 int res1 = 0 ;
24622 int val2 ;
24623 int ecode2 = 0 ;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 char * kwnames[] = {
24627 (char *) "self",(char *) "hour", NULL
24628 };
24629
24630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24632 if (!SWIG_IsOK(res1)) {
24633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24634 }
24635 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24636 ecode2 = SWIG_AsVal_int(obj1, &val2);
24637 if (!SWIG_IsOK(ecode2)) {
24638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24639 }
24640 arg2 = static_cast< int >(val2);
24641 {
24642 PyThreadState* __tstate = wxPyBeginAllowThreads();
24643 {
24644 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24645 result = (wxDateTime *) &_result_ref;
24646 }
24647 wxPyEndAllowThreads(__tstate);
24648 if (PyErr_Occurred()) SWIG_fail;
24649 }
24650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24651 return resultobj;
24652 fail:
24653 return NULL;
24654 }
24655
24656
24657 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24658 PyObject *resultobj = 0;
24659 wxDateTime *arg1 = (wxDateTime *) 0 ;
24660 int arg2 ;
24661 wxDateTime *result = 0 ;
24662 void *argp1 = 0 ;
24663 int res1 = 0 ;
24664 int val2 ;
24665 int ecode2 = 0 ;
24666 PyObject * obj0 = 0 ;
24667 PyObject * obj1 = 0 ;
24668 char * kwnames[] = {
24669 (char *) "self",(char *) "minute", NULL
24670 };
24671
24672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24674 if (!SWIG_IsOK(res1)) {
24675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24676 }
24677 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24678 ecode2 = SWIG_AsVal_int(obj1, &val2);
24679 if (!SWIG_IsOK(ecode2)) {
24680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24681 }
24682 arg2 = static_cast< int >(val2);
24683 {
24684 PyThreadState* __tstate = wxPyBeginAllowThreads();
24685 {
24686 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24687 result = (wxDateTime *) &_result_ref;
24688 }
24689 wxPyEndAllowThreads(__tstate);
24690 if (PyErr_Occurred()) SWIG_fail;
24691 }
24692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24693 return resultobj;
24694 fail:
24695 return NULL;
24696 }
24697
24698
24699 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24700 PyObject *resultobj = 0;
24701 wxDateTime *arg1 = (wxDateTime *) 0 ;
24702 int arg2 ;
24703 wxDateTime *result = 0 ;
24704 void *argp1 = 0 ;
24705 int res1 = 0 ;
24706 int val2 ;
24707 int ecode2 = 0 ;
24708 PyObject * obj0 = 0 ;
24709 PyObject * obj1 = 0 ;
24710 char * kwnames[] = {
24711 (char *) "self",(char *) "second", NULL
24712 };
24713
24714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24716 if (!SWIG_IsOK(res1)) {
24717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24718 }
24719 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24720 ecode2 = SWIG_AsVal_int(obj1, &val2);
24721 if (!SWIG_IsOK(ecode2)) {
24722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24723 }
24724 arg2 = static_cast< int >(val2);
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 {
24728 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24729 result = (wxDateTime *) &_result_ref;
24730 }
24731 wxPyEndAllowThreads(__tstate);
24732 if (PyErr_Occurred()) SWIG_fail;
24733 }
24734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24735 return resultobj;
24736 fail:
24737 return NULL;
24738 }
24739
24740
24741 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24742 PyObject *resultobj = 0;
24743 wxDateTime *arg1 = (wxDateTime *) 0 ;
24744 int arg2 ;
24745 wxDateTime *result = 0 ;
24746 void *argp1 = 0 ;
24747 int res1 = 0 ;
24748 int val2 ;
24749 int ecode2 = 0 ;
24750 PyObject * obj0 = 0 ;
24751 PyObject * obj1 = 0 ;
24752 char * kwnames[] = {
24753 (char *) "self",(char *) "millisecond", NULL
24754 };
24755
24756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24758 if (!SWIG_IsOK(res1)) {
24759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24760 }
24761 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24762 ecode2 = SWIG_AsVal_int(obj1, &val2);
24763 if (!SWIG_IsOK(ecode2)) {
24764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24765 }
24766 arg2 = static_cast< int >(val2);
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 {
24770 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
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_SetToWeekDayInSameWeek(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 = 0 ;
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_SetToWeekDayInSameWeek",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_SetToWeekDayInSameWeek" "', 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_SetToWeekDayInSameWeek" "', 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_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24817 }
24818 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24819 }
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 {
24823 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24824 result = (wxDateTime *) &_result_ref;
24825 }
24826 wxPyEndAllowThreads(__tstate);
24827 if (PyErr_Occurred()) SWIG_fail;
24828 }
24829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24837 PyObject *resultobj = 0;
24838 wxDateTime *arg1 = (wxDateTime *) 0 ;
24839 wxDateTime::WeekDay arg2 ;
24840 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24841 wxDateTime result;
24842 void *argp1 = 0 ;
24843 int res1 = 0 ;
24844 int val2 ;
24845 int ecode2 = 0 ;
24846 int val3 ;
24847 int ecode3 = 0 ;
24848 PyObject * obj0 = 0 ;
24849 PyObject * obj1 = 0 ;
24850 PyObject * obj2 = 0 ;
24851 char * kwnames[] = {
24852 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24853 };
24854
24855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24859 }
24860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24861 ecode2 = SWIG_AsVal_int(obj1, &val2);
24862 if (!SWIG_IsOK(ecode2)) {
24863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24864 }
24865 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24866 if (obj2) {
24867 ecode3 = SWIG_AsVal_int(obj2, &val3);
24868 if (!SWIG_IsOK(ecode3)) {
24869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24870 }
24871 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24872 }
24873 {
24874 PyThreadState* __tstate = wxPyBeginAllowThreads();
24875 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24876 wxPyEndAllowThreads(__tstate);
24877 if (PyErr_Occurred()) SWIG_fail;
24878 }
24879 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24880 return resultobj;
24881 fail:
24882 return NULL;
24883 }
24884
24885
24886 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24887 PyObject *resultobj = 0;
24888 wxDateTime *arg1 = (wxDateTime *) 0 ;
24889 wxDateTime::WeekDay arg2 ;
24890 wxDateTime *result = 0 ;
24891 void *argp1 = 0 ;
24892 int res1 = 0 ;
24893 int val2 ;
24894 int ecode2 = 0 ;
24895 PyObject * obj0 = 0 ;
24896 PyObject * obj1 = 0 ;
24897 char * kwnames[] = {
24898 (char *) "self",(char *) "weekday", NULL
24899 };
24900
24901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24903 if (!SWIG_IsOK(res1)) {
24904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24905 }
24906 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24907 ecode2 = SWIG_AsVal_int(obj1, &val2);
24908 if (!SWIG_IsOK(ecode2)) {
24909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24910 }
24911 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 {
24915 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24916 result = (wxDateTime *) &_result_ref;
24917 }
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = 0;
24930 wxDateTime *arg1 = (wxDateTime *) 0 ;
24931 wxDateTime::WeekDay arg2 ;
24932 wxDateTime result;
24933 void *argp1 = 0 ;
24934 int res1 = 0 ;
24935 int val2 ;
24936 int ecode2 = 0 ;
24937 PyObject * obj0 = 0 ;
24938 PyObject * obj1 = 0 ;
24939 char * kwnames[] = {
24940 (char *) "self",(char *) "weekday", NULL
24941 };
24942
24943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24947 }
24948 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24949 ecode2 = SWIG_AsVal_int(obj1, &val2);
24950 if (!SWIG_IsOK(ecode2)) {
24951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24952 }
24953 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 result = (arg1)->GetNextWeekDay(arg2);
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24961 return resultobj;
24962 fail:
24963 return NULL;
24964 }
24965
24966
24967 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24968 PyObject *resultobj = 0;
24969 wxDateTime *arg1 = (wxDateTime *) 0 ;
24970 wxDateTime::WeekDay arg2 ;
24971 wxDateTime *result = 0 ;
24972 void *argp1 = 0 ;
24973 int res1 = 0 ;
24974 int val2 ;
24975 int ecode2 = 0 ;
24976 PyObject * obj0 = 0 ;
24977 PyObject * obj1 = 0 ;
24978 char * kwnames[] = {
24979 (char *) "self",(char *) "weekday", NULL
24980 };
24981
24982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24984 if (!SWIG_IsOK(res1)) {
24985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24986 }
24987 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24988 ecode2 = SWIG_AsVal_int(obj1, &val2);
24989 if (!SWIG_IsOK(ecode2)) {
24990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24991 }
24992 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 {
24996 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24997 result = (wxDateTime *) &_result_ref;
24998 }
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25003 return resultobj;
25004 fail:
25005 return NULL;
25006 }
25007
25008
25009 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25010 PyObject *resultobj = 0;
25011 wxDateTime *arg1 = (wxDateTime *) 0 ;
25012 wxDateTime::WeekDay arg2 ;
25013 wxDateTime result;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 int val2 ;
25017 int ecode2 = 0 ;
25018 PyObject * obj0 = 0 ;
25019 PyObject * obj1 = 0 ;
25020 char * kwnames[] = {
25021 (char *) "self",(char *) "weekday", NULL
25022 };
25023
25024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25026 if (!SWIG_IsOK(res1)) {
25027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25028 }
25029 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25030 ecode2 = SWIG_AsVal_int(obj1, &val2);
25031 if (!SWIG_IsOK(ecode2)) {
25032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25033 }
25034 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 result = (arg1)->GetPrevWeekDay(arg2);
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25049 PyObject *resultobj = 0;
25050 wxDateTime *arg1 = (wxDateTime *) 0 ;
25051 wxDateTime::WeekDay arg2 ;
25052 int arg3 = (int) 1 ;
25053 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25054 int arg5 = (int) wxDateTime::Inv_Year ;
25055 bool result;
25056 void *argp1 = 0 ;
25057 int res1 = 0 ;
25058 int val2 ;
25059 int ecode2 = 0 ;
25060 int val3 ;
25061 int ecode3 = 0 ;
25062 int val4 ;
25063 int ecode4 = 0 ;
25064 int val5 ;
25065 int ecode5 = 0 ;
25066 PyObject * obj0 = 0 ;
25067 PyObject * obj1 = 0 ;
25068 PyObject * obj2 = 0 ;
25069 PyObject * obj3 = 0 ;
25070 PyObject * obj4 = 0 ;
25071 char * kwnames[] = {
25072 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25073 };
25074
25075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25077 if (!SWIG_IsOK(res1)) {
25078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25079 }
25080 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25081 ecode2 = SWIG_AsVal_int(obj1, &val2);
25082 if (!SWIG_IsOK(ecode2)) {
25083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25084 }
25085 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25086 if (obj2) {
25087 ecode3 = SWIG_AsVal_int(obj2, &val3);
25088 if (!SWIG_IsOK(ecode3)) {
25089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25090 }
25091 arg3 = static_cast< int >(val3);
25092 }
25093 if (obj3) {
25094 ecode4 = SWIG_AsVal_int(obj3, &val4);
25095 if (!SWIG_IsOK(ecode4)) {
25096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25097 }
25098 arg4 = static_cast< wxDateTime::Month >(val4);
25099 }
25100 if (obj4) {
25101 ecode5 = SWIG_AsVal_int(obj4, &val5);
25102 if (!SWIG_IsOK(ecode5)) {
25103 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25104 }
25105 arg5 = static_cast< int >(val5);
25106 }
25107 {
25108 PyThreadState* __tstate = wxPyBeginAllowThreads();
25109 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25110 wxPyEndAllowThreads(__tstate);
25111 if (PyErr_Occurred()) SWIG_fail;
25112 }
25113 {
25114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25115 }
25116 return resultobj;
25117 fail:
25118 return NULL;
25119 }
25120
25121
25122 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25123 PyObject *resultobj = 0;
25124 wxDateTime *arg1 = (wxDateTime *) 0 ;
25125 wxDateTime::WeekDay arg2 ;
25126 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25127 int arg4 = (int) wxDateTime::Inv_Year ;
25128 bool result;
25129 void *argp1 = 0 ;
25130 int res1 = 0 ;
25131 int val2 ;
25132 int ecode2 = 0 ;
25133 int val3 ;
25134 int ecode3 = 0 ;
25135 int val4 ;
25136 int ecode4 = 0 ;
25137 PyObject * obj0 = 0 ;
25138 PyObject * obj1 = 0 ;
25139 PyObject * obj2 = 0 ;
25140 PyObject * obj3 = 0 ;
25141 char * kwnames[] = {
25142 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25143 };
25144
25145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25147 if (!SWIG_IsOK(res1)) {
25148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25149 }
25150 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25151 ecode2 = SWIG_AsVal_int(obj1, &val2);
25152 if (!SWIG_IsOK(ecode2)) {
25153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25154 }
25155 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25156 if (obj2) {
25157 ecode3 = SWIG_AsVal_int(obj2, &val3);
25158 if (!SWIG_IsOK(ecode3)) {
25159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25160 }
25161 arg3 = static_cast< wxDateTime::Month >(val3);
25162 }
25163 if (obj3) {
25164 ecode4 = SWIG_AsVal_int(obj3, &val4);
25165 if (!SWIG_IsOK(ecode4)) {
25166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25167 }
25168 arg4 = static_cast< int >(val4);
25169 }
25170 {
25171 PyThreadState* __tstate = wxPyBeginAllowThreads();
25172 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25173 wxPyEndAllowThreads(__tstate);
25174 if (PyErr_Occurred()) SWIG_fail;
25175 }
25176 {
25177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25178 }
25179 return resultobj;
25180 fail:
25181 return NULL;
25182 }
25183
25184
25185 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25186 PyObject *resultobj = 0;
25187 wxDateTime *arg1 = (wxDateTime *) 0 ;
25188 wxDateTime::WeekDay arg2 ;
25189 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25190 int arg4 = (int) wxDateTime::Inv_Year ;
25191 wxDateTime result;
25192 void *argp1 = 0 ;
25193 int res1 = 0 ;
25194 int val2 ;
25195 int ecode2 = 0 ;
25196 int val3 ;
25197 int ecode3 = 0 ;
25198 int val4 ;
25199 int ecode4 = 0 ;
25200 PyObject * obj0 = 0 ;
25201 PyObject * obj1 = 0 ;
25202 PyObject * obj2 = 0 ;
25203 PyObject * obj3 = 0 ;
25204 char * kwnames[] = {
25205 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25206 };
25207
25208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25210 if (!SWIG_IsOK(res1)) {
25211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25212 }
25213 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25214 ecode2 = SWIG_AsVal_int(obj1, &val2);
25215 if (!SWIG_IsOK(ecode2)) {
25216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25217 }
25218 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25219 if (obj2) {
25220 ecode3 = SWIG_AsVal_int(obj2, &val3);
25221 if (!SWIG_IsOK(ecode3)) {
25222 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25223 }
25224 arg3 = static_cast< wxDateTime::Month >(val3);
25225 }
25226 if (obj3) {
25227 ecode4 = SWIG_AsVal_int(obj3, &val4);
25228 if (!SWIG_IsOK(ecode4)) {
25229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25230 }
25231 arg4 = static_cast< int >(val4);
25232 }
25233 {
25234 PyThreadState* __tstate = wxPyBeginAllowThreads();
25235 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25236 wxPyEndAllowThreads(__tstate);
25237 if (PyErr_Occurred()) SWIG_fail;
25238 }
25239 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25240 return resultobj;
25241 fail:
25242 return NULL;
25243 }
25244
25245
25246 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25247 PyObject *resultobj = 0;
25248 wxDateTime *arg1 = (wxDateTime *) 0 ;
25249 int arg2 ;
25250 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25251 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25252 bool result;
25253 void *argp1 = 0 ;
25254 int res1 = 0 ;
25255 int val2 ;
25256 int ecode2 = 0 ;
25257 int val3 ;
25258 int ecode3 = 0 ;
25259 int val4 ;
25260 int ecode4 = 0 ;
25261 PyObject * obj0 = 0 ;
25262 PyObject * obj1 = 0 ;
25263 PyObject * obj2 = 0 ;
25264 PyObject * obj3 = 0 ;
25265 char * kwnames[] = {
25266 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25267 };
25268
25269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25271 if (!SWIG_IsOK(res1)) {
25272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25273 }
25274 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25275 ecode2 = SWIG_AsVal_int(obj1, &val2);
25276 if (!SWIG_IsOK(ecode2)) {
25277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25278 }
25279 arg2 = static_cast< int >(val2);
25280 if (obj2) {
25281 ecode3 = SWIG_AsVal_int(obj2, &val3);
25282 if (!SWIG_IsOK(ecode3)) {
25283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25284 }
25285 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25286 }
25287 if (obj3) {
25288 ecode4 = SWIG_AsVal_int(obj3, &val4);
25289 if (!SWIG_IsOK(ecode4)) {
25290 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25291 }
25292 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25293 }
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 {
25301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25302 }
25303 return resultobj;
25304 fail:
25305 return NULL;
25306 }
25307
25308
25309 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25310 PyObject *resultobj = 0;
25311 wxDateTime *arg1 = (wxDateTime *) 0 ;
25312 int arg2 ;
25313 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25314 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25315 wxDateTime result;
25316 void *argp1 = 0 ;
25317 int res1 = 0 ;
25318 int val2 ;
25319 int ecode2 = 0 ;
25320 int val3 ;
25321 int ecode3 = 0 ;
25322 int val4 ;
25323 int ecode4 = 0 ;
25324 PyObject * obj0 = 0 ;
25325 PyObject * obj1 = 0 ;
25326 PyObject * obj2 = 0 ;
25327 PyObject * obj3 = 0 ;
25328 char * kwnames[] = {
25329 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25330 };
25331
25332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25334 if (!SWIG_IsOK(res1)) {
25335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25336 }
25337 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25338 ecode2 = SWIG_AsVal_int(obj1, &val2);
25339 if (!SWIG_IsOK(ecode2)) {
25340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25341 }
25342 arg2 = static_cast< int >(val2);
25343 if (obj2) {
25344 ecode3 = SWIG_AsVal_int(obj2, &val3);
25345 if (!SWIG_IsOK(ecode3)) {
25346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25347 }
25348 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25349 }
25350 if (obj3) {
25351 ecode4 = SWIG_AsVal_int(obj3, &val4);
25352 if (!SWIG_IsOK(ecode4)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25354 }
25355 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25356 }
25357 {
25358 PyThreadState* __tstate = wxPyBeginAllowThreads();
25359 result = (arg1)->GetWeek(arg2,arg3,arg4);
25360 wxPyEndAllowThreads(__tstate);
25361 if (PyErr_Occurred()) SWIG_fail;
25362 }
25363 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25364 return resultobj;
25365 fail:
25366 return NULL;
25367 }
25368
25369
25370 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25371 PyObject *resultobj = 0;
25372 int arg1 ;
25373 int arg2 ;
25374 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25375 wxDateTime result;
25376 int val1 ;
25377 int ecode1 = 0 ;
25378 int val2 ;
25379 int ecode2 = 0 ;
25380 int val3 ;
25381 int ecode3 = 0 ;
25382 PyObject * obj0 = 0 ;
25383 PyObject * obj1 = 0 ;
25384 PyObject * obj2 = 0 ;
25385 char * kwnames[] = {
25386 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25387 };
25388
25389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25390 ecode1 = SWIG_AsVal_int(obj0, &val1);
25391 if (!SWIG_IsOK(ecode1)) {
25392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25393 }
25394 arg1 = static_cast< int >(val1);
25395 ecode2 = SWIG_AsVal_int(obj1, &val2);
25396 if (!SWIG_IsOK(ecode2)) {
25397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25398 }
25399 arg2 = static_cast< int >(val2);
25400 if (obj2) {
25401 ecode3 = SWIG_AsVal_int(obj2, &val3);
25402 if (!SWIG_IsOK(ecode3)) {
25403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25404 }
25405 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25406 }
25407 {
25408 PyThreadState* __tstate = wxPyBeginAllowThreads();
25409 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25414 return resultobj;
25415 fail:
25416 return NULL;
25417 }
25418
25419
25420 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25421 PyObject *resultobj = 0;
25422 wxDateTime *arg1 = (wxDateTime *) 0 ;
25423 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25424 int arg3 = (int) wxDateTime::Inv_Year ;
25425 wxDateTime *result = 0 ;
25426 void *argp1 = 0 ;
25427 int res1 = 0 ;
25428 int val2 ;
25429 int ecode2 = 0 ;
25430 int val3 ;
25431 int ecode3 = 0 ;
25432 PyObject * obj0 = 0 ;
25433 PyObject * obj1 = 0 ;
25434 PyObject * obj2 = 0 ;
25435 char * kwnames[] = {
25436 (char *) "self",(char *) "month",(char *) "year", NULL
25437 };
25438
25439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25441 if (!SWIG_IsOK(res1)) {
25442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25443 }
25444 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25445 if (obj1) {
25446 ecode2 = SWIG_AsVal_int(obj1, &val2);
25447 if (!SWIG_IsOK(ecode2)) {
25448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25449 }
25450 arg2 = static_cast< wxDateTime::Month >(val2);
25451 }
25452 if (obj2) {
25453 ecode3 = SWIG_AsVal_int(obj2, &val3);
25454 if (!SWIG_IsOK(ecode3)) {
25455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25456 }
25457 arg3 = static_cast< int >(val3);
25458 }
25459 {
25460 PyThreadState* __tstate = wxPyBeginAllowThreads();
25461 {
25462 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25463 result = (wxDateTime *) &_result_ref;
25464 }
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25469 return resultobj;
25470 fail:
25471 return NULL;
25472 }
25473
25474
25475 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25476 PyObject *resultobj = 0;
25477 wxDateTime *arg1 = (wxDateTime *) 0 ;
25478 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25479 int arg3 = (int) wxDateTime::Inv_Year ;
25480 wxDateTime result;
25481 void *argp1 = 0 ;
25482 int res1 = 0 ;
25483 int val2 ;
25484 int ecode2 = 0 ;
25485 int val3 ;
25486 int ecode3 = 0 ;
25487 PyObject * obj0 = 0 ;
25488 PyObject * obj1 = 0 ;
25489 PyObject * obj2 = 0 ;
25490 char * kwnames[] = {
25491 (char *) "self",(char *) "month",(char *) "year", NULL
25492 };
25493
25494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25496 if (!SWIG_IsOK(res1)) {
25497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25498 }
25499 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25500 if (obj1) {
25501 ecode2 = SWIG_AsVal_int(obj1, &val2);
25502 if (!SWIG_IsOK(ecode2)) {
25503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25504 }
25505 arg2 = static_cast< wxDateTime::Month >(val2);
25506 }
25507 if (obj2) {
25508 ecode3 = SWIG_AsVal_int(obj2, &val3);
25509 if (!SWIG_IsOK(ecode3)) {
25510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25511 }
25512 arg3 = static_cast< int >(val3);
25513 }
25514 {
25515 PyThreadState* __tstate = wxPyBeginAllowThreads();
25516 result = (arg1)->GetLastMonthDay(arg2,arg3);
25517 wxPyEndAllowThreads(__tstate);
25518 if (PyErr_Occurred()) SWIG_fail;
25519 }
25520 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25528 PyObject *resultobj = 0;
25529 wxDateTime *arg1 = (wxDateTime *) 0 ;
25530 int arg2 ;
25531 wxDateTime *result = 0 ;
25532 void *argp1 = 0 ;
25533 int res1 = 0 ;
25534 int val2 ;
25535 int ecode2 = 0 ;
25536 PyObject * obj0 = 0 ;
25537 PyObject * obj1 = 0 ;
25538 char * kwnames[] = {
25539 (char *) "self",(char *) "yday", NULL
25540 };
25541
25542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25544 if (!SWIG_IsOK(res1)) {
25545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25546 }
25547 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25548 ecode2 = SWIG_AsVal_int(obj1, &val2);
25549 if (!SWIG_IsOK(ecode2)) {
25550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25551 }
25552 arg2 = static_cast< int >(val2);
25553 {
25554 PyThreadState* __tstate = wxPyBeginAllowThreads();
25555 {
25556 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25557 result = (wxDateTime *) &_result_ref;
25558 }
25559 wxPyEndAllowThreads(__tstate);
25560 if (PyErr_Occurred()) SWIG_fail;
25561 }
25562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25563 return resultobj;
25564 fail:
25565 return NULL;
25566 }
25567
25568
25569 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25570 PyObject *resultobj = 0;
25571 wxDateTime *arg1 = (wxDateTime *) 0 ;
25572 int arg2 ;
25573 wxDateTime result;
25574 void *argp1 = 0 ;
25575 int res1 = 0 ;
25576 int val2 ;
25577 int ecode2 = 0 ;
25578 PyObject * obj0 = 0 ;
25579 PyObject * obj1 = 0 ;
25580 char * kwnames[] = {
25581 (char *) "self",(char *) "yday", NULL
25582 };
25583
25584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25586 if (!SWIG_IsOK(res1)) {
25587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25588 }
25589 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25590 ecode2 = SWIG_AsVal_int(obj1, &val2);
25591 if (!SWIG_IsOK(ecode2)) {
25592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25593 }
25594 arg2 = static_cast< int >(val2);
25595 {
25596 PyThreadState* __tstate = wxPyBeginAllowThreads();
25597 result = (arg1)->GetYearDay(arg2);
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25609 PyObject *resultobj = 0;
25610 wxDateTime *arg1 = (wxDateTime *) 0 ;
25611 double result;
25612 void *argp1 = 0 ;
25613 int res1 = 0 ;
25614 PyObject *swig_obj[1] ;
25615
25616 if (!args) SWIG_fail;
25617 swig_obj[0] = args;
25618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25619 if (!SWIG_IsOK(res1)) {
25620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25621 }
25622 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25623 {
25624 PyThreadState* __tstate = wxPyBeginAllowThreads();
25625 result = (double)(arg1)->GetJulianDayNumber();
25626 wxPyEndAllowThreads(__tstate);
25627 if (PyErr_Occurred()) SWIG_fail;
25628 }
25629 resultobj = SWIG_From_double(static_cast< double >(result));
25630 return resultobj;
25631 fail:
25632 return NULL;
25633 }
25634
25635
25636 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25637 PyObject *resultobj = 0;
25638 wxDateTime *arg1 = (wxDateTime *) 0 ;
25639 double result;
25640 void *argp1 = 0 ;
25641 int res1 = 0 ;
25642 PyObject *swig_obj[1] ;
25643
25644 if (!args) SWIG_fail;
25645 swig_obj[0] = args;
25646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25647 if (!SWIG_IsOK(res1)) {
25648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25649 }
25650 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 result = (double)(arg1)->GetJDN();
25654 wxPyEndAllowThreads(__tstate);
25655 if (PyErr_Occurred()) SWIG_fail;
25656 }
25657 resultobj = SWIG_From_double(static_cast< double >(result));
25658 return resultobj;
25659 fail:
25660 return NULL;
25661 }
25662
25663
25664 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25665 PyObject *resultobj = 0;
25666 wxDateTime *arg1 = (wxDateTime *) 0 ;
25667 double result;
25668 void *argp1 = 0 ;
25669 int res1 = 0 ;
25670 PyObject *swig_obj[1] ;
25671
25672 if (!args) SWIG_fail;
25673 swig_obj[0] = args;
25674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25675 if (!SWIG_IsOK(res1)) {
25676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25677 }
25678 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25679 {
25680 PyThreadState* __tstate = wxPyBeginAllowThreads();
25681 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25682 wxPyEndAllowThreads(__tstate);
25683 if (PyErr_Occurred()) SWIG_fail;
25684 }
25685 resultobj = SWIG_From_double(static_cast< double >(result));
25686 return resultobj;
25687 fail:
25688 return NULL;
25689 }
25690
25691
25692 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25693 PyObject *resultobj = 0;
25694 wxDateTime *arg1 = (wxDateTime *) 0 ;
25695 double result;
25696 void *argp1 = 0 ;
25697 int res1 = 0 ;
25698 PyObject *swig_obj[1] ;
25699
25700 if (!args) SWIG_fail;
25701 swig_obj[0] = args;
25702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25703 if (!SWIG_IsOK(res1)) {
25704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25705 }
25706 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25707 {
25708 PyThreadState* __tstate = wxPyBeginAllowThreads();
25709 result = (double)(arg1)->GetMJD();
25710 wxPyEndAllowThreads(__tstate);
25711 if (PyErr_Occurred()) SWIG_fail;
25712 }
25713 resultobj = SWIG_From_double(static_cast< double >(result));
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25721 PyObject *resultobj = 0;
25722 wxDateTime *arg1 = (wxDateTime *) 0 ;
25723 double result;
25724 void *argp1 = 0 ;
25725 int res1 = 0 ;
25726 PyObject *swig_obj[1] ;
25727
25728 if (!args) SWIG_fail;
25729 swig_obj[0] = args;
25730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25731 if (!SWIG_IsOK(res1)) {
25732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25733 }
25734 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25735 {
25736 PyThreadState* __tstate = wxPyBeginAllowThreads();
25737 result = (double)(arg1)->GetRataDie();
25738 wxPyEndAllowThreads(__tstate);
25739 if (PyErr_Occurred()) SWIG_fail;
25740 }
25741 resultobj = SWIG_From_double(static_cast< double >(result));
25742 return resultobj;
25743 fail:
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25749 PyObject *resultobj = 0;
25750 wxDateTime *arg1 = (wxDateTime *) 0 ;
25751 wxDateTime::TimeZone *arg2 = 0 ;
25752 bool arg3 = (bool) false ;
25753 wxDateTime result;
25754 void *argp1 = 0 ;
25755 int res1 = 0 ;
25756 bool temp2 = false ;
25757 bool val3 ;
25758 int ecode3 = 0 ;
25759 PyObject * obj0 = 0 ;
25760 PyObject * obj1 = 0 ;
25761 PyObject * obj2 = 0 ;
25762 char * kwnames[] = {
25763 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25764 };
25765
25766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25768 if (!SWIG_IsOK(res1)) {
25769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25770 }
25771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25772 {
25773 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25774 temp2 = true;
25775 }
25776 if (obj2) {
25777 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25778 if (!SWIG_IsOK(ecode3)) {
25779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25780 }
25781 arg3 = static_cast< bool >(val3);
25782 }
25783 {
25784 PyThreadState* __tstate = wxPyBeginAllowThreads();
25785 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25786 wxPyEndAllowThreads(__tstate);
25787 if (PyErr_Occurred()) SWIG_fail;
25788 }
25789 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25790 {
25791 if (temp2) delete arg2;
25792 }
25793 return resultobj;
25794 fail:
25795 {
25796 if (temp2) delete arg2;
25797 }
25798 return NULL;
25799 }
25800
25801
25802 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25803 PyObject *resultobj = 0;
25804 wxDateTime *arg1 = (wxDateTime *) 0 ;
25805 wxDateTime::TimeZone *arg2 = 0 ;
25806 bool arg3 = (bool) false ;
25807 wxDateTime *result = 0 ;
25808 void *argp1 = 0 ;
25809 int res1 = 0 ;
25810 bool temp2 = false ;
25811 bool val3 ;
25812 int ecode3 = 0 ;
25813 PyObject * obj0 = 0 ;
25814 PyObject * obj1 = 0 ;
25815 PyObject * obj2 = 0 ;
25816 char * kwnames[] = {
25817 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25818 };
25819
25820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25822 if (!SWIG_IsOK(res1)) {
25823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25824 }
25825 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25826 {
25827 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25828 temp2 = true;
25829 }
25830 if (obj2) {
25831 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25832 if (!SWIG_IsOK(ecode3)) {
25833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25834 }
25835 arg3 = static_cast< bool >(val3);
25836 }
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 {
25840 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25841 result = (wxDateTime *) &_result_ref;
25842 }
25843 wxPyEndAllowThreads(__tstate);
25844 if (PyErr_Occurred()) SWIG_fail;
25845 }
25846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25847 {
25848 if (temp2) delete arg2;
25849 }
25850 return resultobj;
25851 fail:
25852 {
25853 if (temp2) delete arg2;
25854 }
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25860 PyObject *resultobj = 0;
25861 wxDateTime *arg1 = (wxDateTime *) 0 ;
25862 wxDateTime::TimeZone *arg2 = 0 ;
25863 bool arg3 = (bool) false ;
25864 wxDateTime result;
25865 void *argp1 = 0 ;
25866 int res1 = 0 ;
25867 bool temp2 = false ;
25868 bool val3 ;
25869 int ecode3 = 0 ;
25870 PyObject * obj0 = 0 ;
25871 PyObject * obj1 = 0 ;
25872 PyObject * obj2 = 0 ;
25873 char * kwnames[] = {
25874 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25875 };
25876
25877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25879 if (!SWIG_IsOK(res1)) {
25880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25881 }
25882 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25883 {
25884 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25885 temp2 = true;
25886 }
25887 if (obj2) {
25888 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25889 if (!SWIG_IsOK(ecode3)) {
25890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25891 }
25892 arg3 = static_cast< bool >(val3);
25893 }
25894 {
25895 PyThreadState* __tstate = wxPyBeginAllowThreads();
25896 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25897 wxPyEndAllowThreads(__tstate);
25898 if (PyErr_Occurred()) SWIG_fail;
25899 }
25900 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25901 {
25902 if (temp2) delete arg2;
25903 }
25904 return resultobj;
25905 fail:
25906 {
25907 if (temp2) delete arg2;
25908 }
25909 return NULL;
25910 }
25911
25912
25913 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25914 PyObject *resultobj = 0;
25915 wxDateTime *arg1 = (wxDateTime *) 0 ;
25916 wxDateTime::TimeZone *arg2 = 0 ;
25917 bool arg3 = (bool) false ;
25918 wxDateTime *result = 0 ;
25919 void *argp1 = 0 ;
25920 int res1 = 0 ;
25921 bool temp2 = false ;
25922 bool val3 ;
25923 int ecode3 = 0 ;
25924 PyObject * obj0 = 0 ;
25925 PyObject * obj1 = 0 ;
25926 PyObject * obj2 = 0 ;
25927 char * kwnames[] = {
25928 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25929 };
25930
25931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25933 if (!SWIG_IsOK(res1)) {
25934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25935 }
25936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25937 {
25938 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25939 temp2 = true;
25940 }
25941 if (obj2) {
25942 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25943 if (!SWIG_IsOK(ecode3)) {
25944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25945 }
25946 arg3 = static_cast< bool >(val3);
25947 }
25948 {
25949 PyThreadState* __tstate = wxPyBeginAllowThreads();
25950 {
25951 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25952 result = (wxDateTime *) &_result_ref;
25953 }
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25958 {
25959 if (temp2) delete arg2;
25960 }
25961 return resultobj;
25962 fail:
25963 {
25964 if (temp2) delete arg2;
25965 }
25966 return NULL;
25967 }
25968
25969
25970 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25971 PyObject *resultobj = 0;
25972 wxDateTime *arg1 = (wxDateTime *) 0 ;
25973 bool arg2 = (bool) false ;
25974 wxDateTime result;
25975 void *argp1 = 0 ;
25976 int res1 = 0 ;
25977 bool val2 ;
25978 int ecode2 = 0 ;
25979 PyObject * obj0 = 0 ;
25980 PyObject * obj1 = 0 ;
25981 char * kwnames[] = {
25982 (char *) "self",(char *) "noDST", NULL
25983 };
25984
25985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25987 if (!SWIG_IsOK(res1)) {
25988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25989 }
25990 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25991 if (obj1) {
25992 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25993 if (!SWIG_IsOK(ecode2)) {
25994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25995 }
25996 arg2 = static_cast< bool >(val2);
25997 }
25998 {
25999 PyThreadState* __tstate = wxPyBeginAllowThreads();
26000 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
26001 wxPyEndAllowThreads(__tstate);
26002 if (PyErr_Occurred()) SWIG_fail;
26003 }
26004 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26005 return resultobj;
26006 fail:
26007 return NULL;
26008 }
26009
26010
26011 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26012 PyObject *resultobj = 0;
26013 wxDateTime *arg1 = (wxDateTime *) 0 ;
26014 bool arg2 = (bool) false ;
26015 wxDateTime *result = 0 ;
26016 void *argp1 = 0 ;
26017 int res1 = 0 ;
26018 bool val2 ;
26019 int ecode2 = 0 ;
26020 PyObject * obj0 = 0 ;
26021 PyObject * obj1 = 0 ;
26022 char * kwnames[] = {
26023 (char *) "self",(char *) "noDST", NULL
26024 };
26025
26026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26028 if (!SWIG_IsOK(res1)) {
26029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26030 }
26031 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26032 if (obj1) {
26033 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26034 if (!SWIG_IsOK(ecode2)) {
26035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26036 }
26037 arg2 = static_cast< bool >(val2);
26038 }
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 {
26042 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26043 result = (wxDateTime *) &_result_ref;
26044 }
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26056 PyObject *resultobj = 0;
26057 wxDateTime *arg1 = (wxDateTime *) 0 ;
26058 bool arg2 = (bool) false ;
26059 wxDateTime result;
26060 void *argp1 = 0 ;
26061 int res1 = 0 ;
26062 bool val2 ;
26063 int ecode2 = 0 ;
26064 PyObject * obj0 = 0 ;
26065 PyObject * obj1 = 0 ;
26066 char * kwnames[] = {
26067 (char *) "self",(char *) "noDST", NULL
26068 };
26069
26070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26072 if (!SWIG_IsOK(res1)) {
26073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26074 }
26075 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26076 if (obj1) {
26077 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26078 if (!SWIG_IsOK(ecode2)) {
26079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26080 }
26081 arg2 = static_cast< bool >(val2);
26082 }
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26097 PyObject *resultobj = 0;
26098 wxDateTime *arg1 = (wxDateTime *) 0 ;
26099 bool arg2 = (bool) false ;
26100 wxDateTime *result = 0 ;
26101 void *argp1 = 0 ;
26102 int res1 = 0 ;
26103 bool val2 ;
26104 int ecode2 = 0 ;
26105 PyObject * obj0 = 0 ;
26106 PyObject * obj1 = 0 ;
26107 char * kwnames[] = {
26108 (char *) "self",(char *) "noDST", NULL
26109 };
26110
26111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26113 if (!SWIG_IsOK(res1)) {
26114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26115 }
26116 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26117 if (obj1) {
26118 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26119 if (!SWIG_IsOK(ecode2)) {
26120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26121 }
26122 arg2 = static_cast< bool >(val2);
26123 }
26124 {
26125 PyThreadState* __tstate = wxPyBeginAllowThreads();
26126 {
26127 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26128 result = (wxDateTime *) &_result_ref;
26129 }
26130 wxPyEndAllowThreads(__tstate);
26131 if (PyErr_Occurred()) SWIG_fail;
26132 }
26133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26134 return resultobj;
26135 fail:
26136 return NULL;
26137 }
26138
26139
26140 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26141 PyObject *resultobj = 0;
26142 wxDateTime *arg1 = (wxDateTime *) 0 ;
26143 bool arg2 = (bool) false ;
26144 wxDateTime result;
26145 void *argp1 = 0 ;
26146 int res1 = 0 ;
26147 bool val2 ;
26148 int ecode2 = 0 ;
26149 PyObject * obj0 = 0 ;
26150 PyObject * obj1 = 0 ;
26151 char * kwnames[] = {
26152 (char *) "self",(char *) "noDST", NULL
26153 };
26154
26155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26157 if (!SWIG_IsOK(res1)) {
26158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26159 }
26160 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26161 if (obj1) {
26162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26163 if (!SWIG_IsOK(ecode2)) {
26164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26165 }
26166 arg2 = static_cast< bool >(val2);
26167 }
26168 {
26169 PyThreadState* __tstate = wxPyBeginAllowThreads();
26170 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26171 wxPyEndAllowThreads(__tstate);
26172 if (PyErr_Occurred()) SWIG_fail;
26173 }
26174 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26175 return resultobj;
26176 fail:
26177 return NULL;
26178 }
26179
26180
26181 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26182 PyObject *resultobj = 0;
26183 wxDateTime *arg1 = (wxDateTime *) 0 ;
26184 bool arg2 = (bool) false ;
26185 wxDateTime *result = 0 ;
26186 void *argp1 = 0 ;
26187 int res1 = 0 ;
26188 bool val2 ;
26189 int ecode2 = 0 ;
26190 PyObject * obj0 = 0 ;
26191 PyObject * obj1 = 0 ;
26192 char * kwnames[] = {
26193 (char *) "self",(char *) "noDST", NULL
26194 };
26195
26196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26198 if (!SWIG_IsOK(res1)) {
26199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26200 }
26201 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26202 if (obj1) {
26203 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26204 if (!SWIG_IsOK(ecode2)) {
26205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26206 }
26207 arg2 = static_cast< bool >(val2);
26208 }
26209 {
26210 PyThreadState* __tstate = wxPyBeginAllowThreads();
26211 {
26212 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26213 result = (wxDateTime *) &_result_ref;
26214 }
26215 wxPyEndAllowThreads(__tstate);
26216 if (PyErr_Occurred()) SWIG_fail;
26217 }
26218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26219 return resultobj;
26220 fail:
26221 return NULL;
26222 }
26223
26224
26225 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26226 PyObject *resultobj = 0;
26227 wxDateTime *arg1 = (wxDateTime *) 0 ;
26228 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26229 int result;
26230 void *argp1 = 0 ;
26231 int res1 = 0 ;
26232 int val2 ;
26233 int ecode2 = 0 ;
26234 PyObject * obj0 = 0 ;
26235 PyObject * obj1 = 0 ;
26236 char * kwnames[] = {
26237 (char *) "self",(char *) "country", NULL
26238 };
26239
26240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26242 if (!SWIG_IsOK(res1)) {
26243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26244 }
26245 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26246 if (obj1) {
26247 ecode2 = SWIG_AsVal_int(obj1, &val2);
26248 if (!SWIG_IsOK(ecode2)) {
26249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26250 }
26251 arg2 = static_cast< wxDateTime::Country >(val2);
26252 }
26253 {
26254 PyThreadState* __tstate = wxPyBeginAllowThreads();
26255 result = (int)(arg1)->IsDST(arg2);
26256 wxPyEndAllowThreads(__tstate);
26257 if (PyErr_Occurred()) SWIG_fail;
26258 }
26259 resultobj = SWIG_From_int(static_cast< int >(result));
26260 return resultobj;
26261 fail:
26262 return NULL;
26263 }
26264
26265
26266 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26267 PyObject *resultobj = 0;
26268 wxDateTime *arg1 = (wxDateTime *) 0 ;
26269 bool result;
26270 void *argp1 = 0 ;
26271 int res1 = 0 ;
26272 PyObject *swig_obj[1] ;
26273
26274 if (!args) SWIG_fail;
26275 swig_obj[0] = args;
26276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26277 if (!SWIG_IsOK(res1)) {
26278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26279 }
26280 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26281 {
26282 PyThreadState* __tstate = wxPyBeginAllowThreads();
26283 result = (bool)((wxDateTime const *)arg1)->IsValid();
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 {
26288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26289 }
26290 return resultobj;
26291 fail:
26292 return NULL;
26293 }
26294
26295
26296 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 PyObject *resultobj = 0;
26298 wxDateTime *arg1 = (wxDateTime *) 0 ;
26299 time_t result;
26300 void *argp1 = 0 ;
26301 int res1 = 0 ;
26302 PyObject *swig_obj[1] ;
26303
26304 if (!args) SWIG_fail;
26305 swig_obj[0] = args;
26306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26307 if (!SWIG_IsOK(res1)) {
26308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26309 }
26310 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26311 {
26312 PyThreadState* __tstate = wxPyBeginAllowThreads();
26313 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26314 wxPyEndAllowThreads(__tstate);
26315 if (PyErr_Occurred()) SWIG_fail;
26316 }
26317 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26318 return resultobj;
26319 fail:
26320 return NULL;
26321 }
26322
26323
26324 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26325 PyObject *resultobj = 0;
26326 wxDateTime *arg1 = (wxDateTime *) 0 ;
26327 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26328 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26329 int result;
26330 void *argp1 = 0 ;
26331 int res1 = 0 ;
26332 bool temp2 = false ;
26333 PyObject * obj0 = 0 ;
26334 PyObject * obj1 = 0 ;
26335 char * kwnames[] = {
26336 (char *) "self",(char *) "tz", NULL
26337 };
26338
26339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26341 if (!SWIG_IsOK(res1)) {
26342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26343 }
26344 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26345 if (obj1) {
26346 {
26347 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26348 temp2 = true;
26349 }
26350 }
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26354 wxPyEndAllowThreads(__tstate);
26355 if (PyErr_Occurred()) SWIG_fail;
26356 }
26357 resultobj = SWIG_From_int(static_cast< int >(result));
26358 {
26359 if (temp2) delete arg2;
26360 }
26361 return resultobj;
26362 fail:
26363 {
26364 if (temp2) delete arg2;
26365 }
26366 return NULL;
26367 }
26368
26369
26370 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26371 PyObject *resultobj = 0;
26372 wxDateTime *arg1 = (wxDateTime *) 0 ;
26373 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26374 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26375 wxDateTime::Month result;
26376 void *argp1 = 0 ;
26377 int res1 = 0 ;
26378 bool temp2 = false ;
26379 PyObject * obj0 = 0 ;
26380 PyObject * obj1 = 0 ;
26381 char * kwnames[] = {
26382 (char *) "self",(char *) "tz", NULL
26383 };
26384
26385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26387 if (!SWIG_IsOK(res1)) {
26388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26389 }
26390 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26391 if (obj1) {
26392 {
26393 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26394 temp2 = true;
26395 }
26396 }
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 resultobj = SWIG_From_int(static_cast< int >(result));
26404 {
26405 if (temp2) delete arg2;
26406 }
26407 return resultobj;
26408 fail:
26409 {
26410 if (temp2) delete arg2;
26411 }
26412 return NULL;
26413 }
26414
26415
26416 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26417 PyObject *resultobj = 0;
26418 wxDateTime *arg1 = (wxDateTime *) 0 ;
26419 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26420 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26421 int result;
26422 void *argp1 = 0 ;
26423 int res1 = 0 ;
26424 bool temp2 = false ;
26425 PyObject * obj0 = 0 ;
26426 PyObject * obj1 = 0 ;
26427 char * kwnames[] = {
26428 (char *) "self",(char *) "tz", NULL
26429 };
26430
26431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26433 if (!SWIG_IsOK(res1)) {
26434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26435 }
26436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26437 if (obj1) {
26438 {
26439 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26440 temp2 = true;
26441 }
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26446 wxPyEndAllowThreads(__tstate);
26447 if (PyErr_Occurred()) SWIG_fail;
26448 }
26449 resultobj = SWIG_From_int(static_cast< int >(result));
26450 {
26451 if (temp2) delete arg2;
26452 }
26453 return resultobj;
26454 fail:
26455 {
26456 if (temp2) delete arg2;
26457 }
26458 return NULL;
26459 }
26460
26461
26462 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26463 PyObject *resultobj = 0;
26464 wxDateTime *arg1 = (wxDateTime *) 0 ;
26465 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26466 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26467 wxDateTime::WeekDay result;
26468 void *argp1 = 0 ;
26469 int res1 = 0 ;
26470 bool temp2 = false ;
26471 PyObject * obj0 = 0 ;
26472 PyObject * obj1 = 0 ;
26473 char * kwnames[] = {
26474 (char *) "self",(char *) "tz", NULL
26475 };
26476
26477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26479 if (!SWIG_IsOK(res1)) {
26480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26481 }
26482 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26483 if (obj1) {
26484 {
26485 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26486 temp2 = true;
26487 }
26488 }
26489 {
26490 PyThreadState* __tstate = wxPyBeginAllowThreads();
26491 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26492 wxPyEndAllowThreads(__tstate);
26493 if (PyErr_Occurred()) SWIG_fail;
26494 }
26495 resultobj = SWIG_From_int(static_cast< int >(result));
26496 {
26497 if (temp2) delete arg2;
26498 }
26499 return resultobj;
26500 fail:
26501 {
26502 if (temp2) delete arg2;
26503 }
26504 return NULL;
26505 }
26506
26507
26508 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26509 PyObject *resultobj = 0;
26510 wxDateTime *arg1 = (wxDateTime *) 0 ;
26511 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26512 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26513 int result;
26514 void *argp1 = 0 ;
26515 int res1 = 0 ;
26516 bool temp2 = false ;
26517 PyObject * obj0 = 0 ;
26518 PyObject * obj1 = 0 ;
26519 char * kwnames[] = {
26520 (char *) "self",(char *) "tz", NULL
26521 };
26522
26523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26525 if (!SWIG_IsOK(res1)) {
26526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26527 }
26528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26529 if (obj1) {
26530 {
26531 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26532 temp2 = true;
26533 }
26534 }
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 resultobj = SWIG_From_int(static_cast< int >(result));
26542 {
26543 if (temp2) delete arg2;
26544 }
26545 return resultobj;
26546 fail:
26547 {
26548 if (temp2) delete arg2;
26549 }
26550 return NULL;
26551 }
26552
26553
26554 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26555 PyObject *resultobj = 0;
26556 wxDateTime *arg1 = (wxDateTime *) 0 ;
26557 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26558 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26559 int result;
26560 void *argp1 = 0 ;
26561 int res1 = 0 ;
26562 bool temp2 = false ;
26563 PyObject * obj0 = 0 ;
26564 PyObject * obj1 = 0 ;
26565 char * kwnames[] = {
26566 (char *) "self",(char *) "tz", NULL
26567 };
26568
26569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26571 if (!SWIG_IsOK(res1)) {
26572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26573 }
26574 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26575 if (obj1) {
26576 {
26577 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26578 temp2 = true;
26579 }
26580 }
26581 {
26582 PyThreadState* __tstate = wxPyBeginAllowThreads();
26583 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26584 wxPyEndAllowThreads(__tstate);
26585 if (PyErr_Occurred()) SWIG_fail;
26586 }
26587 resultobj = SWIG_From_int(static_cast< int >(result));
26588 {
26589 if (temp2) delete arg2;
26590 }
26591 return resultobj;
26592 fail:
26593 {
26594 if (temp2) delete arg2;
26595 }
26596 return NULL;
26597 }
26598
26599
26600 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26601 PyObject *resultobj = 0;
26602 wxDateTime *arg1 = (wxDateTime *) 0 ;
26603 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26604 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26605 int result;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 bool temp2 = false ;
26609 PyObject * obj0 = 0 ;
26610 PyObject * obj1 = 0 ;
26611 char * kwnames[] = {
26612 (char *) "self",(char *) "tz", NULL
26613 };
26614
26615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26617 if (!SWIG_IsOK(res1)) {
26618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26619 }
26620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26621 if (obj1) {
26622 {
26623 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26624 temp2 = true;
26625 }
26626 }
26627 {
26628 PyThreadState* __tstate = wxPyBeginAllowThreads();
26629 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26630 wxPyEndAllowThreads(__tstate);
26631 if (PyErr_Occurred()) SWIG_fail;
26632 }
26633 resultobj = SWIG_From_int(static_cast< int >(result));
26634 {
26635 if (temp2) delete arg2;
26636 }
26637 return resultobj;
26638 fail:
26639 {
26640 if (temp2) delete arg2;
26641 }
26642 return NULL;
26643 }
26644
26645
26646 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26647 PyObject *resultobj = 0;
26648 wxDateTime *arg1 = (wxDateTime *) 0 ;
26649 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26650 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26651 int result;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 bool temp2 = false ;
26655 PyObject * obj0 = 0 ;
26656 PyObject * obj1 = 0 ;
26657 char * kwnames[] = {
26658 (char *) "self",(char *) "tz", NULL
26659 };
26660
26661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26663 if (!SWIG_IsOK(res1)) {
26664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26665 }
26666 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26667 if (obj1) {
26668 {
26669 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26670 temp2 = true;
26671 }
26672 }
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 resultobj = SWIG_From_int(static_cast< int >(result));
26680 {
26681 if (temp2) delete arg2;
26682 }
26683 return resultobj;
26684 fail:
26685 {
26686 if (temp2) delete arg2;
26687 }
26688 return NULL;
26689 }
26690
26691
26692 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26693 PyObject *resultobj = 0;
26694 wxDateTime *arg1 = (wxDateTime *) 0 ;
26695 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26696 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26697 int result;
26698 void *argp1 = 0 ;
26699 int res1 = 0 ;
26700 bool temp2 = false ;
26701 PyObject * obj0 = 0 ;
26702 PyObject * obj1 = 0 ;
26703 char * kwnames[] = {
26704 (char *) "self",(char *) "tz", NULL
26705 };
26706
26707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26709 if (!SWIG_IsOK(res1)) {
26710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26711 }
26712 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26713 if (obj1) {
26714 {
26715 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26716 temp2 = true;
26717 }
26718 }
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26722 wxPyEndAllowThreads(__tstate);
26723 if (PyErr_Occurred()) SWIG_fail;
26724 }
26725 resultobj = SWIG_From_int(static_cast< int >(result));
26726 {
26727 if (temp2) delete arg2;
26728 }
26729 return resultobj;
26730 fail:
26731 {
26732 if (temp2) delete arg2;
26733 }
26734 return NULL;
26735 }
26736
26737
26738 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26739 PyObject *resultobj = 0;
26740 wxDateTime *arg1 = (wxDateTime *) 0 ;
26741 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26742 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26743 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26744 int result;
26745 void *argp1 = 0 ;
26746 int res1 = 0 ;
26747 int val2 ;
26748 int ecode2 = 0 ;
26749 bool temp3 = false ;
26750 PyObject * obj0 = 0 ;
26751 PyObject * obj1 = 0 ;
26752 PyObject * obj2 = 0 ;
26753 char * kwnames[] = {
26754 (char *) "self",(char *) "flags",(char *) "tz", NULL
26755 };
26756
26757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26759 if (!SWIG_IsOK(res1)) {
26760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26761 }
26762 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26763 if (obj1) {
26764 ecode2 = SWIG_AsVal_int(obj1, &val2);
26765 if (!SWIG_IsOK(ecode2)) {
26766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26767 }
26768 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26769 }
26770 if (obj2) {
26771 {
26772 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26773 temp3 = true;
26774 }
26775 }
26776 {
26777 PyThreadState* __tstate = wxPyBeginAllowThreads();
26778 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26779 wxPyEndAllowThreads(__tstate);
26780 if (PyErr_Occurred()) SWIG_fail;
26781 }
26782 resultobj = SWIG_From_int(static_cast< int >(result));
26783 {
26784 if (temp3) delete arg3;
26785 }
26786 return resultobj;
26787 fail:
26788 {
26789 if (temp3) delete arg3;
26790 }
26791 return NULL;
26792 }
26793
26794
26795 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26796 PyObject *resultobj = 0;
26797 wxDateTime *arg1 = (wxDateTime *) 0 ;
26798 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26799 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26800 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26801 int result;
26802 void *argp1 = 0 ;
26803 int res1 = 0 ;
26804 int val2 ;
26805 int ecode2 = 0 ;
26806 bool temp3 = false ;
26807 PyObject * obj0 = 0 ;
26808 PyObject * obj1 = 0 ;
26809 PyObject * obj2 = 0 ;
26810 char * kwnames[] = {
26811 (char *) "self",(char *) "flags",(char *) "tz", NULL
26812 };
26813
26814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) 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_GetWeekOfMonth" "', 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_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26824 }
26825 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26826 }
26827 if (obj2) {
26828 {
26829 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26830 temp3 = true;
26831 }
26832 }
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 resultobj = SWIG_From_int(static_cast< int >(result));
26840 {
26841 if (temp3) delete arg3;
26842 }
26843 return resultobj;
26844 fail:
26845 {
26846 if (temp3) delete arg3;
26847 }
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj = 0;
26854 wxDateTime *arg1 = (wxDateTime *) 0 ;
26855 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26856 bool result;
26857 void *argp1 = 0 ;
26858 int res1 = 0 ;
26859 int val2 ;
26860 int ecode2 = 0 ;
26861 PyObject * obj0 = 0 ;
26862 PyObject * obj1 = 0 ;
26863 char * kwnames[] = {
26864 (char *) "self",(char *) "country", NULL
26865 };
26866
26867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26869 if (!SWIG_IsOK(res1)) {
26870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26871 }
26872 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26873 if (obj1) {
26874 ecode2 = SWIG_AsVal_int(obj1, &val2);
26875 if (!SWIG_IsOK(ecode2)) {
26876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26877 }
26878 arg2 = static_cast< wxDateTime::Country >(val2);
26879 }
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26883 wxPyEndAllowThreads(__tstate);
26884 if (PyErr_Occurred()) SWIG_fail;
26885 }
26886 {
26887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26888 }
26889 return resultobj;
26890 fail:
26891 return NULL;
26892 }
26893
26894
26895 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26896 PyObject *resultobj = 0;
26897 wxDateTime *arg1 = (wxDateTime *) 0 ;
26898 wxDateTime *arg2 = 0 ;
26899 bool result;
26900 void *argp1 = 0 ;
26901 int res1 = 0 ;
26902 void *argp2 = 0 ;
26903 int res2 = 0 ;
26904 PyObject * obj0 = 0 ;
26905 PyObject * obj1 = 0 ;
26906 char * kwnames[] = {
26907 (char *) "self",(char *) "datetime", NULL
26908 };
26909
26910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26912 if (!SWIG_IsOK(res1)) {
26913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26914 }
26915 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26916 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26917 if (!SWIG_IsOK(res2)) {
26918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26919 }
26920 if (!argp2) {
26921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26922 }
26923 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26924 {
26925 PyThreadState* __tstate = wxPyBeginAllowThreads();
26926 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26927 wxPyEndAllowThreads(__tstate);
26928 if (PyErr_Occurred()) SWIG_fail;
26929 }
26930 {
26931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26932 }
26933 return resultobj;
26934 fail:
26935 return NULL;
26936 }
26937
26938
26939 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26940 PyObject *resultobj = 0;
26941 wxDateTime *arg1 = (wxDateTime *) 0 ;
26942 wxDateTime *arg2 = 0 ;
26943 bool result;
26944 void *argp1 = 0 ;
26945 int res1 = 0 ;
26946 void *argp2 = 0 ;
26947 int res2 = 0 ;
26948 PyObject * obj0 = 0 ;
26949 PyObject * obj1 = 0 ;
26950 char * kwnames[] = {
26951 (char *) "self",(char *) "datetime", NULL
26952 };
26953
26954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26956 if (!SWIG_IsOK(res1)) {
26957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26958 }
26959 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26961 if (!SWIG_IsOK(res2)) {
26962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26963 }
26964 if (!argp2) {
26965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26966 }
26967 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26968 {
26969 PyThreadState* __tstate = wxPyBeginAllowThreads();
26970 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26971 wxPyEndAllowThreads(__tstate);
26972 if (PyErr_Occurred()) SWIG_fail;
26973 }
26974 {
26975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26976 }
26977 return resultobj;
26978 fail:
26979 return NULL;
26980 }
26981
26982
26983 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26984 PyObject *resultobj = 0;
26985 wxDateTime *arg1 = (wxDateTime *) 0 ;
26986 wxDateTime *arg2 = 0 ;
26987 bool result;
26988 void *argp1 = 0 ;
26989 int res1 = 0 ;
26990 void *argp2 = 0 ;
26991 int res2 = 0 ;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 char * kwnames[] = {
26995 (char *) "self",(char *) "datetime", NULL
26996 };
26997
26998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27000 if (!SWIG_IsOK(res1)) {
27001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27002 }
27003 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27004 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27005 if (!SWIG_IsOK(res2)) {
27006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27007 }
27008 if (!argp2) {
27009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27010 }
27011 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27012 {
27013 PyThreadState* __tstate = wxPyBeginAllowThreads();
27014 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
27015 wxPyEndAllowThreads(__tstate);
27016 if (PyErr_Occurred()) SWIG_fail;
27017 }
27018 {
27019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27020 }
27021 return resultobj;
27022 fail:
27023 return NULL;
27024 }
27025
27026
27027 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27028 PyObject *resultobj = 0;
27029 wxDateTime *arg1 = (wxDateTime *) 0 ;
27030 wxDateTime *arg2 = 0 ;
27031 wxDateTime *arg3 = 0 ;
27032 bool result;
27033 void *argp1 = 0 ;
27034 int res1 = 0 ;
27035 void *argp2 = 0 ;
27036 int res2 = 0 ;
27037 void *argp3 = 0 ;
27038 int res3 = 0 ;
27039 PyObject * obj0 = 0 ;
27040 PyObject * obj1 = 0 ;
27041 PyObject * obj2 = 0 ;
27042 char * kwnames[] = {
27043 (char *) "self",(char *) "t1",(char *) "t2", NULL
27044 };
27045
27046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27048 if (!SWIG_IsOK(res1)) {
27049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27050 }
27051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27053 if (!SWIG_IsOK(res2)) {
27054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27055 }
27056 if (!argp2) {
27057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27058 }
27059 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27060 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27061 if (!SWIG_IsOK(res3)) {
27062 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27063 }
27064 if (!argp3) {
27065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27066 }
27067 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27068 {
27069 PyThreadState* __tstate = wxPyBeginAllowThreads();
27070 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27071 wxPyEndAllowThreads(__tstate);
27072 if (PyErr_Occurred()) SWIG_fail;
27073 }
27074 {
27075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27076 }
27077 return resultobj;
27078 fail:
27079 return NULL;
27080 }
27081
27082
27083 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27084 PyObject *resultobj = 0;
27085 wxDateTime *arg1 = (wxDateTime *) 0 ;
27086 wxDateTime *arg2 = 0 ;
27087 wxDateTime *arg3 = 0 ;
27088 bool result;
27089 void *argp1 = 0 ;
27090 int res1 = 0 ;
27091 void *argp2 = 0 ;
27092 int res2 = 0 ;
27093 void *argp3 = 0 ;
27094 int res3 = 0 ;
27095 PyObject * obj0 = 0 ;
27096 PyObject * obj1 = 0 ;
27097 PyObject * obj2 = 0 ;
27098 char * kwnames[] = {
27099 (char *) "self",(char *) "t1",(char *) "t2", NULL
27100 };
27101
27102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27104 if (!SWIG_IsOK(res1)) {
27105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27106 }
27107 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27109 if (!SWIG_IsOK(res2)) {
27110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27111 }
27112 if (!argp2) {
27113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27114 }
27115 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27116 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27117 if (!SWIG_IsOK(res3)) {
27118 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27119 }
27120 if (!argp3) {
27121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27122 }
27123 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27127 wxPyEndAllowThreads(__tstate);
27128 if (PyErr_Occurred()) SWIG_fail;
27129 }
27130 {
27131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27132 }
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27140 PyObject *resultobj = 0;
27141 wxDateTime *arg1 = (wxDateTime *) 0 ;
27142 wxDateTime *arg2 = 0 ;
27143 bool result;
27144 void *argp1 = 0 ;
27145 int res1 = 0 ;
27146 void *argp2 = 0 ;
27147 int res2 = 0 ;
27148 PyObject * obj0 = 0 ;
27149 PyObject * obj1 = 0 ;
27150 char * kwnames[] = {
27151 (char *) "self",(char *) "dt", NULL
27152 };
27153
27154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27156 if (!SWIG_IsOK(res1)) {
27157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27158 }
27159 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27160 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27161 if (!SWIG_IsOK(res2)) {
27162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27163 }
27164 if (!argp2) {
27165 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27166 }
27167 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27171 wxPyEndAllowThreads(__tstate);
27172 if (PyErr_Occurred()) SWIG_fail;
27173 }
27174 {
27175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27176 }
27177 return resultobj;
27178 fail:
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27184 PyObject *resultobj = 0;
27185 wxDateTime *arg1 = (wxDateTime *) 0 ;
27186 wxDateTime *arg2 = 0 ;
27187 bool result;
27188 void *argp1 = 0 ;
27189 int res1 = 0 ;
27190 void *argp2 = 0 ;
27191 int res2 = 0 ;
27192 PyObject * obj0 = 0 ;
27193 PyObject * obj1 = 0 ;
27194 char * kwnames[] = {
27195 (char *) "self",(char *) "dt", NULL
27196 };
27197
27198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27200 if (!SWIG_IsOK(res1)) {
27201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27202 }
27203 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27205 if (!SWIG_IsOK(res2)) {
27206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27207 }
27208 if (!argp2) {
27209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27210 }
27211 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 {
27219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27220 }
27221 return resultobj;
27222 fail:
27223 return NULL;
27224 }
27225
27226
27227 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27228 PyObject *resultobj = 0;
27229 wxDateTime *arg1 = (wxDateTime *) 0 ;
27230 wxDateTime *arg2 = 0 ;
27231 wxTimeSpan *arg3 = 0 ;
27232 bool result;
27233 void *argp1 = 0 ;
27234 int res1 = 0 ;
27235 void *argp2 = 0 ;
27236 int res2 = 0 ;
27237 void *argp3 = 0 ;
27238 int res3 = 0 ;
27239 PyObject * obj0 = 0 ;
27240 PyObject * obj1 = 0 ;
27241 PyObject * obj2 = 0 ;
27242 char * kwnames[] = {
27243 (char *) "self",(char *) "dt",(char *) "ts", NULL
27244 };
27245
27246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27248 if (!SWIG_IsOK(res1)) {
27249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27250 }
27251 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27252 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27253 if (!SWIG_IsOK(res2)) {
27254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27255 }
27256 if (!argp2) {
27257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27258 }
27259 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27260 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27261 if (!SWIG_IsOK(res3)) {
27262 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27263 }
27264 if (!argp3) {
27265 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27266 }
27267 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27268 {
27269 PyThreadState* __tstate = wxPyBeginAllowThreads();
27270 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27271 wxPyEndAllowThreads(__tstate);
27272 if (PyErr_Occurred()) SWIG_fail;
27273 }
27274 {
27275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27276 }
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj = 0;
27285 wxDateTime *arg1 = (wxDateTime *) 0 ;
27286 wxTimeSpan *arg2 = 0 ;
27287 wxDateTime *result = 0 ;
27288 void *argp1 = 0 ;
27289 int res1 = 0 ;
27290 void *argp2 = 0 ;
27291 int res2 = 0 ;
27292 PyObject * obj0 = 0 ;
27293 PyObject * obj1 = 0 ;
27294 char * kwnames[] = {
27295 (char *) "self",(char *) "diff", NULL
27296 };
27297
27298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27300 if (!SWIG_IsOK(res1)) {
27301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27302 }
27303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27305 if (!SWIG_IsOK(res2)) {
27306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27307 }
27308 if (!argp2) {
27309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27310 }
27311 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 {
27315 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27316 result = (wxDateTime *) &_result_ref;
27317 }
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27329 PyObject *resultobj = 0;
27330 wxDateTime *arg1 = (wxDateTime *) 0 ;
27331 wxDateSpan *arg2 = 0 ;
27332 wxDateTime *result = 0 ;
27333 void *argp1 = 0 ;
27334 int res1 = 0 ;
27335 void *argp2 = 0 ;
27336 int res2 = 0 ;
27337 PyObject * obj0 = 0 ;
27338 PyObject * obj1 = 0 ;
27339 char * kwnames[] = {
27340 (char *) "self",(char *) "diff", NULL
27341 };
27342
27343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27345 if (!SWIG_IsOK(res1)) {
27346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27347 }
27348 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27350 if (!SWIG_IsOK(res2)) {
27351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27352 }
27353 if (!argp2) {
27354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27355 }
27356 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 {
27360 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27361 result = (wxDateTime *) &_result_ref;
27362 }
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27367 return resultobj;
27368 fail:
27369 return NULL;
27370 }
27371
27372
27373 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27374 PyObject *resultobj = 0;
27375 wxDateTime *arg1 = (wxDateTime *) 0 ;
27376 wxTimeSpan *arg2 = 0 ;
27377 wxDateTime *result = 0 ;
27378 void *argp1 = 0 ;
27379 int res1 = 0 ;
27380 void *argp2 = 0 ;
27381 int res2 = 0 ;
27382 PyObject * obj0 = 0 ;
27383 PyObject * obj1 = 0 ;
27384 char * kwnames[] = {
27385 (char *) "self",(char *) "diff", NULL
27386 };
27387
27388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27390 if (!SWIG_IsOK(res1)) {
27391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27392 }
27393 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27394 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27395 if (!SWIG_IsOK(res2)) {
27396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27397 }
27398 if (!argp2) {
27399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27400 }
27401 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 {
27405 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27406 result = (wxDateTime *) &_result_ref;
27407 }
27408 wxPyEndAllowThreads(__tstate);
27409 if (PyErr_Occurred()) SWIG_fail;
27410 }
27411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27412 return resultobj;
27413 fail:
27414 return NULL;
27415 }
27416
27417
27418 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27419 PyObject *resultobj = 0;
27420 wxDateTime *arg1 = (wxDateTime *) 0 ;
27421 wxDateSpan *arg2 = 0 ;
27422 wxDateTime *result = 0 ;
27423 void *argp1 = 0 ;
27424 int res1 = 0 ;
27425 void *argp2 = 0 ;
27426 int res2 = 0 ;
27427 PyObject * obj0 = 0 ;
27428 PyObject * obj1 = 0 ;
27429 char * kwnames[] = {
27430 (char *) "self",(char *) "diff", NULL
27431 };
27432
27433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27435 if (!SWIG_IsOK(res1)) {
27436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27437 }
27438 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27439 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27440 if (!SWIG_IsOK(res2)) {
27441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27442 }
27443 if (!argp2) {
27444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27445 }
27446 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 {
27450 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27451 result = (wxDateTime *) &_result_ref;
27452 }
27453 wxPyEndAllowThreads(__tstate);
27454 if (PyErr_Occurred()) SWIG_fail;
27455 }
27456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27457 return resultobj;
27458 fail:
27459 return NULL;
27460 }
27461
27462
27463 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27464 PyObject *resultobj = 0;
27465 wxDateTime *arg1 = (wxDateTime *) 0 ;
27466 wxDateTime *arg2 = 0 ;
27467 wxTimeSpan result;
27468 void *argp1 = 0 ;
27469 int res1 = 0 ;
27470 void *argp2 = 0 ;
27471 int res2 = 0 ;
27472 PyObject * obj0 = 0 ;
27473 PyObject * obj1 = 0 ;
27474 char * kwnames[] = {
27475 (char *) "self",(char *) "dt", NULL
27476 };
27477
27478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27480 if (!SWIG_IsOK(res1)) {
27481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27482 }
27483 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27484 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27485 if (!SWIG_IsOK(res2)) {
27486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27487 }
27488 if (!argp2) {
27489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27490 }
27491 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27492 {
27493 PyThreadState* __tstate = wxPyBeginAllowThreads();
27494 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27495 wxPyEndAllowThreads(__tstate);
27496 if (PyErr_Occurred()) SWIG_fail;
27497 }
27498 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27506 PyObject *resultobj = 0;
27507 wxDateTime *arg1 = (wxDateTime *) 0 ;
27508 wxTimeSpan *arg2 = 0 ;
27509 wxDateTime *result = 0 ;
27510 void *argp1 = 0 ;
27511 int res1 = 0 ;
27512 void *argp2 = 0 ;
27513 int res2 = 0 ;
27514
27515 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27517 if (!SWIG_IsOK(res1)) {
27518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27519 }
27520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27521 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27522 if (!SWIG_IsOK(res2)) {
27523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27524 }
27525 if (!argp2) {
27526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27527 }
27528 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 {
27532 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27533 result = (wxDateTime *) &_result_ref;
27534 }
27535 wxPyEndAllowThreads(__tstate);
27536 if (PyErr_Occurred()) SWIG_fail;
27537 }
27538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27539 return resultobj;
27540 fail:
27541 return NULL;
27542 }
27543
27544
27545 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27546 PyObject *resultobj = 0;
27547 wxDateTime *arg1 = (wxDateTime *) 0 ;
27548 wxDateSpan *arg2 = 0 ;
27549 wxDateTime *result = 0 ;
27550 void *argp1 = 0 ;
27551 int res1 = 0 ;
27552 void *argp2 = 0 ;
27553 int res2 = 0 ;
27554
27555 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27557 if (!SWIG_IsOK(res1)) {
27558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27559 }
27560 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27561 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27562 if (!SWIG_IsOK(res2)) {
27563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27564 }
27565 if (!argp2) {
27566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27567 }
27568 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 {
27572 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27573 result = (wxDateTime *) &_result_ref;
27574 }
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27586 int argc;
27587 PyObject *argv[3];
27588
27589 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27590 --argc;
27591 if (argc == 2) {
27592 int _v = 0;
27593 {
27594 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27595 _v = SWIG_CheckState(res);
27596 }
27597 if (!_v) goto check_1;
27598 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27599 }
27600 check_1:
27601
27602 if (argc == 2) {
27603 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27604 }
27605
27606 fail:
27607 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27608 return NULL;
27609 }
27610
27611
27612 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27613 PyObject *resultobj = 0;
27614 wxDateTime *arg1 = (wxDateTime *) 0 ;
27615 wxTimeSpan *arg2 = 0 ;
27616 wxDateTime *result = 0 ;
27617 void *argp1 = 0 ;
27618 int res1 = 0 ;
27619 void *argp2 = 0 ;
27620 int res2 = 0 ;
27621
27622 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27624 if (!SWIG_IsOK(res1)) {
27625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27626 }
27627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27628 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27629 if (!SWIG_IsOK(res2)) {
27630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27631 }
27632 if (!argp2) {
27633 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27634 }
27635 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 {
27639 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27640 result = (wxDateTime *) &_result_ref;
27641 }
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27646 return resultobj;
27647 fail:
27648 return NULL;
27649 }
27650
27651
27652 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27653 PyObject *resultobj = 0;
27654 wxDateTime *arg1 = (wxDateTime *) 0 ;
27655 wxDateSpan *arg2 = 0 ;
27656 wxDateTime *result = 0 ;
27657 void *argp1 = 0 ;
27658 int res1 = 0 ;
27659 void *argp2 = 0 ;
27660 int res2 = 0 ;
27661
27662 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27664 if (!SWIG_IsOK(res1)) {
27665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27666 }
27667 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27668 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27669 if (!SWIG_IsOK(res2)) {
27670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27671 }
27672 if (!argp2) {
27673 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27674 }
27675 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27676 {
27677 PyThreadState* __tstate = wxPyBeginAllowThreads();
27678 {
27679 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27680 result = (wxDateTime *) &_result_ref;
27681 }
27682 wxPyEndAllowThreads(__tstate);
27683 if (PyErr_Occurred()) SWIG_fail;
27684 }
27685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27686 return resultobj;
27687 fail:
27688 return NULL;
27689 }
27690
27691
27692 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27693 int argc;
27694 PyObject *argv[3];
27695
27696 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27697 --argc;
27698 if (argc == 2) {
27699 int _v = 0;
27700 {
27701 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27702 _v = SWIG_CheckState(res);
27703 }
27704 if (!_v) goto check_1;
27705 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27706 }
27707 check_1:
27708
27709 if (argc == 2) {
27710 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27711 }
27712
27713 fail:
27714 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27715 return NULL;
27716 }
27717
27718
27719 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27720 PyObject *resultobj = 0;
27721 wxDateTime *arg1 = (wxDateTime *) 0 ;
27722 wxTimeSpan *arg2 = 0 ;
27723 wxDateTime result;
27724 void *argp1 = 0 ;
27725 int res1 = 0 ;
27726 void *argp2 = 0 ;
27727 int res2 = 0 ;
27728
27729 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27731 if (!SWIG_IsOK(res1)) {
27732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27733 }
27734 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27735 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27736 if (!SWIG_IsOK(res2)) {
27737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27738 }
27739 if (!argp2) {
27740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27741 }
27742 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27743 {
27744 PyThreadState* __tstate = wxPyBeginAllowThreads();
27745 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27746 wxPyEndAllowThreads(__tstate);
27747 if (PyErr_Occurred()) SWIG_fail;
27748 }
27749 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27750 return resultobj;
27751 fail:
27752 return NULL;
27753 }
27754
27755
27756 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27757 PyObject *resultobj = 0;
27758 wxDateTime *arg1 = (wxDateTime *) 0 ;
27759 wxDateSpan *arg2 = 0 ;
27760 wxDateTime result;
27761 void *argp1 = 0 ;
27762 int res1 = 0 ;
27763 void *argp2 = 0 ;
27764 int res2 = 0 ;
27765
27766 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27768 if (!SWIG_IsOK(res1)) {
27769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27770 }
27771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27772 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27773 if (!SWIG_IsOK(res2)) {
27774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27775 }
27776 if (!argp2) {
27777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27778 }
27779 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27780 {
27781 PyThreadState* __tstate = wxPyBeginAllowThreads();
27782 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27794 int argc;
27795 PyObject *argv[3];
27796
27797 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27798 --argc;
27799 if (argc == 2) {
27800 int _v = 0;
27801 {
27802 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27803 _v = SWIG_CheckState(res);
27804 }
27805 if (!_v) goto check_1;
27806 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27807 }
27808 check_1:
27809
27810 if (argc == 2) {
27811 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27812 }
27813
27814 fail:
27815 Py_INCREF(Py_NotImplemented);
27816 return Py_NotImplemented;
27817 }
27818
27819
27820 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27821 PyObject *resultobj = 0;
27822 wxDateTime *arg1 = (wxDateTime *) 0 ;
27823 wxDateTime *arg2 = 0 ;
27824 wxTimeSpan result;
27825 void *argp1 = 0 ;
27826 int res1 = 0 ;
27827 void *argp2 = 0 ;
27828 int res2 = 0 ;
27829
27830 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27832 if (!SWIG_IsOK(res1)) {
27833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27834 }
27835 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27836 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27837 if (!SWIG_IsOK(res2)) {
27838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27839 }
27840 if (!argp2) {
27841 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27842 }
27843 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27844 {
27845 PyThreadState* __tstate = wxPyBeginAllowThreads();
27846 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27847 wxPyEndAllowThreads(__tstate);
27848 if (PyErr_Occurred()) SWIG_fail;
27849 }
27850 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27858 PyObject *resultobj = 0;
27859 wxDateTime *arg1 = (wxDateTime *) 0 ;
27860 wxTimeSpan *arg2 = 0 ;
27861 wxDateTime result;
27862 void *argp1 = 0 ;
27863 int res1 = 0 ;
27864 void *argp2 = 0 ;
27865 int res2 = 0 ;
27866
27867 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27871 }
27872 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27873 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27874 if (!SWIG_IsOK(res2)) {
27875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27876 }
27877 if (!argp2) {
27878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27879 }
27880 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27888 return resultobj;
27889 fail:
27890 return NULL;
27891 }
27892
27893
27894 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27895 PyObject *resultobj = 0;
27896 wxDateTime *arg1 = (wxDateTime *) 0 ;
27897 wxDateSpan *arg2 = 0 ;
27898 wxDateTime result;
27899 void *argp1 = 0 ;
27900 int res1 = 0 ;
27901 void *argp2 = 0 ;
27902 int res2 = 0 ;
27903
27904 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27906 if (!SWIG_IsOK(res1)) {
27907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27908 }
27909 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27910 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27911 if (!SWIG_IsOK(res2)) {
27912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27913 }
27914 if (!argp2) {
27915 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27916 }
27917 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27918 {
27919 PyThreadState* __tstate = wxPyBeginAllowThreads();
27920 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27932 int argc;
27933 PyObject *argv[3];
27934
27935 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27936 --argc;
27937 if (argc == 2) {
27938 int _v = 0;
27939 {
27940 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27941 _v = SWIG_CheckState(res);
27942 }
27943 if (!_v) goto check_1;
27944 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27945 }
27946 check_1:
27947
27948 if (argc == 2) {
27949 int _v = 0;
27950 {
27951 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27952 _v = SWIG_CheckState(res);
27953 }
27954 if (!_v) goto check_2;
27955 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27956 }
27957 check_2:
27958
27959 if (argc == 2) {
27960 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27961 }
27962
27963 fail:
27964 Py_INCREF(Py_NotImplemented);
27965 return Py_NotImplemented;
27966 }
27967
27968
27969 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27970 PyObject *resultobj = 0;
27971 wxDateTime *arg1 = (wxDateTime *) 0 ;
27972 wxDateTime *arg2 = (wxDateTime *) 0 ;
27973 bool result;
27974 void *argp1 = 0 ;
27975 int res1 = 0 ;
27976 void *argp2 = 0 ;
27977 int res2 = 0 ;
27978 PyObject * obj0 = 0 ;
27979 PyObject * obj1 = 0 ;
27980 char * kwnames[] = {
27981 (char *) "self",(char *) "other", NULL
27982 };
27983
27984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27986 if (!SWIG_IsOK(res1)) {
27987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27988 }
27989 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27991 if (!SWIG_IsOK(res2)) {
27992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27993 }
27994 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27995 {
27996 PyThreadState* __tstate = wxPyBeginAllowThreads();
27997 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 {
28002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28003 }
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj = 0;
28012 wxDateTime *arg1 = (wxDateTime *) 0 ;
28013 wxDateTime *arg2 = (wxDateTime *) 0 ;
28014 bool result;
28015 void *argp1 = 0 ;
28016 int res1 = 0 ;
28017 void *argp2 = 0 ;
28018 int res2 = 0 ;
28019 PyObject * obj0 = 0 ;
28020 PyObject * obj1 = 0 ;
28021 char * kwnames[] = {
28022 (char *) "self",(char *) "other", NULL
28023 };
28024
28025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28027 if (!SWIG_IsOK(res1)) {
28028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28029 }
28030 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28032 if (!SWIG_IsOK(res2)) {
28033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28034 }
28035 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 {
28043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28044 }
28045 return resultobj;
28046 fail:
28047 return NULL;
28048 }
28049
28050
28051 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28052 PyObject *resultobj = 0;
28053 wxDateTime *arg1 = (wxDateTime *) 0 ;
28054 wxDateTime *arg2 = (wxDateTime *) 0 ;
28055 bool result;
28056 void *argp1 = 0 ;
28057 int res1 = 0 ;
28058 void *argp2 = 0 ;
28059 int res2 = 0 ;
28060 PyObject * obj0 = 0 ;
28061 PyObject * obj1 = 0 ;
28062 char * kwnames[] = {
28063 (char *) "self",(char *) "other", NULL
28064 };
28065
28066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28068 if (!SWIG_IsOK(res1)) {
28069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28070 }
28071 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28073 if (!SWIG_IsOK(res2)) {
28074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28075 }
28076 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28080 wxPyEndAllowThreads(__tstate);
28081 if (PyErr_Occurred()) SWIG_fail;
28082 }
28083 {
28084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28085 }
28086 return resultobj;
28087 fail:
28088 return NULL;
28089 }
28090
28091
28092 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28093 PyObject *resultobj = 0;
28094 wxDateTime *arg1 = (wxDateTime *) 0 ;
28095 wxDateTime *arg2 = (wxDateTime *) 0 ;
28096 bool result;
28097 void *argp1 = 0 ;
28098 int res1 = 0 ;
28099 void *argp2 = 0 ;
28100 int res2 = 0 ;
28101 PyObject * obj0 = 0 ;
28102 PyObject * obj1 = 0 ;
28103 char * kwnames[] = {
28104 (char *) "self",(char *) "other", NULL
28105 };
28106
28107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28109 if (!SWIG_IsOK(res1)) {
28110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28111 }
28112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28113 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28114 if (!SWIG_IsOK(res2)) {
28115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28116 }
28117 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28118 {
28119 PyThreadState* __tstate = wxPyBeginAllowThreads();
28120 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28121 wxPyEndAllowThreads(__tstate);
28122 if (PyErr_Occurred()) SWIG_fail;
28123 }
28124 {
28125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28126 }
28127 return resultobj;
28128 fail:
28129 return NULL;
28130 }
28131
28132
28133 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28134 PyObject *resultobj = 0;
28135 wxDateTime *arg1 = (wxDateTime *) 0 ;
28136 wxDateTime *arg2 = (wxDateTime *) 0 ;
28137 bool result;
28138 void *argp1 = 0 ;
28139 int res1 = 0 ;
28140 void *argp2 = 0 ;
28141 int res2 = 0 ;
28142 PyObject * obj0 = 0 ;
28143 PyObject * obj1 = 0 ;
28144 char * kwnames[] = {
28145 (char *) "self",(char *) "other", NULL
28146 };
28147
28148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28152 }
28153 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28155 if (!SWIG_IsOK(res2)) {
28156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28157 }
28158 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 {
28166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28167 }
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28175 PyObject *resultobj = 0;
28176 wxDateTime *arg1 = (wxDateTime *) 0 ;
28177 wxDateTime *arg2 = (wxDateTime *) 0 ;
28178 bool result;
28179 void *argp1 = 0 ;
28180 int res1 = 0 ;
28181 void *argp2 = 0 ;
28182 int res2 = 0 ;
28183 PyObject * obj0 = 0 ;
28184 PyObject * obj1 = 0 ;
28185 char * kwnames[] = {
28186 (char *) "self",(char *) "other", NULL
28187 };
28188
28189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28191 if (!SWIG_IsOK(res1)) {
28192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28193 }
28194 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28195 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28196 if (!SWIG_IsOK(res2)) {
28197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28198 }
28199 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28200 {
28201 PyThreadState* __tstate = wxPyBeginAllowThreads();
28202 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 {
28207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28208 }
28209 return resultobj;
28210 fail:
28211 return NULL;
28212 }
28213
28214
28215 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28216 PyObject *resultobj = 0;
28217 wxDateTime *arg1 = (wxDateTime *) 0 ;
28218 wxString *arg2 = 0 ;
28219 int result;
28220 void *argp1 = 0 ;
28221 int res1 = 0 ;
28222 bool temp2 = false ;
28223 PyObject * obj0 = 0 ;
28224 PyObject * obj1 = 0 ;
28225 char * kwnames[] = {
28226 (char *) "self",(char *) "date", NULL
28227 };
28228
28229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28231 if (!SWIG_IsOK(res1)) {
28232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28233 }
28234 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28235 {
28236 arg2 = wxString_in_helper(obj1);
28237 if (arg2 == NULL) SWIG_fail;
28238 temp2 = true;
28239 }
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 resultobj = SWIG_From_int(static_cast< int >(result));
28247 {
28248 if (temp2)
28249 delete arg2;
28250 }
28251 return resultobj;
28252 fail:
28253 {
28254 if (temp2)
28255 delete arg2;
28256 }
28257 return NULL;
28258 }
28259
28260
28261 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28262 PyObject *resultobj = 0;
28263 wxDateTime *arg1 = (wxDateTime *) 0 ;
28264 wxString *arg2 = 0 ;
28265 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28266 wxString *arg3 = (wxString *) &arg3_defvalue ;
28267 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28268 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28269 int result;
28270 void *argp1 = 0 ;
28271 int res1 = 0 ;
28272 bool temp2 = false ;
28273 bool temp3 = false ;
28274 void *argp4 = 0 ;
28275 int res4 = 0 ;
28276 PyObject * obj0 = 0 ;
28277 PyObject * obj1 = 0 ;
28278 PyObject * obj2 = 0 ;
28279 PyObject * obj3 = 0 ;
28280 char * kwnames[] = {
28281 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28282 };
28283
28284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28286 if (!SWIG_IsOK(res1)) {
28287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28288 }
28289 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28290 {
28291 arg2 = wxString_in_helper(obj1);
28292 if (arg2 == NULL) SWIG_fail;
28293 temp2 = true;
28294 }
28295 if (obj2) {
28296 {
28297 arg3 = wxString_in_helper(obj2);
28298 if (arg3 == NULL) SWIG_fail;
28299 temp3 = true;
28300 }
28301 }
28302 if (obj3) {
28303 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28304 if (!SWIG_IsOK(res4)) {
28305 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28306 }
28307 if (!argp4) {
28308 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28309 }
28310 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28311 }
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 resultobj = SWIG_From_int(static_cast< int >(result));
28319 {
28320 if (temp2)
28321 delete arg2;
28322 }
28323 {
28324 if (temp3)
28325 delete arg3;
28326 }
28327 return resultobj;
28328 fail:
28329 {
28330 if (temp2)
28331 delete arg2;
28332 }
28333 {
28334 if (temp3)
28335 delete arg3;
28336 }
28337 return NULL;
28338 }
28339
28340
28341 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28342 PyObject *resultobj = 0;
28343 wxDateTime *arg1 = (wxDateTime *) 0 ;
28344 wxString *arg2 = 0 ;
28345 int result;
28346 void *argp1 = 0 ;
28347 int res1 = 0 ;
28348 bool temp2 = false ;
28349 PyObject * obj0 = 0 ;
28350 PyObject * obj1 = 0 ;
28351 char * kwnames[] = {
28352 (char *) "self",(char *) "datetime", NULL
28353 };
28354
28355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28357 if (!SWIG_IsOK(res1)) {
28358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28359 }
28360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28361 {
28362 arg2 = wxString_in_helper(obj1);
28363 if (arg2 == NULL) SWIG_fail;
28364 temp2 = true;
28365 }
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_From_int(static_cast< int >(result));
28373 {
28374 if (temp2)
28375 delete arg2;
28376 }
28377 return resultobj;
28378 fail:
28379 {
28380 if (temp2)
28381 delete arg2;
28382 }
28383 return NULL;
28384 }
28385
28386
28387 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28388 PyObject *resultobj = 0;
28389 wxDateTime *arg1 = (wxDateTime *) 0 ;
28390 wxString *arg2 = 0 ;
28391 int result;
28392 void *argp1 = 0 ;
28393 int res1 = 0 ;
28394 bool temp2 = false ;
28395 PyObject * obj0 = 0 ;
28396 PyObject * obj1 = 0 ;
28397 char * kwnames[] = {
28398 (char *) "self",(char *) "date", NULL
28399 };
28400
28401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28403 if (!SWIG_IsOK(res1)) {
28404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28405 }
28406 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28407 {
28408 arg2 = wxString_in_helper(obj1);
28409 if (arg2 == NULL) SWIG_fail;
28410 temp2 = true;
28411 }
28412 {
28413 PyThreadState* __tstate = wxPyBeginAllowThreads();
28414 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28415 wxPyEndAllowThreads(__tstate);
28416 if (PyErr_Occurred()) SWIG_fail;
28417 }
28418 resultobj = SWIG_From_int(static_cast< int >(result));
28419 {
28420 if (temp2)
28421 delete arg2;
28422 }
28423 return resultobj;
28424 fail:
28425 {
28426 if (temp2)
28427 delete arg2;
28428 }
28429 return NULL;
28430 }
28431
28432
28433 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj = 0;
28435 wxDateTime *arg1 = (wxDateTime *) 0 ;
28436 wxString *arg2 = 0 ;
28437 int result;
28438 void *argp1 = 0 ;
28439 int res1 = 0 ;
28440 bool temp2 = false ;
28441 PyObject * obj0 = 0 ;
28442 PyObject * obj1 = 0 ;
28443 char * kwnames[] = {
28444 (char *) "self",(char *) "time", NULL
28445 };
28446
28447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28449 if (!SWIG_IsOK(res1)) {
28450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28451 }
28452 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28453 {
28454 arg2 = wxString_in_helper(obj1);
28455 if (arg2 == NULL) SWIG_fail;
28456 temp2 = true;
28457 }
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28461 wxPyEndAllowThreads(__tstate);
28462 if (PyErr_Occurred()) SWIG_fail;
28463 }
28464 resultobj = SWIG_From_int(static_cast< int >(result));
28465 {
28466 if (temp2)
28467 delete arg2;
28468 }
28469 return resultobj;
28470 fail:
28471 {
28472 if (temp2)
28473 delete arg2;
28474 }
28475 return NULL;
28476 }
28477
28478
28479 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28480 PyObject *resultobj = 0;
28481 wxDateTime *arg1 = (wxDateTime *) 0 ;
28482 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28483 wxString *arg2 = (wxString *) &arg2_defvalue ;
28484 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28485 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28486 wxString result;
28487 void *argp1 = 0 ;
28488 int res1 = 0 ;
28489 bool temp2 = false ;
28490 bool temp3 = false ;
28491 PyObject * obj0 = 0 ;
28492 PyObject * obj1 = 0 ;
28493 PyObject * obj2 = 0 ;
28494 char * kwnames[] = {
28495 (char *) "self",(char *) "format",(char *) "tz", NULL
28496 };
28497
28498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28500 if (!SWIG_IsOK(res1)) {
28501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28502 }
28503 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28504 if (obj1) {
28505 {
28506 arg2 = wxString_in_helper(obj1);
28507 if (arg2 == NULL) SWIG_fail;
28508 temp2 = true;
28509 }
28510 }
28511 if (obj2) {
28512 {
28513 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28514 temp3 = true;
28515 }
28516 }
28517 {
28518 PyThreadState* __tstate = wxPyBeginAllowThreads();
28519 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 {
28524 #if wxUSE_UNICODE
28525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28526 #else
28527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28528 #endif
28529 }
28530 {
28531 if (temp2)
28532 delete arg2;
28533 }
28534 {
28535 if (temp3) delete arg3;
28536 }
28537 return resultobj;
28538 fail:
28539 {
28540 if (temp2)
28541 delete arg2;
28542 }
28543 {
28544 if (temp3) delete arg3;
28545 }
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28551 PyObject *resultobj = 0;
28552 wxDateTime *arg1 = (wxDateTime *) 0 ;
28553 wxString result;
28554 void *argp1 = 0 ;
28555 int res1 = 0 ;
28556 PyObject *swig_obj[1] ;
28557
28558 if (!args) SWIG_fail;
28559 swig_obj[0] = args;
28560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28561 if (!SWIG_IsOK(res1)) {
28562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28563 }
28564 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 result = ((wxDateTime const *)arg1)->FormatDate();
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 {
28572 #if wxUSE_UNICODE
28573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28574 #else
28575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28576 #endif
28577 }
28578 return resultobj;
28579 fail:
28580 return NULL;
28581 }
28582
28583
28584 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28585 PyObject *resultobj = 0;
28586 wxDateTime *arg1 = (wxDateTime *) 0 ;
28587 wxString result;
28588 void *argp1 = 0 ;
28589 int res1 = 0 ;
28590 PyObject *swig_obj[1] ;
28591
28592 if (!args) SWIG_fail;
28593 swig_obj[0] = args;
28594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28595 if (!SWIG_IsOK(res1)) {
28596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28597 }
28598 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = ((wxDateTime const *)arg1)->FormatTime();
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 {
28606 #if wxUSE_UNICODE
28607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28608 #else
28609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28610 #endif
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28619 PyObject *resultobj = 0;
28620 wxDateTime *arg1 = (wxDateTime *) 0 ;
28621 wxString result;
28622 void *argp1 = 0 ;
28623 int res1 = 0 ;
28624 PyObject *swig_obj[1] ;
28625
28626 if (!args) SWIG_fail;
28627 swig_obj[0] = args;
28628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28629 if (!SWIG_IsOK(res1)) {
28630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28631 }
28632 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28633 {
28634 PyThreadState* __tstate = wxPyBeginAllowThreads();
28635 result = ((wxDateTime const *)arg1)->FormatISODate();
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 {
28640 #if wxUSE_UNICODE
28641 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28642 #else
28643 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28644 #endif
28645 }
28646 return resultobj;
28647 fail:
28648 return NULL;
28649 }
28650
28651
28652 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28653 PyObject *resultobj = 0;
28654 wxDateTime *arg1 = (wxDateTime *) 0 ;
28655 wxString result;
28656 void *argp1 = 0 ;
28657 int res1 = 0 ;
28658 PyObject *swig_obj[1] ;
28659
28660 if (!args) SWIG_fail;
28661 swig_obj[0] = args;
28662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28663 if (!SWIG_IsOK(res1)) {
28664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28665 }
28666 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 result = ((wxDateTime const *)arg1)->FormatISOTime();
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 {
28674 #if wxUSE_UNICODE
28675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28676 #else
28677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28678 #endif
28679 }
28680 return resultobj;
28681 fail:
28682 return NULL;
28683 }
28684
28685
28686 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28687 PyObject *obj;
28688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28689 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28690 return SWIG_Py_Void();
28691 }
28692
28693 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28694 return SWIG_Python_InitShadowInstance(args);
28695 }
28696
28697 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28698 PyObject *resultobj = 0;
28699 long arg1 ;
28700 wxTimeSpan result;
28701 long val1 ;
28702 int ecode1 = 0 ;
28703 PyObject * obj0 = 0 ;
28704 char * kwnames[] = {
28705 (char *) "ms", NULL
28706 };
28707
28708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28709 ecode1 = SWIG_AsVal_long(obj0, &val1);
28710 if (!SWIG_IsOK(ecode1)) {
28711 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28712 }
28713 arg1 = static_cast< long >(val1);
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 result = wxTimeSpan::Milliseconds(arg1);
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28721 return resultobj;
28722 fail:
28723 return NULL;
28724 }
28725
28726
28727 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28728 PyObject *resultobj = 0;
28729 wxTimeSpan result;
28730
28731 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 result = wxTimeSpan::Millisecond();
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28739 return resultobj;
28740 fail:
28741 return NULL;
28742 }
28743
28744
28745 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28746 PyObject *resultobj = 0;
28747 long arg1 ;
28748 wxTimeSpan result;
28749 long val1 ;
28750 int ecode1 = 0 ;
28751 PyObject * obj0 = 0 ;
28752 char * kwnames[] = {
28753 (char *) "sec", NULL
28754 };
28755
28756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28757 ecode1 = SWIG_AsVal_long(obj0, &val1);
28758 if (!SWIG_IsOK(ecode1)) {
28759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28760 }
28761 arg1 = static_cast< long >(val1);
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 result = wxTimeSpan::Seconds(arg1);
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28776 PyObject *resultobj = 0;
28777 wxTimeSpan result;
28778
28779 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 result = wxTimeSpan::Second();
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28794 PyObject *resultobj = 0;
28795 long arg1 ;
28796 wxTimeSpan result;
28797 long val1 ;
28798 int ecode1 = 0 ;
28799 PyObject * obj0 = 0 ;
28800 char * kwnames[] = {
28801 (char *) "min", NULL
28802 };
28803
28804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28805 ecode1 = SWIG_AsVal_long(obj0, &val1);
28806 if (!SWIG_IsOK(ecode1)) {
28807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28808 }
28809 arg1 = static_cast< long >(val1);
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = wxTimeSpan::Minutes(arg1);
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28817 return resultobj;
28818 fail:
28819 return NULL;
28820 }
28821
28822
28823 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824 PyObject *resultobj = 0;
28825 wxTimeSpan result;
28826
28827 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 result = wxTimeSpan::Minute();
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj = 0;
28843 long arg1 ;
28844 wxTimeSpan result;
28845 long val1 ;
28846 int ecode1 = 0 ;
28847 PyObject * obj0 = 0 ;
28848 char * kwnames[] = {
28849 (char *) "hours", NULL
28850 };
28851
28852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28853 ecode1 = SWIG_AsVal_long(obj0, &val1);
28854 if (!SWIG_IsOK(ecode1)) {
28855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28856 }
28857 arg1 = static_cast< long >(val1);
28858 {
28859 PyThreadState* __tstate = wxPyBeginAllowThreads();
28860 result = wxTimeSpan::Hours(arg1);
28861 wxPyEndAllowThreads(__tstate);
28862 if (PyErr_Occurred()) SWIG_fail;
28863 }
28864 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28865 return resultobj;
28866 fail:
28867 return NULL;
28868 }
28869
28870
28871 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28872 PyObject *resultobj = 0;
28873 wxTimeSpan result;
28874
28875 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 result = wxTimeSpan::Hour();
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj = 0;
28891 long arg1 ;
28892 wxTimeSpan result;
28893 long val1 ;
28894 int ecode1 = 0 ;
28895 PyObject * obj0 = 0 ;
28896 char * kwnames[] = {
28897 (char *) "days", NULL
28898 };
28899
28900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28901 ecode1 = SWIG_AsVal_long(obj0, &val1);
28902 if (!SWIG_IsOK(ecode1)) {
28903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28904 }
28905 arg1 = static_cast< long >(val1);
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = wxTimeSpan::Days(arg1);
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28913 return resultobj;
28914 fail:
28915 return NULL;
28916 }
28917
28918
28919 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28920 PyObject *resultobj = 0;
28921 wxTimeSpan result;
28922
28923 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28924 {
28925 PyThreadState* __tstate = wxPyBeginAllowThreads();
28926 result = wxTimeSpan::Day();
28927 wxPyEndAllowThreads(__tstate);
28928 if (PyErr_Occurred()) SWIG_fail;
28929 }
28930 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28931 return resultobj;
28932 fail:
28933 return NULL;
28934 }
28935
28936
28937 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28938 PyObject *resultobj = 0;
28939 long arg1 ;
28940 wxTimeSpan result;
28941 long val1 ;
28942 int ecode1 = 0 ;
28943 PyObject * obj0 = 0 ;
28944 char * kwnames[] = {
28945 (char *) "days", NULL
28946 };
28947
28948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28949 ecode1 = SWIG_AsVal_long(obj0, &val1);
28950 if (!SWIG_IsOK(ecode1)) {
28951 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28952 }
28953 arg1 = static_cast< long >(val1);
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 result = wxTimeSpan::Weeks(arg1);
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28968 PyObject *resultobj = 0;
28969 wxTimeSpan result;
28970
28971 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 result = wxTimeSpan::Week();
28975 wxPyEndAllowThreads(__tstate);
28976 if (PyErr_Occurred()) SWIG_fail;
28977 }
28978 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28979 return resultobj;
28980 fail:
28981 return NULL;
28982 }
28983
28984
28985 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28986 PyObject *resultobj = 0;
28987 long arg1 = (long) 0 ;
28988 long arg2 = (long) 0 ;
28989 long arg3 = (long) 0 ;
28990 long arg4 = (long) 0 ;
28991 wxTimeSpan *result = 0 ;
28992 long val1 ;
28993 int ecode1 = 0 ;
28994 long val2 ;
28995 int ecode2 = 0 ;
28996 long val3 ;
28997 int ecode3 = 0 ;
28998 long val4 ;
28999 int ecode4 = 0 ;
29000 PyObject * obj0 = 0 ;
29001 PyObject * obj1 = 0 ;
29002 PyObject * obj2 = 0 ;
29003 PyObject * obj3 = 0 ;
29004 char * kwnames[] = {
29005 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
29006 };
29007
29008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29009 if (obj0) {
29010 ecode1 = SWIG_AsVal_long(obj0, &val1);
29011 if (!SWIG_IsOK(ecode1)) {
29012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
29013 }
29014 arg1 = static_cast< long >(val1);
29015 }
29016 if (obj1) {
29017 ecode2 = SWIG_AsVal_long(obj1, &val2);
29018 if (!SWIG_IsOK(ecode2)) {
29019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
29020 }
29021 arg2 = static_cast< long >(val2);
29022 }
29023 if (obj2) {
29024 ecode3 = SWIG_AsVal_long(obj2, &val3);
29025 if (!SWIG_IsOK(ecode3)) {
29026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
29027 }
29028 arg3 = static_cast< long >(val3);
29029 }
29030 if (obj3) {
29031 ecode4 = SWIG_AsVal_long(obj3, &val4);
29032 if (!SWIG_IsOK(ecode4)) {
29033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
29034 }
29035 arg4 = static_cast< long >(val4);
29036 }
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 PyObject *resultobj = 0;
29052 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29053 void *argp1 = 0 ;
29054 int res1 = 0 ;
29055 PyObject *swig_obj[1] ;
29056
29057 if (!args) SWIG_fail;
29058 swig_obj[0] = args;
29059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29060 if (!SWIG_IsOK(res1)) {
29061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29062 }
29063 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29064 {
29065 PyThreadState* __tstate = wxPyBeginAllowThreads();
29066 delete arg1;
29067
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 resultobj = SWIG_Py_Void();
29072 return resultobj;
29073 fail:
29074 return NULL;
29075 }
29076
29077
29078 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj = 0;
29080 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29081 wxTimeSpan *arg2 = 0 ;
29082 wxTimeSpan *result = 0 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 void *argp2 = 0 ;
29086 int res2 = 0 ;
29087 PyObject * obj0 = 0 ;
29088 PyObject * obj1 = 0 ;
29089 char * kwnames[] = {
29090 (char *) "self",(char *) "diff", NULL
29091 };
29092
29093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29095 if (!SWIG_IsOK(res1)) {
29096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29097 }
29098 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29099 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29100 if (!SWIG_IsOK(res2)) {
29101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29102 }
29103 if (!argp2) {
29104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29105 }
29106 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 {
29110 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29111 result = (wxTimeSpan *) &_result_ref;
29112 }
29113 wxPyEndAllowThreads(__tstate);
29114 if (PyErr_Occurred()) SWIG_fail;
29115 }
29116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29124 PyObject *resultobj = 0;
29125 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29126 wxTimeSpan *arg2 = 0 ;
29127 wxTimeSpan *result = 0 ;
29128 void *argp1 = 0 ;
29129 int res1 = 0 ;
29130 void *argp2 = 0 ;
29131 int res2 = 0 ;
29132 PyObject * obj0 = 0 ;
29133 PyObject * obj1 = 0 ;
29134 char * kwnames[] = {
29135 (char *) "self",(char *) "diff", NULL
29136 };
29137
29138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29140 if (!SWIG_IsOK(res1)) {
29141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29142 }
29143 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29144 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29145 if (!SWIG_IsOK(res2)) {
29146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29147 }
29148 if (!argp2) {
29149 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29150 }
29151 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29152 {
29153 PyThreadState* __tstate = wxPyBeginAllowThreads();
29154 {
29155 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29156 result = (wxTimeSpan *) &_result_ref;
29157 }
29158 wxPyEndAllowThreads(__tstate);
29159 if (PyErr_Occurred()) SWIG_fail;
29160 }
29161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29162 return resultobj;
29163 fail:
29164 return NULL;
29165 }
29166
29167
29168 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29169 PyObject *resultobj = 0;
29170 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29171 int arg2 ;
29172 wxTimeSpan *result = 0 ;
29173 void *argp1 = 0 ;
29174 int res1 = 0 ;
29175 int val2 ;
29176 int ecode2 = 0 ;
29177 PyObject * obj0 = 0 ;
29178 PyObject * obj1 = 0 ;
29179 char * kwnames[] = {
29180 (char *) "self",(char *) "n", NULL
29181 };
29182
29183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29185 if (!SWIG_IsOK(res1)) {
29186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29187 }
29188 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29189 ecode2 = SWIG_AsVal_int(obj1, &val2);
29190 if (!SWIG_IsOK(ecode2)) {
29191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29192 }
29193 arg2 = static_cast< int >(val2);
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 {
29197 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29198 result = (wxTimeSpan *) &_result_ref;
29199 }
29200 wxPyEndAllowThreads(__tstate);
29201 if (PyErr_Occurred()) SWIG_fail;
29202 }
29203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29211 PyObject *resultobj = 0;
29212 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29213 wxTimeSpan *result = 0 ;
29214 void *argp1 = 0 ;
29215 int res1 = 0 ;
29216 PyObject *swig_obj[1] ;
29217
29218 if (!args) SWIG_fail;
29219 swig_obj[0] = args;
29220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29221 if (!SWIG_IsOK(res1)) {
29222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29223 }
29224 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29225 {
29226 PyThreadState* __tstate = wxPyBeginAllowThreads();
29227 {
29228 wxTimeSpan &_result_ref = (arg1)->Neg();
29229 result = (wxTimeSpan *) &_result_ref;
29230 }
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29242 PyObject *resultobj = 0;
29243 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29244 wxTimeSpan result;
29245 void *argp1 = 0 ;
29246 int res1 = 0 ;
29247 PyObject *swig_obj[1] ;
29248
29249 if (!args) SWIG_fail;
29250 swig_obj[0] = args;
29251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29252 if (!SWIG_IsOK(res1)) {
29253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29254 }
29255 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 result = ((wxTimeSpan const *)arg1)->Abs();
29259 wxPyEndAllowThreads(__tstate);
29260 if (PyErr_Occurred()) SWIG_fail;
29261 }
29262 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29263 return resultobj;
29264 fail:
29265 return NULL;
29266 }
29267
29268
29269 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29270 PyObject *resultobj = 0;
29271 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29272 wxTimeSpan *arg2 = 0 ;
29273 wxTimeSpan *result = 0 ;
29274 void *argp1 = 0 ;
29275 int res1 = 0 ;
29276 void *argp2 = 0 ;
29277 int res2 = 0 ;
29278 PyObject * obj0 = 0 ;
29279 PyObject * obj1 = 0 ;
29280 char * kwnames[] = {
29281 (char *) "self",(char *) "diff", NULL
29282 };
29283
29284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29286 if (!SWIG_IsOK(res1)) {
29287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29288 }
29289 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29290 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29291 if (!SWIG_IsOK(res2)) {
29292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29293 }
29294 if (!argp2) {
29295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29296 }
29297 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29298 {
29299 PyThreadState* __tstate = wxPyBeginAllowThreads();
29300 {
29301 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29302 result = (wxTimeSpan *) &_result_ref;
29303 }
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29315 PyObject *resultobj = 0;
29316 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29317 wxTimeSpan *arg2 = 0 ;
29318 wxTimeSpan *result = 0 ;
29319 void *argp1 = 0 ;
29320 int res1 = 0 ;
29321 void *argp2 = 0 ;
29322 int res2 = 0 ;
29323 PyObject * obj0 = 0 ;
29324 PyObject * obj1 = 0 ;
29325 char * kwnames[] = {
29326 (char *) "self",(char *) "diff", NULL
29327 };
29328
29329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29331 if (!SWIG_IsOK(res1)) {
29332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29333 }
29334 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29336 if (!SWIG_IsOK(res2)) {
29337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29338 }
29339 if (!argp2) {
29340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29341 }
29342 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 {
29346 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29347 result = (wxTimeSpan *) &_result_ref;
29348 }
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj = 0;
29361 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29362 int arg2 ;
29363 wxTimeSpan *result = 0 ;
29364 void *argp1 = 0 ;
29365 int res1 = 0 ;
29366 int val2 ;
29367 int ecode2 = 0 ;
29368 PyObject * obj0 = 0 ;
29369 PyObject * obj1 = 0 ;
29370 char * kwnames[] = {
29371 (char *) "self",(char *) "n", NULL
29372 };
29373
29374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29376 if (!SWIG_IsOK(res1)) {
29377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29378 }
29379 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29380 ecode2 = SWIG_AsVal_int(obj1, &val2);
29381 if (!SWIG_IsOK(ecode2)) {
29382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29383 }
29384 arg2 = static_cast< int >(val2);
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 {
29388 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29389 result = (wxTimeSpan *) &_result_ref;
29390 }
29391 wxPyEndAllowThreads(__tstate);
29392 if (PyErr_Occurred()) SWIG_fail;
29393 }
29394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29395 return resultobj;
29396 fail:
29397 return NULL;
29398 }
29399
29400
29401 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29402 PyObject *resultobj = 0;
29403 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29404 wxTimeSpan *result = 0 ;
29405 void *argp1 = 0 ;
29406 int res1 = 0 ;
29407 PyObject *swig_obj[1] ;
29408
29409 if (!args) SWIG_fail;
29410 swig_obj[0] = args;
29411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29412 if (!SWIG_IsOK(res1)) {
29413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29414 }
29415 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 {
29419 wxTimeSpan &_result_ref = (arg1)->operator -();
29420 result = (wxTimeSpan *) &_result_ref;
29421 }
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj = 0;
29434 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29435 wxTimeSpan *arg2 = 0 ;
29436 wxTimeSpan result;
29437 void *argp1 = 0 ;
29438 int res1 = 0 ;
29439 void *argp2 = 0 ;
29440 int res2 = 0 ;
29441 PyObject * obj0 = 0 ;
29442 PyObject * obj1 = 0 ;
29443 char * kwnames[] = {
29444 (char *) "self",(char *) "other", NULL
29445 };
29446
29447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29449 if (!SWIG_IsOK(res1)) {
29450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29451 }
29452 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29454 if (!SWIG_IsOK(res2)) {
29455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29456 }
29457 if (!argp2) {
29458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29459 }
29460 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj = 0;
29476 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29477 wxTimeSpan *arg2 = 0 ;
29478 wxTimeSpan result;
29479 void *argp1 = 0 ;
29480 int res1 = 0 ;
29481 void *argp2 = 0 ;
29482 int res2 = 0 ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 char * kwnames[] = {
29486 (char *) "self",(char *) "other", NULL
29487 };
29488
29489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29491 if (!SWIG_IsOK(res1)) {
29492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29493 }
29494 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29495 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29496 if (!SWIG_IsOK(res2)) {
29497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29498 }
29499 if (!argp2) {
29500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29501 }
29502 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29503 {
29504 PyThreadState* __tstate = wxPyBeginAllowThreads();
29505 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj = 0;
29518 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29519 int arg2 ;
29520 wxTimeSpan result;
29521 void *argp1 = 0 ;
29522 int res1 = 0 ;
29523 int val2 ;
29524 int ecode2 = 0 ;
29525 PyObject * obj0 = 0 ;
29526 PyObject * obj1 = 0 ;
29527 char * kwnames[] = {
29528 (char *) "self",(char *) "n", NULL
29529 };
29530
29531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29533 if (!SWIG_IsOK(res1)) {
29534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29535 }
29536 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29537 ecode2 = SWIG_AsVal_int(obj1, &val2);
29538 if (!SWIG_IsOK(ecode2)) {
29539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29540 }
29541 arg2 = static_cast< int >(val2);
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 result = wxTimeSpan___mul__(arg1,arg2);
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29556 PyObject *resultobj = 0;
29557 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29558 int arg2 ;
29559 wxTimeSpan result;
29560 void *argp1 = 0 ;
29561 int res1 = 0 ;
29562 int val2 ;
29563 int ecode2 = 0 ;
29564 PyObject * obj0 = 0 ;
29565 PyObject * obj1 = 0 ;
29566 char * kwnames[] = {
29567 (char *) "self",(char *) "n", NULL
29568 };
29569
29570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29572 if (!SWIG_IsOK(res1)) {
29573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29574 }
29575 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29576 ecode2 = SWIG_AsVal_int(obj1, &val2);
29577 if (!SWIG_IsOK(ecode2)) {
29578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29579 }
29580 arg2 = static_cast< int >(val2);
29581 {
29582 PyThreadState* __tstate = wxPyBeginAllowThreads();
29583 result = wxTimeSpan___rmul__(arg1,arg2);
29584 wxPyEndAllowThreads(__tstate);
29585 if (PyErr_Occurred()) SWIG_fail;
29586 }
29587 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29588 return resultobj;
29589 fail:
29590 return NULL;
29591 }
29592
29593
29594 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29595 PyObject *resultobj = 0;
29596 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29597 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29598 bool result;
29599 void *argp1 = 0 ;
29600 int res1 = 0 ;
29601 void *argp2 = 0 ;
29602 int res2 = 0 ;
29603 PyObject * obj0 = 0 ;
29604 PyObject * obj1 = 0 ;
29605 char * kwnames[] = {
29606 (char *) "self",(char *) "other", NULL
29607 };
29608
29609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29611 if (!SWIG_IsOK(res1)) {
29612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29613 }
29614 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29616 if (!SWIG_IsOK(res2)) {
29617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29618 }
29619 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 {
29627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29628 }
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29636 PyObject *resultobj = 0;
29637 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29638 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29639 bool result;
29640 void *argp1 = 0 ;
29641 int res1 = 0 ;
29642 void *argp2 = 0 ;
29643 int res2 = 0 ;
29644 PyObject * obj0 = 0 ;
29645 PyObject * obj1 = 0 ;
29646 char * kwnames[] = {
29647 (char *) "self",(char *) "other", NULL
29648 };
29649
29650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29652 if (!SWIG_IsOK(res1)) {
29653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29654 }
29655 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29657 if (!SWIG_IsOK(res2)) {
29658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29659 }
29660 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29661 {
29662 PyThreadState* __tstate = wxPyBeginAllowThreads();
29663 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29664 wxPyEndAllowThreads(__tstate);
29665 if (PyErr_Occurred()) SWIG_fail;
29666 }
29667 {
29668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29669 }
29670 return resultobj;
29671 fail:
29672 return NULL;
29673 }
29674
29675
29676 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29677 PyObject *resultobj = 0;
29678 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29679 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29680 bool result;
29681 void *argp1 = 0 ;
29682 int res1 = 0 ;
29683 void *argp2 = 0 ;
29684 int res2 = 0 ;
29685 PyObject * obj0 = 0 ;
29686 PyObject * obj1 = 0 ;
29687 char * kwnames[] = {
29688 (char *) "self",(char *) "other", NULL
29689 };
29690
29691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29693 if (!SWIG_IsOK(res1)) {
29694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29695 }
29696 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29698 if (!SWIG_IsOK(res2)) {
29699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29700 }
29701 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29702 {
29703 PyThreadState* __tstate = wxPyBeginAllowThreads();
29704 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29705 wxPyEndAllowThreads(__tstate);
29706 if (PyErr_Occurred()) SWIG_fail;
29707 }
29708 {
29709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29710 }
29711 return resultobj;
29712 fail:
29713 return NULL;
29714 }
29715
29716
29717 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29718 PyObject *resultobj = 0;
29719 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29720 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29721 bool result;
29722 void *argp1 = 0 ;
29723 int res1 = 0 ;
29724 void *argp2 = 0 ;
29725 int res2 = 0 ;
29726 PyObject * obj0 = 0 ;
29727 PyObject * obj1 = 0 ;
29728 char * kwnames[] = {
29729 (char *) "self",(char *) "other", NULL
29730 };
29731
29732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29734 if (!SWIG_IsOK(res1)) {
29735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29736 }
29737 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29739 if (!SWIG_IsOK(res2)) {
29740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29741 }
29742 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29743 {
29744 PyThreadState* __tstate = wxPyBeginAllowThreads();
29745 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29746 wxPyEndAllowThreads(__tstate);
29747 if (PyErr_Occurred()) SWIG_fail;
29748 }
29749 {
29750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29751 }
29752 return resultobj;
29753 fail:
29754 return NULL;
29755 }
29756
29757
29758 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj = 0;
29760 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29761 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29762 bool result;
29763 void *argp1 = 0 ;
29764 int res1 = 0 ;
29765 void *argp2 = 0 ;
29766 int res2 = 0 ;
29767 PyObject * obj0 = 0 ;
29768 PyObject * obj1 = 0 ;
29769 char * kwnames[] = {
29770 (char *) "self",(char *) "other", NULL
29771 };
29772
29773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29775 if (!SWIG_IsOK(res1)) {
29776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29777 }
29778 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29780 if (!SWIG_IsOK(res2)) {
29781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29782 }
29783 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29784 {
29785 PyThreadState* __tstate = wxPyBeginAllowThreads();
29786 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29787 wxPyEndAllowThreads(__tstate);
29788 if (PyErr_Occurred()) SWIG_fail;
29789 }
29790 {
29791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29792 }
29793 return resultobj;
29794 fail:
29795 return NULL;
29796 }
29797
29798
29799 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29800 PyObject *resultobj = 0;
29801 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29802 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29803 bool result;
29804 void *argp1 = 0 ;
29805 int res1 = 0 ;
29806 void *argp2 = 0 ;
29807 int res2 = 0 ;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 char * kwnames[] = {
29811 (char *) "self",(char *) "other", NULL
29812 };
29813
29814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29816 if (!SWIG_IsOK(res1)) {
29817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29818 }
29819 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29820 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29821 if (!SWIG_IsOK(res2)) {
29822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29823 }
29824 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 {
29832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29833 }
29834 return resultobj;
29835 fail:
29836 return NULL;
29837 }
29838
29839
29840 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29841 PyObject *resultobj = 0;
29842 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29843 bool result;
29844 void *argp1 = 0 ;
29845 int res1 = 0 ;
29846 PyObject *swig_obj[1] ;
29847
29848 if (!args) SWIG_fail;
29849 swig_obj[0] = args;
29850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29851 if (!SWIG_IsOK(res1)) {
29852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29853 }
29854 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29855 {
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 {
29862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29863 }
29864 return resultobj;
29865 fail:
29866 return NULL;
29867 }
29868
29869
29870 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29871 PyObject *resultobj = 0;
29872 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29873 bool result;
29874 void *argp1 = 0 ;
29875 int res1 = 0 ;
29876 PyObject *swig_obj[1] ;
29877
29878 if (!args) SWIG_fail;
29879 swig_obj[0] = args;
29880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29881 if (!SWIG_IsOK(res1)) {
29882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29883 }
29884 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29888 wxPyEndAllowThreads(__tstate);
29889 if (PyErr_Occurred()) SWIG_fail;
29890 }
29891 {
29892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29893 }
29894 return resultobj;
29895 fail:
29896 return NULL;
29897 }
29898
29899
29900 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29901 PyObject *resultobj = 0;
29902 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29903 bool result;
29904 void *argp1 = 0 ;
29905 int res1 = 0 ;
29906 PyObject *swig_obj[1] ;
29907
29908 if (!args) SWIG_fail;
29909 swig_obj[0] = args;
29910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29911 if (!SWIG_IsOK(res1)) {
29912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29913 }
29914 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 {
29922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29923 }
29924 return resultobj;
29925 fail:
29926 return NULL;
29927 }
29928
29929
29930 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29931 PyObject *resultobj = 0;
29932 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29933 wxTimeSpan *arg2 = 0 ;
29934 bool result;
29935 void *argp1 = 0 ;
29936 int res1 = 0 ;
29937 void *argp2 = 0 ;
29938 int res2 = 0 ;
29939 PyObject * obj0 = 0 ;
29940 PyObject * obj1 = 0 ;
29941 char * kwnames[] = {
29942 (char *) "self",(char *) "ts", NULL
29943 };
29944
29945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29947 if (!SWIG_IsOK(res1)) {
29948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29949 }
29950 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29951 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29952 if (!SWIG_IsOK(res2)) {
29953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29954 }
29955 if (!argp2) {
29956 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29957 }
29958 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29959 {
29960 PyThreadState* __tstate = wxPyBeginAllowThreads();
29961 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29962 wxPyEndAllowThreads(__tstate);
29963 if (PyErr_Occurred()) SWIG_fail;
29964 }
29965 {
29966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29967 }
29968 return resultobj;
29969 fail:
29970 return NULL;
29971 }
29972
29973
29974 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29975 PyObject *resultobj = 0;
29976 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29977 wxTimeSpan *arg2 = 0 ;
29978 bool result;
29979 void *argp1 = 0 ;
29980 int res1 = 0 ;
29981 void *argp2 = 0 ;
29982 int res2 = 0 ;
29983 PyObject * obj0 = 0 ;
29984 PyObject * obj1 = 0 ;
29985 char * kwnames[] = {
29986 (char *) "self",(char *) "ts", NULL
29987 };
29988
29989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29991 if (!SWIG_IsOK(res1)) {
29992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29993 }
29994 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29995 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29996 if (!SWIG_IsOK(res2)) {
29997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29998 }
29999 if (!argp2) {
30000 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30001 }
30002 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30003 {
30004 PyThreadState* __tstate = wxPyBeginAllowThreads();
30005 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 {
30010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30011 }
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30019 PyObject *resultobj = 0;
30020 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30021 wxTimeSpan *arg2 = 0 ;
30022 bool result;
30023 void *argp1 = 0 ;
30024 int res1 = 0 ;
30025 void *argp2 = 0 ;
30026 int res2 = 0 ;
30027 PyObject * obj0 = 0 ;
30028 PyObject * obj1 = 0 ;
30029 char * kwnames[] = {
30030 (char *) "self",(char *) "t", NULL
30031 };
30032
30033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
30034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30035 if (!SWIG_IsOK(res1)) {
30036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30037 }
30038 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30039 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30040 if (!SWIG_IsOK(res2)) {
30041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30042 }
30043 if (!argp2) {
30044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30045 }
30046 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 {
30054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30055 }
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30063 PyObject *resultobj = 0;
30064 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30065 int result;
30066 void *argp1 = 0 ;
30067 int res1 = 0 ;
30068 PyObject *swig_obj[1] ;
30069
30070 if (!args) SWIG_fail;
30071 swig_obj[0] = args;
30072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30073 if (!SWIG_IsOK(res1)) {
30074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30075 }
30076 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30077 {
30078 PyThreadState* __tstate = wxPyBeginAllowThreads();
30079 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30080 wxPyEndAllowThreads(__tstate);
30081 if (PyErr_Occurred()) SWIG_fail;
30082 }
30083 resultobj = SWIG_From_int(static_cast< int >(result));
30084 return resultobj;
30085 fail:
30086 return NULL;
30087 }
30088
30089
30090 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30091 PyObject *resultobj = 0;
30092 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30093 int result;
30094 void *argp1 = 0 ;
30095 int res1 = 0 ;
30096 PyObject *swig_obj[1] ;
30097
30098 if (!args) SWIG_fail;
30099 swig_obj[0] = args;
30100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30101 if (!SWIG_IsOK(res1)) {
30102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30103 }
30104 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30105 {
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 resultobj = SWIG_From_int(static_cast< int >(result));
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30119 PyObject *resultobj = 0;
30120 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30121 int result;
30122 void *argp1 = 0 ;
30123 int res1 = 0 ;
30124 PyObject *swig_obj[1] ;
30125
30126 if (!args) SWIG_fail;
30127 swig_obj[0] = args;
30128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30129 if (!SWIG_IsOK(res1)) {
30130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30131 }
30132 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30136 wxPyEndAllowThreads(__tstate);
30137 if (PyErr_Occurred()) SWIG_fail;
30138 }
30139 resultobj = SWIG_From_int(static_cast< int >(result));
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30147 PyObject *resultobj = 0;
30148 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30149 int result;
30150 void *argp1 = 0 ;
30151 int res1 = 0 ;
30152 PyObject *swig_obj[1] ;
30153
30154 if (!args) SWIG_fail;
30155 swig_obj[0] = args;
30156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30157 if (!SWIG_IsOK(res1)) {
30158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30159 }
30160 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30164 wxPyEndAllowThreads(__tstate);
30165 if (PyErr_Occurred()) SWIG_fail;
30166 }
30167 resultobj = SWIG_From_int(static_cast< int >(result));
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30175 PyObject *resultobj = 0;
30176 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30177 wxLongLong result;
30178 void *argp1 = 0 ;
30179 int res1 = 0 ;
30180 PyObject *swig_obj[1] ;
30181
30182 if (!args) SWIG_fail;
30183 swig_obj[0] = args;
30184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30185 if (!SWIG_IsOK(res1)) {
30186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30187 }
30188 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30192 wxPyEndAllowThreads(__tstate);
30193 if (PyErr_Occurred()) SWIG_fail;
30194 }
30195 {
30196 PyObject *hi, *lo, *shifter, *shifted;
30197 hi = PyLong_FromLong( (&result)->GetHi() );
30198 lo = PyLong_FromLong( (&result)->GetLo() );
30199 shifter = PyLong_FromLong(32);
30200 shifted = PyNumber_Lshift(hi, shifter);
30201 resultobj = PyNumber_Or(shifted, lo);
30202 Py_DECREF(hi);
30203 Py_DECREF(lo);
30204 Py_DECREF(shifter);
30205 Py_DECREF(shifted);
30206 }
30207 return resultobj;
30208 fail:
30209 return NULL;
30210 }
30211
30212
30213 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30214 PyObject *resultobj = 0;
30215 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30216 wxLongLong result;
30217 void *argp1 = 0 ;
30218 int res1 = 0 ;
30219 PyObject *swig_obj[1] ;
30220
30221 if (!args) SWIG_fail;
30222 swig_obj[0] = args;
30223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30224 if (!SWIG_IsOK(res1)) {
30225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30226 }
30227 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30228 {
30229 PyThreadState* __tstate = wxPyBeginAllowThreads();
30230 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30231 wxPyEndAllowThreads(__tstate);
30232 if (PyErr_Occurred()) SWIG_fail;
30233 }
30234 {
30235 PyObject *hi, *lo, *shifter, *shifted;
30236 hi = PyLong_FromLong( (&result)->GetHi() );
30237 lo = PyLong_FromLong( (&result)->GetLo() );
30238 shifter = PyLong_FromLong(32);
30239 shifted = PyNumber_Lshift(hi, shifter);
30240 resultobj = PyNumber_Or(shifted, lo);
30241 Py_DECREF(hi);
30242 Py_DECREF(lo);
30243 Py_DECREF(shifter);
30244 Py_DECREF(shifted);
30245 }
30246 return resultobj;
30247 fail:
30248 return NULL;
30249 }
30250
30251
30252 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30253 PyObject *resultobj = 0;
30254 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30255 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30256 wxString *arg2 = (wxString *) &arg2_defvalue ;
30257 wxString result;
30258 void *argp1 = 0 ;
30259 int res1 = 0 ;
30260 bool temp2 = false ;
30261 PyObject * obj0 = 0 ;
30262 PyObject * obj1 = 0 ;
30263 char * kwnames[] = {
30264 (char *) "self",(char *) "format", NULL
30265 };
30266
30267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30269 if (!SWIG_IsOK(res1)) {
30270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30271 }
30272 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30273 if (obj1) {
30274 {
30275 arg2 = wxString_in_helper(obj1);
30276 if (arg2 == NULL) SWIG_fail;
30277 temp2 = true;
30278 }
30279 }
30280 {
30281 PyThreadState* __tstate = wxPyBeginAllowThreads();
30282 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 {
30287 #if wxUSE_UNICODE
30288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30289 #else
30290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30291 #endif
30292 }
30293 {
30294 if (temp2)
30295 delete arg2;
30296 }
30297 return resultobj;
30298 fail:
30299 {
30300 if (temp2)
30301 delete arg2;
30302 }
30303 return NULL;
30304 }
30305
30306
30307 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30308 PyObject *obj;
30309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30310 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30311 return SWIG_Py_Void();
30312 }
30313
30314 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30315 return SWIG_Python_InitShadowInstance(args);
30316 }
30317
30318 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30319 PyObject *resultobj = 0;
30320 int arg1 = (int) 0 ;
30321 int arg2 = (int) 0 ;
30322 int arg3 = (int) 0 ;
30323 int arg4 = (int) 0 ;
30324 wxDateSpan *result = 0 ;
30325 int val1 ;
30326 int ecode1 = 0 ;
30327 int val2 ;
30328 int ecode2 = 0 ;
30329 int val3 ;
30330 int ecode3 = 0 ;
30331 int val4 ;
30332 int ecode4 = 0 ;
30333 PyObject * obj0 = 0 ;
30334 PyObject * obj1 = 0 ;
30335 PyObject * obj2 = 0 ;
30336 PyObject * obj3 = 0 ;
30337 char * kwnames[] = {
30338 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30339 };
30340
30341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30342 if (obj0) {
30343 ecode1 = SWIG_AsVal_int(obj0, &val1);
30344 if (!SWIG_IsOK(ecode1)) {
30345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30346 }
30347 arg1 = static_cast< int >(val1);
30348 }
30349 if (obj1) {
30350 ecode2 = SWIG_AsVal_int(obj1, &val2);
30351 if (!SWIG_IsOK(ecode2)) {
30352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30353 }
30354 arg2 = static_cast< int >(val2);
30355 }
30356 if (obj2) {
30357 ecode3 = SWIG_AsVal_int(obj2, &val3);
30358 if (!SWIG_IsOK(ecode3)) {
30359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30360 }
30361 arg3 = static_cast< int >(val3);
30362 }
30363 if (obj3) {
30364 ecode4 = SWIG_AsVal_int(obj3, &val4);
30365 if (!SWIG_IsOK(ecode4)) {
30366 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30367 }
30368 arg4 = static_cast< int >(val4);
30369 }
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30384 PyObject *resultobj = 0;
30385 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30386 void *argp1 = 0 ;
30387 int res1 = 0 ;
30388 PyObject *swig_obj[1] ;
30389
30390 if (!args) SWIG_fail;
30391 swig_obj[0] = args;
30392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30393 if (!SWIG_IsOK(res1)) {
30394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30395 }
30396 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30397 {
30398 PyThreadState* __tstate = wxPyBeginAllowThreads();
30399 delete arg1;
30400
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 resultobj = SWIG_Py_Void();
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30412 PyObject *resultobj = 0;
30413 int arg1 ;
30414 wxDateSpan result;
30415 int val1 ;
30416 int ecode1 = 0 ;
30417 PyObject * obj0 = 0 ;
30418 char * kwnames[] = {
30419 (char *) "days", NULL
30420 };
30421
30422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30423 ecode1 = SWIG_AsVal_int(obj0, &val1);
30424 if (!SWIG_IsOK(ecode1)) {
30425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30426 }
30427 arg1 = static_cast< int >(val1);
30428 {
30429 PyThreadState* __tstate = wxPyBeginAllowThreads();
30430 result = wxDateSpan::Days(arg1);
30431 wxPyEndAllowThreads(__tstate);
30432 if (PyErr_Occurred()) SWIG_fail;
30433 }
30434 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30435 return resultobj;
30436 fail:
30437 return NULL;
30438 }
30439
30440
30441 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30442 PyObject *resultobj = 0;
30443 wxDateSpan result;
30444
30445 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30446 {
30447 PyThreadState* __tstate = wxPyBeginAllowThreads();
30448 result = wxDateSpan::Day();
30449 wxPyEndAllowThreads(__tstate);
30450 if (PyErr_Occurred()) SWIG_fail;
30451 }
30452 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj = 0;
30461 int arg1 ;
30462 wxDateSpan result;
30463 int val1 ;
30464 int ecode1 = 0 ;
30465 PyObject * obj0 = 0 ;
30466 char * kwnames[] = {
30467 (char *) "weeks", NULL
30468 };
30469
30470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30471 ecode1 = SWIG_AsVal_int(obj0, &val1);
30472 if (!SWIG_IsOK(ecode1)) {
30473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30474 }
30475 arg1 = static_cast< int >(val1);
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = wxDateSpan::Weeks(arg1);
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30490 PyObject *resultobj = 0;
30491 wxDateSpan result;
30492
30493 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 result = wxDateSpan::Week();
30497 wxPyEndAllowThreads(__tstate);
30498 if (PyErr_Occurred()) SWIG_fail;
30499 }
30500 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30508 PyObject *resultobj = 0;
30509 int arg1 ;
30510 wxDateSpan result;
30511 int val1 ;
30512 int ecode1 = 0 ;
30513 PyObject * obj0 = 0 ;
30514 char * kwnames[] = {
30515 (char *) "mon", NULL
30516 };
30517
30518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30519 ecode1 = SWIG_AsVal_int(obj0, &val1);
30520 if (!SWIG_IsOK(ecode1)) {
30521 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30522 }
30523 arg1 = static_cast< int >(val1);
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 result = wxDateSpan::Months(arg1);
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30531 return resultobj;
30532 fail:
30533 return NULL;
30534 }
30535
30536
30537 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30538 PyObject *resultobj = 0;
30539 wxDateSpan result;
30540
30541 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30542 {
30543 PyThreadState* __tstate = wxPyBeginAllowThreads();
30544 result = wxDateSpan::Month();
30545 wxPyEndAllowThreads(__tstate);
30546 if (PyErr_Occurred()) SWIG_fail;
30547 }
30548 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30549 return resultobj;
30550 fail:
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30556 PyObject *resultobj = 0;
30557 int arg1 ;
30558 wxDateSpan result;
30559 int val1 ;
30560 int ecode1 = 0 ;
30561 PyObject * obj0 = 0 ;
30562 char * kwnames[] = {
30563 (char *) "years", NULL
30564 };
30565
30566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30567 ecode1 = SWIG_AsVal_int(obj0, &val1);
30568 if (!SWIG_IsOK(ecode1)) {
30569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30570 }
30571 arg1 = static_cast< int >(val1);
30572 {
30573 PyThreadState* __tstate = wxPyBeginAllowThreads();
30574 result = wxDateSpan::Years(arg1);
30575 wxPyEndAllowThreads(__tstate);
30576 if (PyErr_Occurred()) SWIG_fail;
30577 }
30578 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30586 PyObject *resultobj = 0;
30587 wxDateSpan result;
30588
30589 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 result = wxDateSpan::Year();
30593 wxPyEndAllowThreads(__tstate);
30594 if (PyErr_Occurred()) SWIG_fail;
30595 }
30596 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30597 return resultobj;
30598 fail:
30599 return NULL;
30600 }
30601
30602
30603 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30604 PyObject *resultobj = 0;
30605 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30606 int arg2 ;
30607 wxDateSpan *result = 0 ;
30608 void *argp1 = 0 ;
30609 int res1 = 0 ;
30610 int val2 ;
30611 int ecode2 = 0 ;
30612 PyObject * obj0 = 0 ;
30613 PyObject * obj1 = 0 ;
30614 char * kwnames[] = {
30615 (char *) "self",(char *) "n", NULL
30616 };
30617
30618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30620 if (!SWIG_IsOK(res1)) {
30621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30622 }
30623 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30624 ecode2 = SWIG_AsVal_int(obj1, &val2);
30625 if (!SWIG_IsOK(ecode2)) {
30626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30627 }
30628 arg2 = static_cast< int >(val2);
30629 {
30630 PyThreadState* __tstate = wxPyBeginAllowThreads();
30631 {
30632 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30633 result = (wxDateSpan *) &_result_ref;
30634 }
30635 wxPyEndAllowThreads(__tstate);
30636 if (PyErr_Occurred()) SWIG_fail;
30637 }
30638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30639 return resultobj;
30640 fail:
30641 return NULL;
30642 }
30643
30644
30645 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30646 PyObject *resultobj = 0;
30647 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30648 int arg2 ;
30649 wxDateSpan *result = 0 ;
30650 void *argp1 = 0 ;
30651 int res1 = 0 ;
30652 int val2 ;
30653 int ecode2 = 0 ;
30654 PyObject * obj0 = 0 ;
30655 PyObject * obj1 = 0 ;
30656 char * kwnames[] = {
30657 (char *) "self",(char *) "n", NULL
30658 };
30659
30660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30662 if (!SWIG_IsOK(res1)) {
30663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30664 }
30665 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30666 ecode2 = SWIG_AsVal_int(obj1, &val2);
30667 if (!SWIG_IsOK(ecode2)) {
30668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30669 }
30670 arg2 = static_cast< int >(val2);
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 {
30674 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30675 result = (wxDateSpan *) &_result_ref;
30676 }
30677 wxPyEndAllowThreads(__tstate);
30678 if (PyErr_Occurred()) SWIG_fail;
30679 }
30680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30681 return resultobj;
30682 fail:
30683 return NULL;
30684 }
30685
30686
30687 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30688 PyObject *resultobj = 0;
30689 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30690 int arg2 ;
30691 wxDateSpan *result = 0 ;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 int val2 ;
30695 int ecode2 = 0 ;
30696 PyObject * obj0 = 0 ;
30697 PyObject * obj1 = 0 ;
30698 char * kwnames[] = {
30699 (char *) "self",(char *) "n", NULL
30700 };
30701
30702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30704 if (!SWIG_IsOK(res1)) {
30705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30706 }
30707 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30708 ecode2 = SWIG_AsVal_int(obj1, &val2);
30709 if (!SWIG_IsOK(ecode2)) {
30710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30711 }
30712 arg2 = static_cast< int >(val2);
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 {
30716 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30717 result = (wxDateSpan *) &_result_ref;
30718 }
30719 wxPyEndAllowThreads(__tstate);
30720 if (PyErr_Occurred()) SWIG_fail;
30721 }
30722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30723 return resultobj;
30724 fail:
30725 return NULL;
30726 }
30727
30728
30729 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30730 PyObject *resultobj = 0;
30731 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30732 int arg2 ;
30733 wxDateSpan *result = 0 ;
30734 void *argp1 = 0 ;
30735 int res1 = 0 ;
30736 int val2 ;
30737 int ecode2 = 0 ;
30738 PyObject * obj0 = 0 ;
30739 PyObject * obj1 = 0 ;
30740 char * kwnames[] = {
30741 (char *) "self",(char *) "n", NULL
30742 };
30743
30744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30748 }
30749 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30750 ecode2 = SWIG_AsVal_int(obj1, &val2);
30751 if (!SWIG_IsOK(ecode2)) {
30752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30753 }
30754 arg2 = static_cast< int >(val2);
30755 {
30756 PyThreadState* __tstate = wxPyBeginAllowThreads();
30757 {
30758 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30759 result = (wxDateSpan *) &_result_ref;
30760 }
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30772 PyObject *resultobj = 0;
30773 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30774 int result;
30775 void *argp1 = 0 ;
30776 int res1 = 0 ;
30777 PyObject *swig_obj[1] ;
30778
30779 if (!args) SWIG_fail;
30780 swig_obj[0] = args;
30781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30782 if (!SWIG_IsOK(res1)) {
30783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30784 }
30785 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (int)((wxDateSpan const *)arg1)->GetYears();
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 resultobj = SWIG_From_int(static_cast< int >(result));
30793 return resultobj;
30794 fail:
30795 return NULL;
30796 }
30797
30798
30799 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30800 PyObject *resultobj = 0;
30801 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30802 int result;
30803 void *argp1 = 0 ;
30804 int res1 = 0 ;
30805 PyObject *swig_obj[1] ;
30806
30807 if (!args) SWIG_fail;
30808 swig_obj[0] = args;
30809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30810 if (!SWIG_IsOK(res1)) {
30811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30812 }
30813 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30817 wxPyEndAllowThreads(__tstate);
30818 if (PyErr_Occurred()) SWIG_fail;
30819 }
30820 resultobj = SWIG_From_int(static_cast< int >(result));
30821 return resultobj;
30822 fail:
30823 return NULL;
30824 }
30825
30826
30827 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30828 PyObject *resultobj = 0;
30829 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30830 int result;
30831 void *argp1 = 0 ;
30832 int res1 = 0 ;
30833 PyObject *swig_obj[1] ;
30834
30835 if (!args) SWIG_fail;
30836 swig_obj[0] = args;
30837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30838 if (!SWIG_IsOK(res1)) {
30839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30840 }
30841 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30842 {
30843 PyThreadState* __tstate = wxPyBeginAllowThreads();
30844 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30845 wxPyEndAllowThreads(__tstate);
30846 if (PyErr_Occurred()) SWIG_fail;
30847 }
30848 resultobj = SWIG_From_int(static_cast< int >(result));
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30856 PyObject *resultobj = 0;
30857 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30858 int result;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 PyObject *swig_obj[1] ;
30862
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = (int)((wxDateSpan const *)arg1)->GetDays();
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 resultobj = SWIG_From_int(static_cast< int >(result));
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30884 PyObject *resultobj = 0;
30885 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30886 int result;
30887 void *argp1 = 0 ;
30888 int res1 = 0 ;
30889 PyObject *swig_obj[1] ;
30890
30891 if (!args) SWIG_fail;
30892 swig_obj[0] = args;
30893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30894 if (!SWIG_IsOK(res1)) {
30895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30896 }
30897 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30901 wxPyEndAllowThreads(__tstate);
30902 if (PyErr_Occurred()) SWIG_fail;
30903 }
30904 resultobj = SWIG_From_int(static_cast< int >(result));
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30912 PyObject *resultobj = 0;
30913 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30914 wxDateSpan *arg2 = 0 ;
30915 wxDateSpan *result = 0 ;
30916 void *argp1 = 0 ;
30917 int res1 = 0 ;
30918 void *argp2 = 0 ;
30919 int res2 = 0 ;
30920 PyObject * obj0 = 0 ;
30921 PyObject * obj1 = 0 ;
30922 char * kwnames[] = {
30923 (char *) "self",(char *) "other", NULL
30924 };
30925
30926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30928 if (!SWIG_IsOK(res1)) {
30929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30930 }
30931 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30932 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30933 if (!SWIG_IsOK(res2)) {
30934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30935 }
30936 if (!argp2) {
30937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30938 }
30939 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 {
30943 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30944 result = (wxDateSpan *) &_result_ref;
30945 }
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj = 0;
30958 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30959 wxDateSpan *arg2 = 0 ;
30960 wxDateSpan *result = 0 ;
30961 void *argp1 = 0 ;
30962 int res1 = 0 ;
30963 void *argp2 = 0 ;
30964 int res2 = 0 ;
30965 PyObject * obj0 = 0 ;
30966 PyObject * obj1 = 0 ;
30967 char * kwnames[] = {
30968 (char *) "self",(char *) "other", NULL
30969 };
30970
30971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30973 if (!SWIG_IsOK(res1)) {
30974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30975 }
30976 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30978 if (!SWIG_IsOK(res2)) {
30979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30980 }
30981 if (!argp2) {
30982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30983 }
30984 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30985 {
30986 PyThreadState* __tstate = wxPyBeginAllowThreads();
30987 {
30988 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30989 result = (wxDateSpan *) &_result_ref;
30990 }
30991 wxPyEndAllowThreads(__tstate);
30992 if (PyErr_Occurred()) SWIG_fail;
30993 }
30994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30995 return resultobj;
30996 fail:
30997 return NULL;
30998 }
30999
31000
31001 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31002 PyObject *resultobj = 0;
31003 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31004 wxDateSpan *result = 0 ;
31005 void *argp1 = 0 ;
31006 int res1 = 0 ;
31007 PyObject *swig_obj[1] ;
31008
31009 if (!args) SWIG_fail;
31010 swig_obj[0] = args;
31011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31012 if (!SWIG_IsOK(res1)) {
31013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31014 }
31015 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31016 {
31017 PyThreadState* __tstate = wxPyBeginAllowThreads();
31018 {
31019 wxDateSpan &_result_ref = (arg1)->Neg();
31020 result = (wxDateSpan *) &_result_ref;
31021 }
31022 wxPyEndAllowThreads(__tstate);
31023 if (PyErr_Occurred()) SWIG_fail;
31024 }
31025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31026 return resultobj;
31027 fail:
31028 return NULL;
31029 }
31030
31031
31032 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31033 PyObject *resultobj = 0;
31034 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31035 int arg2 ;
31036 wxDateSpan *result = 0 ;
31037 void *argp1 = 0 ;
31038 int res1 = 0 ;
31039 int val2 ;
31040 int ecode2 = 0 ;
31041 PyObject * obj0 = 0 ;
31042 PyObject * obj1 = 0 ;
31043 char * kwnames[] = {
31044 (char *) "self",(char *) "factor", NULL
31045 };
31046
31047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31049 if (!SWIG_IsOK(res1)) {
31050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31051 }
31052 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31053 ecode2 = SWIG_AsVal_int(obj1, &val2);
31054 if (!SWIG_IsOK(ecode2)) {
31055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31056 }
31057 arg2 = static_cast< int >(val2);
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 {
31061 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31062 result = (wxDateSpan *) &_result_ref;
31063 }
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31068 return resultobj;
31069 fail:
31070 return NULL;
31071 }
31072
31073
31074 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31075 PyObject *resultobj = 0;
31076 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31077 wxDateSpan *arg2 = 0 ;
31078 wxDateSpan *result = 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 void *argp2 = 0 ;
31082 int res2 = 0 ;
31083 PyObject * obj0 = 0 ;
31084 PyObject * obj1 = 0 ;
31085 char * kwnames[] = {
31086 (char *) "self",(char *) "other", NULL
31087 };
31088
31089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31091 if (!SWIG_IsOK(res1)) {
31092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31093 }
31094 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31096 if (!SWIG_IsOK(res2)) {
31097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31098 }
31099 if (!argp2) {
31100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31101 }
31102 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 {
31106 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31107 result = (wxDateSpan *) &_result_ref;
31108 }
31109 wxPyEndAllowThreads(__tstate);
31110 if (PyErr_Occurred()) SWIG_fail;
31111 }
31112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31113 return resultobj;
31114 fail:
31115 return NULL;
31116 }
31117
31118
31119 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31120 PyObject *resultobj = 0;
31121 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31122 wxDateSpan *arg2 = 0 ;
31123 wxDateSpan *result = 0 ;
31124 void *argp1 = 0 ;
31125 int res1 = 0 ;
31126 void *argp2 = 0 ;
31127 int res2 = 0 ;
31128 PyObject * obj0 = 0 ;
31129 PyObject * obj1 = 0 ;
31130 char * kwnames[] = {
31131 (char *) "self",(char *) "other", NULL
31132 };
31133
31134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31136 if (!SWIG_IsOK(res1)) {
31137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31138 }
31139 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31140 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31141 if (!SWIG_IsOK(res2)) {
31142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31143 }
31144 if (!argp2) {
31145 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31146 }
31147 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 {
31151 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31152 result = (wxDateSpan *) &_result_ref;
31153 }
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31165 PyObject *resultobj = 0;
31166 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31167 wxDateSpan *result = 0 ;
31168 void *argp1 = 0 ;
31169 int res1 = 0 ;
31170 PyObject *swig_obj[1] ;
31171
31172 if (!args) SWIG_fail;
31173 swig_obj[0] = args;
31174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31175 if (!SWIG_IsOK(res1)) {
31176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31177 }
31178 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31179 {
31180 PyThreadState* __tstate = wxPyBeginAllowThreads();
31181 {
31182 wxDateSpan &_result_ref = (arg1)->operator -();
31183 result = (wxDateSpan *) &_result_ref;
31184 }
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31189 return resultobj;
31190 fail:
31191 return NULL;
31192 }
31193
31194
31195 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31196 PyObject *resultobj = 0;
31197 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31198 int arg2 ;
31199 wxDateSpan *result = 0 ;
31200 void *argp1 = 0 ;
31201 int res1 = 0 ;
31202 int val2 ;
31203 int ecode2 = 0 ;
31204 PyObject * obj0 = 0 ;
31205 PyObject * obj1 = 0 ;
31206 char * kwnames[] = {
31207 (char *) "self",(char *) "factor", NULL
31208 };
31209
31210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31212 if (!SWIG_IsOK(res1)) {
31213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31214 }
31215 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31216 ecode2 = SWIG_AsVal_int(obj1, &val2);
31217 if (!SWIG_IsOK(ecode2)) {
31218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31219 }
31220 arg2 = static_cast< int >(val2);
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 {
31224 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31225 result = (wxDateSpan *) &_result_ref;
31226 }
31227 wxPyEndAllowThreads(__tstate);
31228 if (PyErr_Occurred()) SWIG_fail;
31229 }
31230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31231 return resultobj;
31232 fail:
31233 return NULL;
31234 }
31235
31236
31237 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31238 PyObject *resultobj = 0;
31239 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31240 wxDateSpan *arg2 = 0 ;
31241 wxDateSpan result;
31242 void *argp1 = 0 ;
31243 int res1 = 0 ;
31244 void *argp2 = 0 ;
31245 int res2 = 0 ;
31246 PyObject * obj0 = 0 ;
31247 PyObject * obj1 = 0 ;
31248 char * kwnames[] = {
31249 (char *) "self",(char *) "other", NULL
31250 };
31251
31252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31254 if (!SWIG_IsOK(res1)) {
31255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31256 }
31257 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31258 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31259 if (!SWIG_IsOK(res2)) {
31260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31261 }
31262 if (!argp2) {
31263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31264 }
31265 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31266 {
31267 PyThreadState* __tstate = wxPyBeginAllowThreads();
31268 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31269 wxPyEndAllowThreads(__tstate);
31270 if (PyErr_Occurred()) SWIG_fail;
31271 }
31272 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31273 return resultobj;
31274 fail:
31275 return NULL;
31276 }
31277
31278
31279 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31280 PyObject *resultobj = 0;
31281 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31282 wxDateSpan *arg2 = 0 ;
31283 wxDateSpan result;
31284 void *argp1 = 0 ;
31285 int res1 = 0 ;
31286 void *argp2 = 0 ;
31287 int res2 = 0 ;
31288 PyObject * obj0 = 0 ;
31289 PyObject * obj1 = 0 ;
31290 char * kwnames[] = {
31291 (char *) "self",(char *) "other", NULL
31292 };
31293
31294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31296 if (!SWIG_IsOK(res1)) {
31297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31298 }
31299 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31300 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31301 if (!SWIG_IsOK(res2)) {
31302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31303 }
31304 if (!argp2) {
31305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31306 }
31307 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31308 {
31309 PyThreadState* __tstate = wxPyBeginAllowThreads();
31310 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31315 return resultobj;
31316 fail:
31317 return NULL;
31318 }
31319
31320
31321 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31322 PyObject *resultobj = 0;
31323 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31324 int arg2 ;
31325 wxDateSpan result;
31326 void *argp1 = 0 ;
31327 int res1 = 0 ;
31328 int val2 ;
31329 int ecode2 = 0 ;
31330 PyObject * obj0 = 0 ;
31331 PyObject * obj1 = 0 ;
31332 char * kwnames[] = {
31333 (char *) "self",(char *) "n", NULL
31334 };
31335
31336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31338 if (!SWIG_IsOK(res1)) {
31339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31340 }
31341 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31342 ecode2 = SWIG_AsVal_int(obj1, &val2);
31343 if (!SWIG_IsOK(ecode2)) {
31344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31345 }
31346 arg2 = static_cast< int >(val2);
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 result = wxDateSpan___mul__(arg1,arg2);
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31354 return resultobj;
31355 fail:
31356 return NULL;
31357 }
31358
31359
31360 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31361 PyObject *resultobj = 0;
31362 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31363 int arg2 ;
31364 wxDateSpan result;
31365 void *argp1 = 0 ;
31366 int res1 = 0 ;
31367 int val2 ;
31368 int ecode2 = 0 ;
31369 PyObject * obj0 = 0 ;
31370 PyObject * obj1 = 0 ;
31371 char * kwnames[] = {
31372 (char *) "self",(char *) "n", NULL
31373 };
31374
31375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31377 if (!SWIG_IsOK(res1)) {
31378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31379 }
31380 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31381 ecode2 = SWIG_AsVal_int(obj1, &val2);
31382 if (!SWIG_IsOK(ecode2)) {
31383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31384 }
31385 arg2 = static_cast< int >(val2);
31386 {
31387 PyThreadState* __tstate = wxPyBeginAllowThreads();
31388 result = wxDateSpan___rmul__(arg1,arg2);
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31393 return resultobj;
31394 fail:
31395 return NULL;
31396 }
31397
31398
31399 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31400 PyObject *resultobj = 0;
31401 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31402 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31403 bool result;
31404 void *argp1 = 0 ;
31405 int res1 = 0 ;
31406 void *argp2 = 0 ;
31407 int res2 = 0 ;
31408 PyObject * obj0 = 0 ;
31409 PyObject * obj1 = 0 ;
31410 char * kwnames[] = {
31411 (char *) "self",(char *) "other", NULL
31412 };
31413
31414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31416 if (!SWIG_IsOK(res1)) {
31417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31418 }
31419 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31421 if (!SWIG_IsOK(res2)) {
31422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31423 }
31424 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31425 {
31426 PyThreadState* __tstate = wxPyBeginAllowThreads();
31427 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31428 wxPyEndAllowThreads(__tstate);
31429 if (PyErr_Occurred()) SWIG_fail;
31430 }
31431 {
31432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31433 }
31434 return resultobj;
31435 fail:
31436 return NULL;
31437 }
31438
31439
31440 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31441 PyObject *resultobj = 0;
31442 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31443 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31444 bool result;
31445 void *argp1 = 0 ;
31446 int res1 = 0 ;
31447 void *argp2 = 0 ;
31448 int res2 = 0 ;
31449 PyObject * obj0 = 0 ;
31450 PyObject * obj1 = 0 ;
31451 char * kwnames[] = {
31452 (char *) "self",(char *) "other", NULL
31453 };
31454
31455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31457 if (!SWIG_IsOK(res1)) {
31458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31459 }
31460 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31461 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31462 if (!SWIG_IsOK(res2)) {
31463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31464 }
31465 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31466 {
31467 PyThreadState* __tstate = wxPyBeginAllowThreads();
31468 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31469 wxPyEndAllowThreads(__tstate);
31470 if (PyErr_Occurred()) SWIG_fail;
31471 }
31472 {
31473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31474 }
31475 return resultobj;
31476 fail:
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 PyObject *obj;
31483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31484 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31485 return SWIG_Py_Void();
31486 }
31487
31488 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31489 return SWIG_Python_InitShadowInstance(args);
31490 }
31491
31492 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31493 PyObject *resultobj = 0;
31494 long result;
31495
31496 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31497 {
31498 PyThreadState* __tstate = wxPyBeginAllowThreads();
31499 result = (long)wxGetLocalTime();
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 resultobj = SWIG_From_long(static_cast< long >(result));
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31511 PyObject *resultobj = 0;
31512 long result;
31513
31514 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 result = (long)wxGetUTCTime();
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 resultobj = SWIG_From_long(static_cast< long >(result));
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31529 PyObject *resultobj = 0;
31530 long result;
31531
31532 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31533 {
31534 PyThreadState* __tstate = wxPyBeginAllowThreads();
31535 result = (long)wxGetCurrentTime();
31536 wxPyEndAllowThreads(__tstate);
31537 if (PyErr_Occurred()) SWIG_fail;
31538 }
31539 resultobj = SWIG_From_long(static_cast< long >(result));
31540 return resultobj;
31541 fail:
31542 return NULL;
31543 }
31544
31545
31546 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31547 PyObject *resultobj = 0;
31548 wxLongLong result;
31549
31550 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31551 {
31552 PyThreadState* __tstate = wxPyBeginAllowThreads();
31553 result = wxGetLocalTimeMillis();
31554 wxPyEndAllowThreads(__tstate);
31555 if (PyErr_Occurred()) SWIG_fail;
31556 }
31557 {
31558 PyObject *hi, *lo, *shifter, *shifted;
31559 hi = PyLong_FromLong( (&result)->GetHi() );
31560 lo = PyLong_FromLong( (&result)->GetLo() );
31561 shifter = PyLong_FromLong(32);
31562 shifted = PyNumber_Lshift(hi, shifter);
31563 resultobj = PyNumber_Or(shifted, lo);
31564 Py_DECREF(hi);
31565 Py_DECREF(lo);
31566 Py_DECREF(shifter);
31567 Py_DECREF(shifted);
31568 }
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31576 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31577 return 1;
31578 }
31579
31580
31581 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31582 PyObject *pyobj = 0;
31583
31584 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31585 return pyobj;
31586 }
31587
31588
31589 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31590 PyObject *resultobj = 0;
31591 wxDataFormatId arg1 ;
31592 wxDataFormat *result = 0 ;
31593 int val1 ;
31594 int ecode1 = 0 ;
31595 PyObject * obj0 = 0 ;
31596 char * kwnames[] = {
31597 (char *) "type", NULL
31598 };
31599
31600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31601 ecode1 = SWIG_AsVal_int(obj0, &val1);
31602 if (!SWIG_IsOK(ecode1)) {
31603 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31604 }
31605 arg1 = static_cast< wxDataFormatId >(val1);
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 result = (wxDataFormat *)new wxDataFormat(arg1);
31609 wxPyEndAllowThreads(__tstate);
31610 if (PyErr_Occurred()) SWIG_fail;
31611 }
31612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31613 return resultobj;
31614 fail:
31615 return NULL;
31616 }
31617
31618
31619 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31620 PyObject *resultobj = 0;
31621 wxString *arg1 = 0 ;
31622 wxDataFormat *result = 0 ;
31623 bool temp1 = false ;
31624 PyObject * obj0 = 0 ;
31625 char * kwnames[] = {
31626 (char *) "format", NULL
31627 };
31628
31629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31630 {
31631 arg1 = wxString_in_helper(obj0);
31632 if (arg1 == NULL) SWIG_fail;
31633 temp1 = true;
31634 }
31635 {
31636 PyThreadState* __tstate = wxPyBeginAllowThreads();
31637 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31638 wxPyEndAllowThreads(__tstate);
31639 if (PyErr_Occurred()) SWIG_fail;
31640 }
31641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31642 {
31643 if (temp1)
31644 delete arg1;
31645 }
31646 return resultobj;
31647 fail:
31648 {
31649 if (temp1)
31650 delete arg1;
31651 }
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31657 PyObject *resultobj = 0;
31658 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31659 void *argp1 = 0 ;
31660 int res1 = 0 ;
31661 PyObject *swig_obj[1] ;
31662
31663 if (!args) SWIG_fail;
31664 swig_obj[0] = args;
31665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31666 if (!SWIG_IsOK(res1)) {
31667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31668 }
31669 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31670 {
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 delete arg1;
31673
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 resultobj = SWIG_Py_Void();
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31685 PyObject *resultobj = 0;
31686 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31687 wxDataFormatId arg2 ;
31688 bool result;
31689 void *argp1 = 0 ;
31690 int res1 = 0 ;
31691 int val2 ;
31692 int ecode2 = 0 ;
31693
31694 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31696 if (!SWIG_IsOK(res1)) {
31697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31698 }
31699 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31700 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31701 if (!SWIG_IsOK(ecode2)) {
31702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31703 }
31704 arg2 = static_cast< wxDataFormatId >(val2);
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31708 wxPyEndAllowThreads(__tstate);
31709 if (PyErr_Occurred()) SWIG_fail;
31710 }
31711 {
31712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31713 }
31714 return resultobj;
31715 fail:
31716 return NULL;
31717 }
31718
31719
31720 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31721 PyObject *resultobj = 0;
31722 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31723 wxDataFormatId arg2 ;
31724 bool result;
31725 void *argp1 = 0 ;
31726 int res1 = 0 ;
31727 int val2 ;
31728 int ecode2 = 0 ;
31729
31730 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31732 if (!SWIG_IsOK(res1)) {
31733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31734 }
31735 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31736 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31737 if (!SWIG_IsOK(ecode2)) {
31738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31739 }
31740 arg2 = static_cast< wxDataFormatId >(val2);
31741 {
31742 PyThreadState* __tstate = wxPyBeginAllowThreads();
31743 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31744 wxPyEndAllowThreads(__tstate);
31745 if (PyErr_Occurred()) SWIG_fail;
31746 }
31747 {
31748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31749 }
31750 return resultobj;
31751 fail:
31752 return NULL;
31753 }
31754
31755
31756 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31757 PyObject *resultobj = 0;
31758 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31759 wxDataFormat *arg2 = 0 ;
31760 bool result;
31761 void *argp1 = 0 ;
31762 int res1 = 0 ;
31763 void *argp2 = 0 ;
31764 int res2 = 0 ;
31765
31766 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31768 if (!SWIG_IsOK(res1)) {
31769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31770 }
31771 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31772 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31773 if (!SWIG_IsOK(res2)) {
31774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31775 }
31776 if (!argp2) {
31777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31778 }
31779 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31780 {
31781 PyThreadState* __tstate = wxPyBeginAllowThreads();
31782 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31783 wxPyEndAllowThreads(__tstate);
31784 if (PyErr_Occurred()) SWIG_fail;
31785 }
31786 {
31787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31788 }
31789 return resultobj;
31790 fail:
31791 return NULL;
31792 }
31793
31794
31795 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31796 int argc;
31797 PyObject *argv[3];
31798
31799 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31800 --argc;
31801 if (argc == 2) {
31802 int _v = 0;
31803 {
31804 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31805 _v = SWIG_CheckState(res);
31806 }
31807 if (!_v) goto check_1;
31808 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31809 }
31810 check_1:
31811
31812 if (argc == 2) {
31813 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31814 }
31815
31816 fail:
31817 Py_INCREF(Py_NotImplemented);
31818 return Py_NotImplemented;
31819 }
31820
31821
31822 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31823 PyObject *resultobj = 0;
31824 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31825 wxDataFormat *arg2 = 0 ;
31826 bool result;
31827 void *argp1 = 0 ;
31828 int res1 = 0 ;
31829 void *argp2 = 0 ;
31830 int res2 = 0 ;
31831
31832 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31836 }
31837 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31838 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31839 if (!SWIG_IsOK(res2)) {
31840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31841 }
31842 if (!argp2) {
31843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31844 }
31845 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31846 {
31847 PyThreadState* __tstate = wxPyBeginAllowThreads();
31848 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31849 wxPyEndAllowThreads(__tstate);
31850 if (PyErr_Occurred()) SWIG_fail;
31851 }
31852 {
31853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31854 }
31855 return resultobj;
31856 fail:
31857 return NULL;
31858 }
31859
31860
31861 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31862 int argc;
31863 PyObject *argv[3];
31864
31865 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31866 --argc;
31867 if (argc == 2) {
31868 int _v = 0;
31869 {
31870 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31871 _v = SWIG_CheckState(res);
31872 }
31873 if (!_v) goto check_1;
31874 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31875 }
31876 check_1:
31877
31878 if (argc == 2) {
31879 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31880 }
31881
31882 fail:
31883 Py_INCREF(Py_NotImplemented);
31884 return Py_NotImplemented;
31885 }
31886
31887
31888 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31889 PyObject *resultobj = 0;
31890 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31891 wxDataFormatId arg2 ;
31892 void *argp1 = 0 ;
31893 int res1 = 0 ;
31894 int val2 ;
31895 int ecode2 = 0 ;
31896 PyObject * obj0 = 0 ;
31897 PyObject * obj1 = 0 ;
31898 char * kwnames[] = {
31899 (char *) "self",(char *) "format", NULL
31900 };
31901
31902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31904 if (!SWIG_IsOK(res1)) {
31905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31906 }
31907 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31908 ecode2 = SWIG_AsVal_int(obj1, &val2);
31909 if (!SWIG_IsOK(ecode2)) {
31910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31911 }
31912 arg2 = static_cast< wxDataFormatId >(val2);
31913 {
31914 PyThreadState* __tstate = wxPyBeginAllowThreads();
31915 (arg1)->SetType(arg2);
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 resultobj = SWIG_Py_Void();
31920 return resultobj;
31921 fail:
31922 return NULL;
31923 }
31924
31925
31926 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31927 PyObject *resultobj = 0;
31928 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31929 wxDataFormatId result;
31930 void *argp1 = 0 ;
31931 int res1 = 0 ;
31932 PyObject *swig_obj[1] ;
31933
31934 if (!args) SWIG_fail;
31935 swig_obj[0] = args;
31936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31937 if (!SWIG_IsOK(res1)) {
31938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31939 }
31940 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_From_int(static_cast< int >(result));
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *_wrap_DataFormat__GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31955 PyObject *resultobj = 0;
31956 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31957 wxString result;
31958 void *argp1 = 0 ;
31959 int res1 = 0 ;
31960 PyObject *swig_obj[1] ;
31961
31962 if (!args) SWIG_fail;
31963 swig_obj[0] = args;
31964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31965 if (!SWIG_IsOK(res1)) {
31966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat__GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31967 }
31968 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 result = ((wxDataFormat const *)arg1)->GetId();
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 {
31976 #if wxUSE_UNICODE
31977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31978 #else
31979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31980 #endif
31981 }
31982 return resultobj;
31983 fail:
31984 return NULL;
31985 }
31986
31987
31988 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31989 PyObject *resultobj = 0;
31990 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31991 wxString *arg2 = 0 ;
31992 void *argp1 = 0 ;
31993 int res1 = 0 ;
31994 bool temp2 = false ;
31995 PyObject * obj0 = 0 ;
31996 PyObject * obj1 = 0 ;
31997 char * kwnames[] = {
31998 (char *) "self",(char *) "format", NULL
31999 };
32000
32001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
32002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
32003 if (!SWIG_IsOK(res1)) {
32004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
32005 }
32006 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32007 {
32008 arg2 = wxString_in_helper(obj1);
32009 if (arg2 == NULL) SWIG_fail;
32010 temp2 = true;
32011 }
32012 {
32013 PyThreadState* __tstate = wxPyBeginAllowThreads();
32014 (arg1)->SetId((wxString const &)*arg2);
32015 wxPyEndAllowThreads(__tstate);
32016 if (PyErr_Occurred()) SWIG_fail;
32017 }
32018 resultobj = SWIG_Py_Void();
32019 {
32020 if (temp2)
32021 delete arg2;
32022 }
32023 return resultobj;
32024 fail:
32025 {
32026 if (temp2)
32027 delete arg2;
32028 }
32029 return NULL;
32030 }
32031
32032
32033 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32034 PyObject *obj;
32035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32036 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32037 return SWIG_Py_Void();
32038 }
32039
32040 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32041 return SWIG_Python_InitShadowInstance(args);
32042 }
32043
32044 SWIGINTERN int FormatInvalid_set(PyObject *) {
32045 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32046 return 1;
32047 }
32048
32049
32050 SWIGINTERN PyObject *FormatInvalid_get(void) {
32051 PyObject *pyobj = 0;
32052
32053 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32054 return pyobj;
32055 }
32056
32057
32058 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32059 PyObject *resultobj = 0;
32060 wxDataObject *arg1 = (wxDataObject *) 0 ;
32061 void *argp1 = 0 ;
32062 int res1 = 0 ;
32063 PyObject *swig_obj[1] ;
32064
32065 if (!args) SWIG_fail;
32066 swig_obj[0] = args;
32067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32068 if (!SWIG_IsOK(res1)) {
32069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32070 }
32071 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 delete arg1;
32075
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 resultobj = SWIG_Py_Void();
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32087 PyObject *resultobj = 0;
32088 wxDataObject *arg1 = (wxDataObject *) 0 ;
32089 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32090 SwigValueWrapper<wxDataFormat > result;
32091 void *argp1 = 0 ;
32092 int res1 = 0 ;
32093 int val2 ;
32094 int ecode2 = 0 ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 char * kwnames[] = {
32098 (char *) "self",(char *) "dir", NULL
32099 };
32100
32101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32103 if (!SWIG_IsOK(res1)) {
32104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32105 }
32106 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32107 if (obj1) {
32108 ecode2 = SWIG_AsVal_int(obj1, &val2);
32109 if (!SWIG_IsOK(ecode2)) {
32110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32111 }
32112 arg2 = static_cast< wxDataObject::Direction >(val2);
32113 }
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32121 return resultobj;
32122 fail:
32123 return NULL;
32124 }
32125
32126
32127 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32128 PyObject *resultobj = 0;
32129 wxDataObject *arg1 = (wxDataObject *) 0 ;
32130 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32131 size_t result;
32132 void *argp1 = 0 ;
32133 int res1 = 0 ;
32134 int val2 ;
32135 int ecode2 = 0 ;
32136 PyObject * obj0 = 0 ;
32137 PyObject * obj1 = 0 ;
32138 char * kwnames[] = {
32139 (char *) "self",(char *) "dir", NULL
32140 };
32141
32142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32144 if (!SWIG_IsOK(res1)) {
32145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32146 }
32147 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32148 if (obj1) {
32149 ecode2 = SWIG_AsVal_int(obj1, &val2);
32150 if (!SWIG_IsOK(ecode2)) {
32151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32152 }
32153 arg2 = static_cast< wxDataObject::Direction >(val2);
32154 }
32155 {
32156 PyThreadState* __tstate = wxPyBeginAllowThreads();
32157 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32158 wxPyEndAllowThreads(__tstate);
32159 if (PyErr_Occurred()) SWIG_fail;
32160 }
32161 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32162 return resultobj;
32163 fail:
32164 return NULL;
32165 }
32166
32167
32168 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32169 PyObject *resultobj = 0;
32170 wxDataObject *arg1 = (wxDataObject *) 0 ;
32171 wxDataFormat *arg2 = 0 ;
32172 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32173 bool result;
32174 void *argp1 = 0 ;
32175 int res1 = 0 ;
32176 void *argp2 = 0 ;
32177 int res2 = 0 ;
32178 int val3 ;
32179 int ecode3 = 0 ;
32180 PyObject * obj0 = 0 ;
32181 PyObject * obj1 = 0 ;
32182 PyObject * obj2 = 0 ;
32183 char * kwnames[] = {
32184 (char *) "self",(char *) "format",(char *) "dir", NULL
32185 };
32186
32187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32189 if (!SWIG_IsOK(res1)) {
32190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32191 }
32192 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32193 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32194 if (!SWIG_IsOK(res2)) {
32195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32196 }
32197 if (!argp2) {
32198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32199 }
32200 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32201 if (obj2) {
32202 ecode3 = SWIG_AsVal_int(obj2, &val3);
32203 if (!SWIG_IsOK(ecode3)) {
32204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32205 }
32206 arg3 = static_cast< wxDataObject::Direction >(val3);
32207 }
32208 {
32209 PyThreadState* __tstate = wxPyBeginAllowThreads();
32210 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32211 wxPyEndAllowThreads(__tstate);
32212 if (PyErr_Occurred()) SWIG_fail;
32213 }
32214 {
32215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32216 }
32217 return resultobj;
32218 fail:
32219 return NULL;
32220 }
32221
32222
32223 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32224 PyObject *resultobj = 0;
32225 wxDataObject *arg1 = (wxDataObject *) 0 ;
32226 wxDataFormat *arg2 = 0 ;
32227 size_t result;
32228 void *argp1 = 0 ;
32229 int res1 = 0 ;
32230 void *argp2 = 0 ;
32231 int res2 = 0 ;
32232 PyObject * obj0 = 0 ;
32233 PyObject * obj1 = 0 ;
32234 char * kwnames[] = {
32235 (char *) "self",(char *) "format", NULL
32236 };
32237
32238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32240 if (!SWIG_IsOK(res1)) {
32241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32242 }
32243 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32245 if (!SWIG_IsOK(res2)) {
32246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32247 }
32248 if (!argp2) {
32249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32250 }
32251 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32252 {
32253 PyThreadState* __tstate = wxPyBeginAllowThreads();
32254 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32255 wxPyEndAllowThreads(__tstate);
32256 if (PyErr_Occurred()) SWIG_fail;
32257 }
32258 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32259 return resultobj;
32260 fail:
32261 return NULL;
32262 }
32263
32264
32265 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32266 PyObject *resultobj = 0;
32267 wxDataObject *arg1 = (wxDataObject *) 0 ;
32268 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32269 PyObject *result = 0 ;
32270 void *argp1 = 0 ;
32271 int res1 = 0 ;
32272 int val2 ;
32273 int ecode2 = 0 ;
32274 PyObject * obj0 = 0 ;
32275 PyObject * obj1 = 0 ;
32276 char * kwnames[] = {
32277 (char *) "self",(char *) "dir", NULL
32278 };
32279
32280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32282 if (!SWIG_IsOK(res1)) {
32283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32284 }
32285 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32286 if (obj1) {
32287 ecode2 = SWIG_AsVal_int(obj1, &val2);
32288 if (!SWIG_IsOK(ecode2)) {
32289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32290 }
32291 arg2 = static_cast< wxDataObject::Direction >(val2);
32292 }
32293 {
32294 PyThreadState* __tstate = wxPyBeginAllowThreads();
32295 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32296 wxPyEndAllowThreads(__tstate);
32297 if (PyErr_Occurred()) SWIG_fail;
32298 }
32299 resultobj = result;
32300 return resultobj;
32301 fail:
32302 return NULL;
32303 }
32304
32305
32306 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32307 PyObject *resultobj = 0;
32308 wxDataObject *arg1 = (wxDataObject *) 0 ;
32309 wxDataFormat *arg2 = 0 ;
32310 PyObject *result = 0 ;
32311 void *argp1 = 0 ;
32312 int res1 = 0 ;
32313 void *argp2 = 0 ;
32314 int res2 = 0 ;
32315 PyObject * obj0 = 0 ;
32316 PyObject * obj1 = 0 ;
32317 char * kwnames[] = {
32318 (char *) "self",(char *) "format", NULL
32319 };
32320
32321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32323 if (!SWIG_IsOK(res1)) {
32324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32325 }
32326 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32327 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32328 if (!SWIG_IsOK(res2)) {
32329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32330 }
32331 if (!argp2) {
32332 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32333 }
32334 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32335 {
32336 PyThreadState* __tstate = wxPyBeginAllowThreads();
32337 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32338 wxPyEndAllowThreads(__tstate);
32339 if (PyErr_Occurred()) SWIG_fail;
32340 }
32341 resultobj = result;
32342 return resultobj;
32343 fail:
32344 return NULL;
32345 }
32346
32347
32348 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32349 PyObject *resultobj = 0;
32350 wxDataObject *arg1 = (wxDataObject *) 0 ;
32351 wxDataFormat *arg2 = 0 ;
32352 PyObject *arg3 = (PyObject *) 0 ;
32353 bool result;
32354 void *argp1 = 0 ;
32355 int res1 = 0 ;
32356 void *argp2 = 0 ;
32357 int res2 = 0 ;
32358 PyObject * obj0 = 0 ;
32359 PyObject * obj1 = 0 ;
32360 PyObject * obj2 = 0 ;
32361 char * kwnames[] = {
32362 (char *) "self",(char *) "format",(char *) "data", NULL
32363 };
32364
32365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32367 if (!SWIG_IsOK(res1)) {
32368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32369 }
32370 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32371 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32372 if (!SWIG_IsOK(res2)) {
32373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32374 }
32375 if (!argp2) {
32376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32377 }
32378 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32379 arg3 = obj2;
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 {
32387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32388 }
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *obj;
32397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32398 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32399 return SWIG_Py_Void();
32400 }
32401
32402 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32403 PyObject *resultobj = 0;
32404 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32405 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32406 wxDataObjectSimple *result = 0 ;
32407 void *argp1 = 0 ;
32408 int res1 = 0 ;
32409 PyObject * obj0 = 0 ;
32410 char * kwnames[] = {
32411 (char *) "format", NULL
32412 };
32413
32414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32415 if (obj0) {
32416 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32417 if (!SWIG_IsOK(res1)) {
32418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32419 }
32420 if (!argp1) {
32421 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32422 }
32423 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32424 }
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32428 wxPyEndAllowThreads(__tstate);
32429 if (PyErr_Occurred()) SWIG_fail;
32430 }
32431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32432 return resultobj;
32433 fail:
32434 return NULL;
32435 }
32436
32437
32438 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32439 PyObject *resultobj = 0;
32440 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32441 wxDataFormat *result = 0 ;
32442 void *argp1 = 0 ;
32443 int res1 = 0 ;
32444 PyObject *swig_obj[1] ;
32445
32446 if (!args) SWIG_fail;
32447 swig_obj[0] = args;
32448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32449 if (!SWIG_IsOK(res1)) {
32450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32451 }
32452 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32453 {
32454 PyThreadState* __tstate = wxPyBeginAllowThreads();
32455 {
32456 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32457 result = (wxDataFormat *) &_result_ref;
32458 }
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = 0;
32471 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32472 wxDataFormat *arg2 = 0 ;
32473 void *argp1 = 0 ;
32474 int res1 = 0 ;
32475 void *argp2 = 0 ;
32476 int res2 = 0 ;
32477 PyObject * obj0 = 0 ;
32478 PyObject * obj1 = 0 ;
32479 char * kwnames[] = {
32480 (char *) "self",(char *) "format", NULL
32481 };
32482
32483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32485 if (!SWIG_IsOK(res1)) {
32486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32487 }
32488 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32489 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32490 if (!SWIG_IsOK(res2)) {
32491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32492 }
32493 if (!argp2) {
32494 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32495 }
32496 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32497 {
32498 PyThreadState* __tstate = wxPyBeginAllowThreads();
32499 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32500 wxPyEndAllowThreads(__tstate);
32501 if (PyErr_Occurred()) SWIG_fail;
32502 }
32503 resultobj = SWIG_Py_Void();
32504 return resultobj;
32505 fail:
32506 return NULL;
32507 }
32508
32509
32510 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32511 PyObject *resultobj = 0;
32512 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32513 size_t result;
32514 void *argp1 = 0 ;
32515 int res1 = 0 ;
32516 PyObject *swig_obj[1] ;
32517
32518 if (!args) SWIG_fail;
32519 swig_obj[0] = args;
32520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32521 if (!SWIG_IsOK(res1)) {
32522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32523 }
32524 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32525 {
32526 PyThreadState* __tstate = wxPyBeginAllowThreads();
32527 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32528 wxPyEndAllowThreads(__tstate);
32529 if (PyErr_Occurred()) SWIG_fail;
32530 }
32531 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32532 return resultobj;
32533 fail:
32534 return NULL;
32535 }
32536
32537
32538 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32539 PyObject *resultobj = 0;
32540 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32541 PyObject *result = 0 ;
32542 void *argp1 = 0 ;
32543 int res1 = 0 ;
32544 PyObject *swig_obj[1] ;
32545
32546 if (!args) SWIG_fail;
32547 swig_obj[0] = args;
32548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32549 if (!SWIG_IsOK(res1)) {
32550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32551 }
32552 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32553 {
32554 PyThreadState* __tstate = wxPyBeginAllowThreads();
32555 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32556 wxPyEndAllowThreads(__tstate);
32557 if (PyErr_Occurred()) SWIG_fail;
32558 }
32559 resultobj = result;
32560 return resultobj;
32561 fail:
32562 return NULL;
32563 }
32564
32565
32566 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32567 PyObject *resultobj = 0;
32568 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32569 PyObject *arg2 = (PyObject *) 0 ;
32570 bool result;
32571 void *argp1 = 0 ;
32572 int res1 = 0 ;
32573 PyObject * obj0 = 0 ;
32574 PyObject * obj1 = 0 ;
32575 char * kwnames[] = {
32576 (char *) "self",(char *) "data", NULL
32577 };
32578
32579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32581 if (!SWIG_IsOK(res1)) {
32582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32583 }
32584 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32585 arg2 = obj1;
32586 {
32587 PyThreadState* __tstate = wxPyBeginAllowThreads();
32588 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32589 wxPyEndAllowThreads(__tstate);
32590 if (PyErr_Occurred()) SWIG_fail;
32591 }
32592 {
32593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32594 }
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32602 PyObject *obj;
32603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32604 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32605 return SWIG_Py_Void();
32606 }
32607
32608 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32609 return SWIG_Python_InitShadowInstance(args);
32610 }
32611
32612 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32613 PyObject *resultobj = 0;
32614 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32615 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32616 wxPyDataObjectSimple *result = 0 ;
32617 void *argp1 = 0 ;
32618 int res1 = 0 ;
32619 PyObject * obj0 = 0 ;
32620 char * kwnames[] = {
32621 (char *) "format", NULL
32622 };
32623
32624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32625 if (obj0) {
32626 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32627 if (!SWIG_IsOK(res1)) {
32628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32629 }
32630 if (!argp1) {
32631 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32632 }
32633 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32634 }
32635 {
32636 PyThreadState* __tstate = wxPyBeginAllowThreads();
32637 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32638 wxPyEndAllowThreads(__tstate);
32639 if (PyErr_Occurred()) SWIG_fail;
32640 }
32641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32642 return resultobj;
32643 fail:
32644 return NULL;
32645 }
32646
32647
32648 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32649 PyObject *resultobj = 0;
32650 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32651 PyObject *arg2 = (PyObject *) 0 ;
32652 PyObject *arg3 = (PyObject *) 0 ;
32653 void *argp1 = 0 ;
32654 int res1 = 0 ;
32655 PyObject * obj0 = 0 ;
32656 PyObject * obj1 = 0 ;
32657 PyObject * obj2 = 0 ;
32658 char * kwnames[] = {
32659 (char *) "self",(char *) "self",(char *) "_class", NULL
32660 };
32661
32662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32664 if (!SWIG_IsOK(res1)) {
32665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32666 }
32667 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32668 arg2 = obj1;
32669 arg3 = obj2;
32670 {
32671 PyThreadState* __tstate = wxPyBeginAllowThreads();
32672 (arg1)->_setCallbackInfo(arg2,arg3);
32673 wxPyEndAllowThreads(__tstate);
32674 if (PyErr_Occurred()) SWIG_fail;
32675 }
32676 resultobj = SWIG_Py_Void();
32677 return resultobj;
32678 fail:
32679 return NULL;
32680 }
32681
32682
32683 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32684 PyObject *obj;
32685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32686 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32687 return SWIG_Py_Void();
32688 }
32689
32690 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32691 return SWIG_Python_InitShadowInstance(args);
32692 }
32693
32694 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32695 PyObject *resultobj = 0;
32696 wxDataObjectComposite *result = 0 ;
32697
32698 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32713 PyObject *resultobj = 0;
32714 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32715 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32716 bool arg3 = (bool) false ;
32717 void *argp1 = 0 ;
32718 int res1 = 0 ;
32719 int res2 = 0 ;
32720 bool val3 ;
32721 int ecode3 = 0 ;
32722 PyObject * obj0 = 0 ;
32723 PyObject * obj1 = 0 ;
32724 PyObject * obj2 = 0 ;
32725 char * kwnames[] = {
32726 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32727 };
32728
32729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32731 if (!SWIG_IsOK(res1)) {
32732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32733 }
32734 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32735 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32736 if (!SWIG_IsOK(res2)) {
32737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32738 }
32739 if (obj2) {
32740 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32741 if (!SWIG_IsOK(ecode3)) {
32742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32743 }
32744 arg3 = static_cast< bool >(val3);
32745 }
32746 {
32747 PyThreadState* __tstate = wxPyBeginAllowThreads();
32748 (arg1)->Add(arg2,arg3);
32749 wxPyEndAllowThreads(__tstate);
32750 if (PyErr_Occurred()) SWIG_fail;
32751 }
32752 resultobj = SWIG_Py_Void();
32753 return resultobj;
32754 fail:
32755 return NULL;
32756 }
32757
32758
32759 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32760 PyObject *resultobj = 0;
32761 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32762 SwigValueWrapper<wxDataFormat > result;
32763 void *argp1 = 0 ;
32764 int res1 = 0 ;
32765 PyObject *swig_obj[1] ;
32766
32767 if (!args) SWIG_fail;
32768 swig_obj[0] = args;
32769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32770 if (!SWIG_IsOK(res1)) {
32771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32772 }
32773 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32774 {
32775 PyThreadState* __tstate = wxPyBeginAllowThreads();
32776 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32777 wxPyEndAllowThreads(__tstate);
32778 if (PyErr_Occurred()) SWIG_fail;
32779 }
32780 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32781 return resultobj;
32782 fail:
32783 return NULL;
32784 }
32785
32786
32787 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32788 PyObject *obj;
32789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32790 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32791 return SWIG_Py_Void();
32792 }
32793
32794 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32795 return SWIG_Python_InitShadowInstance(args);
32796 }
32797
32798 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32799 PyObject *resultobj = 0;
32800 wxString const &arg1_defvalue = wxPyEmptyString ;
32801 wxString *arg1 = (wxString *) &arg1_defvalue ;
32802 wxTextDataObject *result = 0 ;
32803 bool temp1 = false ;
32804 PyObject * obj0 = 0 ;
32805 char * kwnames[] = {
32806 (char *) "text", NULL
32807 };
32808
32809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32810 if (obj0) {
32811 {
32812 arg1 = wxString_in_helper(obj0);
32813 if (arg1 == NULL) SWIG_fail;
32814 temp1 = true;
32815 }
32816 }
32817 {
32818 PyThreadState* __tstate = wxPyBeginAllowThreads();
32819 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32820 wxPyEndAllowThreads(__tstate);
32821 if (PyErr_Occurred()) SWIG_fail;
32822 }
32823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32824 {
32825 if (temp1)
32826 delete arg1;
32827 }
32828 return resultobj;
32829 fail:
32830 {
32831 if (temp1)
32832 delete arg1;
32833 }
32834 return NULL;
32835 }
32836
32837
32838 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32839 PyObject *resultobj = 0;
32840 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32841 size_t result;
32842 void *argp1 = 0 ;
32843 int res1 = 0 ;
32844 PyObject *swig_obj[1] ;
32845
32846 if (!args) SWIG_fail;
32847 swig_obj[0] = args;
32848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32849 if (!SWIG_IsOK(res1)) {
32850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32851 }
32852 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32853 {
32854 PyThreadState* __tstate = wxPyBeginAllowThreads();
32855 result = (size_t)(arg1)->GetTextLength();
32856 wxPyEndAllowThreads(__tstate);
32857 if (PyErr_Occurred()) SWIG_fail;
32858 }
32859 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32860 return resultobj;
32861 fail:
32862 return NULL;
32863 }
32864
32865
32866 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32867 PyObject *resultobj = 0;
32868 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32869 wxString result;
32870 void *argp1 = 0 ;
32871 int res1 = 0 ;
32872 PyObject *swig_obj[1] ;
32873
32874 if (!args) SWIG_fail;
32875 swig_obj[0] = args;
32876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32877 if (!SWIG_IsOK(res1)) {
32878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32879 }
32880 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32881 {
32882 PyThreadState* __tstate = wxPyBeginAllowThreads();
32883 result = (arg1)->GetText();
32884 wxPyEndAllowThreads(__tstate);
32885 if (PyErr_Occurred()) SWIG_fail;
32886 }
32887 {
32888 #if wxUSE_UNICODE
32889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32890 #else
32891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32892 #endif
32893 }
32894 return resultobj;
32895 fail:
32896 return NULL;
32897 }
32898
32899
32900 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32901 PyObject *resultobj = 0;
32902 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32903 wxString *arg2 = 0 ;
32904 void *argp1 = 0 ;
32905 int res1 = 0 ;
32906 bool temp2 = false ;
32907 PyObject * obj0 = 0 ;
32908 PyObject * obj1 = 0 ;
32909 char * kwnames[] = {
32910 (char *) "self",(char *) "text", NULL
32911 };
32912
32913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32917 }
32918 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32919 {
32920 arg2 = wxString_in_helper(obj1);
32921 if (arg2 == NULL) SWIG_fail;
32922 temp2 = true;
32923 }
32924 {
32925 PyThreadState* __tstate = wxPyBeginAllowThreads();
32926 (arg1)->SetText((wxString const &)*arg2);
32927 wxPyEndAllowThreads(__tstate);
32928 if (PyErr_Occurred()) SWIG_fail;
32929 }
32930 resultobj = SWIG_Py_Void();
32931 {
32932 if (temp2)
32933 delete arg2;
32934 }
32935 return resultobj;
32936 fail:
32937 {
32938 if (temp2)
32939 delete arg2;
32940 }
32941 return NULL;
32942 }
32943
32944
32945 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32946 PyObject *obj;
32947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32948 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32949 return SWIG_Py_Void();
32950 }
32951
32952 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32953 return SWIG_Python_InitShadowInstance(args);
32954 }
32955
32956 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32957 PyObject *resultobj = 0;
32958 wxString const &arg1_defvalue = wxPyEmptyString ;
32959 wxString *arg1 = (wxString *) &arg1_defvalue ;
32960 wxPyTextDataObject *result = 0 ;
32961 bool temp1 = false ;
32962 PyObject * obj0 = 0 ;
32963 char * kwnames[] = {
32964 (char *) "text", NULL
32965 };
32966
32967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32968 if (obj0) {
32969 {
32970 arg1 = wxString_in_helper(obj0);
32971 if (arg1 == NULL) SWIG_fail;
32972 temp1 = true;
32973 }
32974 }
32975 {
32976 PyThreadState* __tstate = wxPyBeginAllowThreads();
32977 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32978 wxPyEndAllowThreads(__tstate);
32979 if (PyErr_Occurred()) SWIG_fail;
32980 }
32981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32982 {
32983 if (temp1)
32984 delete arg1;
32985 }
32986 return resultobj;
32987 fail:
32988 {
32989 if (temp1)
32990 delete arg1;
32991 }
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32999 PyObject *arg2 = (PyObject *) 0 ;
33000 PyObject *arg3 = (PyObject *) 0 ;
33001 void *argp1 = 0 ;
33002 int res1 = 0 ;
33003 PyObject * obj0 = 0 ;
33004 PyObject * obj1 = 0 ;
33005 PyObject * obj2 = 0 ;
33006 char * kwnames[] = {
33007 (char *) "self",(char *) "self",(char *) "_class", NULL
33008 };
33009
33010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
33014 }
33015 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
33016 arg2 = obj1;
33017 arg3 = obj2;
33018 {
33019 PyThreadState* __tstate = wxPyBeginAllowThreads();
33020 (arg1)->_setCallbackInfo(arg2,arg3);
33021 wxPyEndAllowThreads(__tstate);
33022 if (PyErr_Occurred()) SWIG_fail;
33023 }
33024 resultobj = SWIG_Py_Void();
33025 return resultobj;
33026 fail:
33027 return NULL;
33028 }
33029
33030
33031 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33032 PyObject *obj;
33033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33034 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
33035 return SWIG_Py_Void();
33036 }
33037
33038 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33039 return SWIG_Python_InitShadowInstance(args);
33040 }
33041
33042 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33043 PyObject *resultobj = 0;
33044 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33045 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33046 wxBitmapDataObject *result = 0 ;
33047 void *argp1 = 0 ;
33048 int res1 = 0 ;
33049 PyObject * obj0 = 0 ;
33050 char * kwnames[] = {
33051 (char *) "bitmap", NULL
33052 };
33053
33054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33055 if (obj0) {
33056 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33057 if (!SWIG_IsOK(res1)) {
33058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33059 }
33060 if (!argp1) {
33061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33062 }
33063 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33064 }
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33068 wxPyEndAllowThreads(__tstate);
33069 if (PyErr_Occurred()) SWIG_fail;
33070 }
33071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33072 return resultobj;
33073 fail:
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33079 PyObject *resultobj = 0;
33080 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33081 wxBitmap result;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 PyObject *swig_obj[1] ;
33085
33086 if (!args) SWIG_fail;
33087 swig_obj[0] = args;
33088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33089 if (!SWIG_IsOK(res1)) {
33090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33091 }
33092 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33093 {
33094 PyThreadState* __tstate = wxPyBeginAllowThreads();
33095 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33096 wxPyEndAllowThreads(__tstate);
33097 if (PyErr_Occurred()) SWIG_fail;
33098 }
33099 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33100 return resultobj;
33101 fail:
33102 return NULL;
33103 }
33104
33105
33106 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33107 PyObject *resultobj = 0;
33108 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33109 wxBitmap *arg2 = 0 ;
33110 void *argp1 = 0 ;
33111 int res1 = 0 ;
33112 void *argp2 = 0 ;
33113 int res2 = 0 ;
33114 PyObject * obj0 = 0 ;
33115 PyObject * obj1 = 0 ;
33116 char * kwnames[] = {
33117 (char *) "self",(char *) "bitmap", NULL
33118 };
33119
33120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33122 if (!SWIG_IsOK(res1)) {
33123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33124 }
33125 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33126 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33127 if (!SWIG_IsOK(res2)) {
33128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33129 }
33130 if (!argp2) {
33131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33132 }
33133 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_Py_Void();
33141 return resultobj;
33142 fail:
33143 return NULL;
33144 }
33145
33146
33147 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33148 PyObject *obj;
33149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33150 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33151 return SWIG_Py_Void();
33152 }
33153
33154 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33155 return SWIG_Python_InitShadowInstance(args);
33156 }
33157
33158 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33159 PyObject *resultobj = 0;
33160 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33161 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33162 wxPyBitmapDataObject *result = 0 ;
33163 void *argp1 = 0 ;
33164 int res1 = 0 ;
33165 PyObject * obj0 = 0 ;
33166 char * kwnames[] = {
33167 (char *) "bitmap", NULL
33168 };
33169
33170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33171 if (obj0) {
33172 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33173 if (!SWIG_IsOK(res1)) {
33174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33175 }
33176 if (!argp1) {
33177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33178 }
33179 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33180 }
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33188 return resultobj;
33189 fail:
33190 return NULL;
33191 }
33192
33193
33194 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33195 PyObject *resultobj = 0;
33196 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33197 PyObject *arg2 = (PyObject *) 0 ;
33198 PyObject *arg3 = (PyObject *) 0 ;
33199 void *argp1 = 0 ;
33200 int res1 = 0 ;
33201 PyObject * obj0 = 0 ;
33202 PyObject * obj1 = 0 ;
33203 PyObject * obj2 = 0 ;
33204 char * kwnames[] = {
33205 (char *) "self",(char *) "self",(char *) "_class", NULL
33206 };
33207
33208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33210 if (!SWIG_IsOK(res1)) {
33211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33212 }
33213 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33214 arg2 = obj1;
33215 arg3 = obj2;
33216 {
33217 PyThreadState* __tstate = wxPyBeginAllowThreads();
33218 (arg1)->_setCallbackInfo(arg2,arg3);
33219 wxPyEndAllowThreads(__tstate);
33220 if (PyErr_Occurred()) SWIG_fail;
33221 }
33222 resultobj = SWIG_Py_Void();
33223 return resultobj;
33224 fail:
33225 return NULL;
33226 }
33227
33228
33229 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33230 PyObject *obj;
33231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33232 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33233 return SWIG_Py_Void();
33234 }
33235
33236 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33237 return SWIG_Python_InitShadowInstance(args);
33238 }
33239
33240 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33241 PyObject *resultobj = 0;
33242 wxFileDataObject *result = 0 ;
33243
33244 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33245 {
33246 PyThreadState* __tstate = wxPyBeginAllowThreads();
33247 result = (wxFileDataObject *)new wxFileDataObject();
33248 wxPyEndAllowThreads(__tstate);
33249 if (PyErr_Occurred()) SWIG_fail;
33250 }
33251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33252 return resultobj;
33253 fail:
33254 return NULL;
33255 }
33256
33257
33258 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33259 PyObject *resultobj = 0;
33260 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33261 wxArrayString *result = 0 ;
33262 void *argp1 = 0 ;
33263 int res1 = 0 ;
33264 PyObject *swig_obj[1] ;
33265
33266 if (!args) SWIG_fail;
33267 swig_obj[0] = args;
33268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33269 if (!SWIG_IsOK(res1)) {
33270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33271 }
33272 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33273 {
33274 PyThreadState* __tstate = wxPyBeginAllowThreads();
33275 {
33276 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33277 result = (wxArrayString *) &_result_ref;
33278 }
33279 wxPyEndAllowThreads(__tstate);
33280 if (PyErr_Occurred()) SWIG_fail;
33281 }
33282 {
33283 resultobj = wxArrayString2PyList_helper(*result);
33284 }
33285 return resultobj;
33286 fail:
33287 return NULL;
33288 }
33289
33290
33291 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33292 PyObject *resultobj = 0;
33293 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33294 wxString *arg2 = 0 ;
33295 void *argp1 = 0 ;
33296 int res1 = 0 ;
33297 bool temp2 = false ;
33298 PyObject * obj0 = 0 ;
33299 PyObject * obj1 = 0 ;
33300 char * kwnames[] = {
33301 (char *) "self",(char *) "filename", NULL
33302 };
33303
33304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33306 if (!SWIG_IsOK(res1)) {
33307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33308 }
33309 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33310 {
33311 arg2 = wxString_in_helper(obj1);
33312 if (arg2 == NULL) SWIG_fail;
33313 temp2 = true;
33314 }
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 (arg1)->AddFile((wxString const &)*arg2);
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 resultobj = SWIG_Py_Void();
33322 {
33323 if (temp2)
33324 delete arg2;
33325 }
33326 return resultobj;
33327 fail:
33328 {
33329 if (temp2)
33330 delete arg2;
33331 }
33332 return NULL;
33333 }
33334
33335
33336 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33337 PyObject *obj;
33338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33339 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33340 return SWIG_Py_Void();
33341 }
33342
33343 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33344 return SWIG_Python_InitShadowInstance(args);
33345 }
33346
33347 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33348 PyObject *resultobj = 0;
33349 wxDataFormat *arg1 = 0 ;
33350 wxCustomDataObject *result = 0 ;
33351 void *argp1 = 0 ;
33352 int res1 = 0 ;
33353
33354 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33356 if (!SWIG_IsOK(res1)) {
33357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33358 }
33359 if (!argp1) {
33360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33361 }
33362 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33363 {
33364 PyThreadState* __tstate = wxPyBeginAllowThreads();
33365 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33366 wxPyEndAllowThreads(__tstate);
33367 if (PyErr_Occurred()) SWIG_fail;
33368 }
33369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33370 return resultobj;
33371 fail:
33372 return NULL;
33373 }
33374
33375
33376 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33377 PyObject *resultobj = 0;
33378 wxString *arg1 = 0 ;
33379 wxCustomDataObject *result = 0 ;
33380 bool temp1 = false ;
33381
33382 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33383 {
33384 arg1 = wxString_in_helper(swig_obj[0]);
33385 if (arg1 == NULL) SWIG_fail;
33386 temp1 = true;
33387 }
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33395 {
33396 if (temp1)
33397 delete arg1;
33398 }
33399 return resultobj;
33400 fail:
33401 {
33402 if (temp1)
33403 delete arg1;
33404 }
33405 return NULL;
33406 }
33407
33408
33409 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33410 PyObject *resultobj = 0;
33411 wxCustomDataObject *result = 0 ;
33412
33413 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33414 {
33415 PyThreadState* __tstate = wxPyBeginAllowThreads();
33416 result = (wxCustomDataObject *)new wxCustomDataObject();
33417 wxPyEndAllowThreads(__tstate);
33418 if (PyErr_Occurred()) SWIG_fail;
33419 }
33420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33421 return resultobj;
33422 fail:
33423 return NULL;
33424 }
33425
33426
33427 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33428 int argc;
33429 PyObject *argv[2];
33430
33431 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33432 --argc;
33433 if (argc == 0) {
33434 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33435 }
33436 if (argc == 1) {
33437 int _v = 0;
33438 {
33439 {
33440 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33441 }
33442 }
33443 if (!_v) goto check_2;
33444 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33445 }
33446 check_2:
33447
33448 if (argc == 1) {
33449 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33450 }
33451
33452 fail:
33453 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33454 return NULL;
33455 }
33456
33457
33458 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33459 PyObject *resultobj = 0;
33460 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33461 PyObject *arg2 = (PyObject *) 0 ;
33462 bool result;
33463 void *argp1 = 0 ;
33464 int res1 = 0 ;
33465 PyObject * obj0 = 0 ;
33466 PyObject * obj1 = 0 ;
33467 char * kwnames[] = {
33468 (char *) "self",(char *) "data", NULL
33469 };
33470
33471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33473 if (!SWIG_IsOK(res1)) {
33474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33475 }
33476 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33477 arg2 = obj1;
33478 {
33479 PyThreadState* __tstate = wxPyBeginAllowThreads();
33480 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33481 wxPyEndAllowThreads(__tstate);
33482 if (PyErr_Occurred()) SWIG_fail;
33483 }
33484 {
33485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33486 }
33487 return resultobj;
33488 fail:
33489 return NULL;
33490 }
33491
33492
33493 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33494 PyObject *resultobj = 0;
33495 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33496 size_t result;
33497 void *argp1 = 0 ;
33498 int res1 = 0 ;
33499 PyObject *swig_obj[1] ;
33500
33501 if (!args) SWIG_fail;
33502 swig_obj[0] = args;
33503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33504 if (!SWIG_IsOK(res1)) {
33505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33506 }
33507 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 result = (size_t)(arg1)->GetSize();
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33515 return resultobj;
33516 fail:
33517 return NULL;
33518 }
33519
33520
33521 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33522 PyObject *resultobj = 0;
33523 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33524 PyObject *result = 0 ;
33525 void *argp1 = 0 ;
33526 int res1 = 0 ;
33527 PyObject *swig_obj[1] ;
33528
33529 if (!args) SWIG_fail;
33530 swig_obj[0] = args;
33531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33532 if (!SWIG_IsOK(res1)) {
33533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33534 }
33535 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33536 {
33537 PyThreadState* __tstate = wxPyBeginAllowThreads();
33538 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33539 wxPyEndAllowThreads(__tstate);
33540 if (PyErr_Occurred()) SWIG_fail;
33541 }
33542 resultobj = result;
33543 return resultobj;
33544 fail:
33545 return NULL;
33546 }
33547
33548
33549 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33550 PyObject *obj;
33551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33552 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33553 return SWIG_Py_Void();
33554 }
33555
33556 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33557 return SWIG_Python_InitShadowInstance(args);
33558 }
33559
33560 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33561 PyObject *resultobj = 0;
33562 wxString const &arg1_defvalue = wxPyEmptyString ;
33563 wxString *arg1 = (wxString *) &arg1_defvalue ;
33564 wxURLDataObject *result = 0 ;
33565 bool temp1 = false ;
33566 PyObject * obj0 = 0 ;
33567 char * kwnames[] = {
33568 (char *) "url", NULL
33569 };
33570
33571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33572 if (obj0) {
33573 {
33574 arg1 = wxString_in_helper(obj0);
33575 if (arg1 == NULL) SWIG_fail;
33576 temp1 = true;
33577 }
33578 }
33579 {
33580 PyThreadState* __tstate = wxPyBeginAllowThreads();
33581 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33582 wxPyEndAllowThreads(__tstate);
33583 if (PyErr_Occurred()) SWIG_fail;
33584 }
33585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33586 {
33587 if (temp1)
33588 delete arg1;
33589 }
33590 return resultobj;
33591 fail:
33592 {
33593 if (temp1)
33594 delete arg1;
33595 }
33596 return NULL;
33597 }
33598
33599
33600 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33601 PyObject *resultobj = 0;
33602 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33603 wxString result;
33604 void *argp1 = 0 ;
33605 int res1 = 0 ;
33606 PyObject *swig_obj[1] ;
33607
33608 if (!args) SWIG_fail;
33609 swig_obj[0] = args;
33610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33611 if (!SWIG_IsOK(res1)) {
33612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33613 }
33614 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33615 {
33616 PyThreadState* __tstate = wxPyBeginAllowThreads();
33617 result = (arg1)->GetURL();
33618 wxPyEndAllowThreads(__tstate);
33619 if (PyErr_Occurred()) SWIG_fail;
33620 }
33621 {
33622 #if wxUSE_UNICODE
33623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33624 #else
33625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33626 #endif
33627 }
33628 return resultobj;
33629 fail:
33630 return NULL;
33631 }
33632
33633
33634 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33635 PyObject *resultobj = 0;
33636 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33637 wxString *arg2 = 0 ;
33638 void *argp1 = 0 ;
33639 int res1 = 0 ;
33640 bool temp2 = false ;
33641 PyObject * obj0 = 0 ;
33642 PyObject * obj1 = 0 ;
33643 char * kwnames[] = {
33644 (char *) "self",(char *) "url", NULL
33645 };
33646
33647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33649 if (!SWIG_IsOK(res1)) {
33650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33651 }
33652 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33653 {
33654 arg2 = wxString_in_helper(obj1);
33655 if (arg2 == NULL) SWIG_fail;
33656 temp2 = true;
33657 }
33658 {
33659 PyThreadState* __tstate = wxPyBeginAllowThreads();
33660 (arg1)->SetURL((wxString const &)*arg2);
33661 wxPyEndAllowThreads(__tstate);
33662 if (PyErr_Occurred()) SWIG_fail;
33663 }
33664 resultobj = SWIG_Py_Void();
33665 {
33666 if (temp2)
33667 delete arg2;
33668 }
33669 return resultobj;
33670 fail:
33671 {
33672 if (temp2)
33673 delete arg2;
33674 }
33675 return NULL;
33676 }
33677
33678
33679 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33680 PyObject *obj;
33681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33682 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33683 return SWIG_Py_Void();
33684 }
33685
33686 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33687 return SWIG_Python_InitShadowInstance(args);
33688 }
33689
33690 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33691 PyObject *resultobj = 0;
33692 wxMetafileDataObject *result = 0 ;
33693
33694 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33695 {
33696 PyThreadState* __tstate = wxPyBeginAllowThreads();
33697 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33698 wxPyEndAllowThreads(__tstate);
33699 if (PyErr_Occurred()) SWIG_fail;
33700 }
33701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33702 return resultobj;
33703 fail:
33704 return NULL;
33705 }
33706
33707
33708 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33709 PyObject *obj;
33710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33711 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33712 return SWIG_Py_Void();
33713 }
33714
33715 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33716 return SWIG_Python_InitShadowInstance(args);
33717 }
33718
33719 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33720 PyObject *resultobj = 0;
33721 wxDragResult arg1 ;
33722 bool result;
33723 int val1 ;
33724 int ecode1 = 0 ;
33725 PyObject * obj0 = 0 ;
33726 char * kwnames[] = {
33727 (char *) "res", NULL
33728 };
33729
33730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33731 ecode1 = SWIG_AsVal_int(obj0, &val1);
33732 if (!SWIG_IsOK(ecode1)) {
33733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33734 }
33735 arg1 = static_cast< wxDragResult >(val1);
33736 {
33737 PyThreadState* __tstate = wxPyBeginAllowThreads();
33738 result = (bool)wxIsDragResultOk(arg1);
33739 wxPyEndAllowThreads(__tstate);
33740 if (PyErr_Occurred()) SWIG_fail;
33741 }
33742 {
33743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33744 }
33745 return resultobj;
33746 fail:
33747 return NULL;
33748 }
33749
33750
33751 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33752 PyObject *resultobj = 0;
33753 wxWindow *arg1 = (wxWindow *) 0 ;
33754 wxIcon const &arg2_defvalue = wxNullIcon ;
33755 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33756 wxIcon const &arg3_defvalue = wxNullIcon ;
33757 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33758 wxIcon const &arg4_defvalue = wxNullIcon ;
33759 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33760 wxPyDropSource *result = 0 ;
33761 void *argp1 = 0 ;
33762 int res1 = 0 ;
33763 void *argp2 = 0 ;
33764 int res2 = 0 ;
33765 void *argp3 = 0 ;
33766 int res3 = 0 ;
33767 void *argp4 = 0 ;
33768 int res4 = 0 ;
33769 PyObject * obj0 = 0 ;
33770 PyObject * obj1 = 0 ;
33771 PyObject * obj2 = 0 ;
33772 PyObject * obj3 = 0 ;
33773 char * kwnames[] = {
33774 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33775 };
33776
33777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33779 if (!SWIG_IsOK(res1)) {
33780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33781 }
33782 arg1 = reinterpret_cast< wxWindow * >(argp1);
33783 if (obj1) {
33784 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33785 if (!SWIG_IsOK(res2)) {
33786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33787 }
33788 if (!argp2) {
33789 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33790 }
33791 arg2 = reinterpret_cast< wxIcon * >(argp2);
33792 }
33793 if (obj2) {
33794 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33795 if (!SWIG_IsOK(res3)) {
33796 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33797 }
33798 if (!argp3) {
33799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33800 }
33801 arg3 = reinterpret_cast< wxIcon * >(argp3);
33802 }
33803 if (obj3) {
33804 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33805 if (!SWIG_IsOK(res4)) {
33806 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33807 }
33808 if (!argp4) {
33809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33810 }
33811 arg4 = reinterpret_cast< wxIcon * >(argp4);
33812 }
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33816 wxPyEndAllowThreads(__tstate);
33817 if (PyErr_Occurred()) SWIG_fail;
33818 }
33819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33820 return resultobj;
33821 fail:
33822 return NULL;
33823 }
33824
33825
33826 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33827 PyObject *resultobj = 0;
33828 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33829 PyObject *arg2 = (PyObject *) 0 ;
33830 PyObject *arg3 = (PyObject *) 0 ;
33831 int arg4 = (int) 0 ;
33832 void *argp1 = 0 ;
33833 int res1 = 0 ;
33834 int val4 ;
33835 int ecode4 = 0 ;
33836 PyObject * obj0 = 0 ;
33837 PyObject * obj1 = 0 ;
33838 PyObject * obj2 = 0 ;
33839 PyObject * obj3 = 0 ;
33840 char * kwnames[] = {
33841 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33842 };
33843
33844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33846 if (!SWIG_IsOK(res1)) {
33847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33848 }
33849 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33850 arg2 = obj1;
33851 arg3 = obj2;
33852 if (obj3) {
33853 ecode4 = SWIG_AsVal_int(obj3, &val4);
33854 if (!SWIG_IsOK(ecode4)) {
33855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33856 }
33857 arg4 = static_cast< int >(val4);
33858 }
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_Py_Void();
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33873 PyObject *resultobj = 0;
33874 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33875 void *argp1 = 0 ;
33876 int res1 = 0 ;
33877 PyObject *swig_obj[1] ;
33878
33879 if (!args) SWIG_fail;
33880 swig_obj[0] = args;
33881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33882 if (!SWIG_IsOK(res1)) {
33883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33884 }
33885 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33886 {
33887 PyThreadState* __tstate = wxPyBeginAllowThreads();
33888 delete arg1;
33889
33890 wxPyEndAllowThreads(__tstate);
33891 if (PyErr_Occurred()) SWIG_fail;
33892 }
33893 resultobj = SWIG_Py_Void();
33894 return resultobj;
33895 fail:
33896 return NULL;
33897 }
33898
33899
33900 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33901 PyObject *resultobj = 0;
33902 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33903 wxDataObject *arg2 = 0 ;
33904 void *argp1 = 0 ;
33905 int res1 = 0 ;
33906 void *argp2 = 0 ;
33907 int res2 = 0 ;
33908 PyObject * obj0 = 0 ;
33909 PyObject * obj1 = 0 ;
33910 char * kwnames[] = {
33911 (char *) "self",(char *) "data", NULL
33912 };
33913
33914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33916 if (!SWIG_IsOK(res1)) {
33917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33918 }
33919 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33920 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33921 if (!SWIG_IsOK(res2)) {
33922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33923 }
33924 if (!argp2) {
33925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33926 }
33927 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 (arg1)->SetData(*arg2);
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 resultobj = SWIG_Py_Void();
33935 return resultobj;
33936 fail:
33937 return NULL;
33938 }
33939
33940
33941 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33942 PyObject *resultobj = 0;
33943 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33944 wxDataObject *result = 0 ;
33945 void *argp1 = 0 ;
33946 int res1 = 0 ;
33947 PyObject *swig_obj[1] ;
33948
33949 if (!args) SWIG_fail;
33950 swig_obj[0] = args;
33951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33952 if (!SWIG_IsOK(res1)) {
33953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33954 }
33955 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33956 {
33957 PyThreadState* __tstate = wxPyBeginAllowThreads();
33958 result = (wxDataObject *)(arg1)->GetDataObject();
33959 wxPyEndAllowThreads(__tstate);
33960 if (PyErr_Occurred()) SWIG_fail;
33961 }
33962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33963 return resultobj;
33964 fail:
33965 return NULL;
33966 }
33967
33968
33969 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33970 PyObject *resultobj = 0;
33971 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33972 wxDragResult arg2 ;
33973 wxCursor *arg3 = 0 ;
33974 void *argp1 = 0 ;
33975 int res1 = 0 ;
33976 int val2 ;
33977 int ecode2 = 0 ;
33978 void *argp3 = 0 ;
33979 int res3 = 0 ;
33980 PyObject * obj0 = 0 ;
33981 PyObject * obj1 = 0 ;
33982 PyObject * obj2 = 0 ;
33983 char * kwnames[] = {
33984 (char *) "self",(char *) "res",(char *) "cursor", NULL
33985 };
33986
33987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33989 if (!SWIG_IsOK(res1)) {
33990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33991 }
33992 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33993 ecode2 = SWIG_AsVal_int(obj1, &val2);
33994 if (!SWIG_IsOK(ecode2)) {
33995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33996 }
33997 arg2 = static_cast< wxDragResult >(val2);
33998 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33999 if (!SWIG_IsOK(res3)) {
34000 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34001 }
34002 if (!argp3) {
34003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34004 }
34005 arg3 = reinterpret_cast< wxCursor * >(argp3);
34006 {
34007 PyThreadState* __tstate = wxPyBeginAllowThreads();
34008 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34009 wxPyEndAllowThreads(__tstate);
34010 if (PyErr_Occurred()) SWIG_fail;
34011 }
34012 resultobj = SWIG_Py_Void();
34013 return resultobj;
34014 fail:
34015 return NULL;
34016 }
34017
34018
34019 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34020 PyObject *resultobj = 0;
34021 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34022 int arg2 = (int) wxDrag_CopyOnly ;
34023 wxDragResult result;
34024 void *argp1 = 0 ;
34025 int res1 = 0 ;
34026 int val2 ;
34027 int ecode2 = 0 ;
34028 PyObject * obj0 = 0 ;
34029 PyObject * obj1 = 0 ;
34030 char * kwnames[] = {
34031 (char *) "self",(char *) "flags", NULL
34032 };
34033
34034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34036 if (!SWIG_IsOK(res1)) {
34037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34038 }
34039 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34040 if (obj1) {
34041 ecode2 = SWIG_AsVal_int(obj1, &val2);
34042 if (!SWIG_IsOK(ecode2)) {
34043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34044 }
34045 arg2 = static_cast< int >(val2);
34046 }
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 resultobj = SWIG_From_int(static_cast< int >(result));
34054 return resultobj;
34055 fail:
34056 return NULL;
34057 }
34058
34059
34060 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34061 PyObject *resultobj = 0;
34062 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34063 wxDragResult arg2 ;
34064 bool result;
34065 void *argp1 = 0 ;
34066 int res1 = 0 ;
34067 int val2 ;
34068 int ecode2 = 0 ;
34069 PyObject * obj0 = 0 ;
34070 PyObject * obj1 = 0 ;
34071 char * kwnames[] = {
34072 (char *) "self",(char *) "effect", NULL
34073 };
34074
34075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34077 if (!SWIG_IsOK(res1)) {
34078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34079 }
34080 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34081 ecode2 = SWIG_AsVal_int(obj1, &val2);
34082 if (!SWIG_IsOK(ecode2)) {
34083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34084 }
34085 arg2 = static_cast< wxDragResult >(val2);
34086 {
34087 PyThreadState* __tstate = wxPyBeginAllowThreads();
34088 result = (bool)(arg1)->GiveFeedback(arg2);
34089 wxPyEndAllowThreads(__tstate);
34090 if (PyErr_Occurred()) SWIG_fail;
34091 }
34092 {
34093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34094 }
34095 return resultobj;
34096 fail:
34097 return NULL;
34098 }
34099
34100
34101 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34102 PyObject *obj;
34103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34104 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34105 return SWIG_Py_Void();
34106 }
34107
34108 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34109 return SWIG_Python_InitShadowInstance(args);
34110 }
34111
34112 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34113 PyObject *resultobj = 0;
34114 wxDataObject *arg1 = (wxDataObject *) NULL ;
34115 wxPyDropTarget *result = 0 ;
34116 int res1 = 0 ;
34117 PyObject * obj0 = 0 ;
34118 char * kwnames[] = {
34119 (char *) "dataObject", NULL
34120 };
34121
34122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34123 if (obj0) {
34124 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34125 if (!SWIG_IsOK(res1)) {
34126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34127 }
34128 }
34129 {
34130 PyThreadState* __tstate = wxPyBeginAllowThreads();
34131 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34132 wxPyEndAllowThreads(__tstate);
34133 if (PyErr_Occurred()) SWIG_fail;
34134 }
34135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34136 return resultobj;
34137 fail:
34138 return NULL;
34139 }
34140
34141
34142 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34143 PyObject *resultobj = 0;
34144 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34145 PyObject *arg2 = (PyObject *) 0 ;
34146 PyObject *arg3 = (PyObject *) 0 ;
34147 void *argp1 = 0 ;
34148 int res1 = 0 ;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 PyObject * obj2 = 0 ;
34152 char * kwnames[] = {
34153 (char *) "self",(char *) "self",(char *) "_class", NULL
34154 };
34155
34156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34158 if (!SWIG_IsOK(res1)) {
34159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34160 }
34161 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34162 arg2 = obj1;
34163 arg3 = obj2;
34164 {
34165 PyThreadState* __tstate = wxPyBeginAllowThreads();
34166 (arg1)->_setCallbackInfo(arg2,arg3);
34167 wxPyEndAllowThreads(__tstate);
34168 if (PyErr_Occurred()) SWIG_fail;
34169 }
34170 resultobj = SWIG_Py_Void();
34171 return resultobj;
34172 fail:
34173 return NULL;
34174 }
34175
34176
34177 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34178 PyObject *resultobj = 0;
34179 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34180 void *argp1 = 0 ;
34181 int res1 = 0 ;
34182 PyObject *swig_obj[1] ;
34183
34184 if (!args) SWIG_fail;
34185 swig_obj[0] = args;
34186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34187 if (!SWIG_IsOK(res1)) {
34188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34189 }
34190 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34191 {
34192 PyThreadState* __tstate = wxPyBeginAllowThreads();
34193 delete arg1;
34194
34195 wxPyEndAllowThreads(__tstate);
34196 if (PyErr_Occurred()) SWIG_fail;
34197 }
34198 resultobj = SWIG_Py_Void();
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34206 PyObject *resultobj = 0;
34207 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34208 wxDataObject *result = 0 ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 PyObject *swig_obj[1] ;
34212
34213 if (!args) SWIG_fail;
34214 swig_obj[0] = args;
34215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34216 if (!SWIG_IsOK(res1)) {
34217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34218 }
34219 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34220 {
34221 PyThreadState* __tstate = wxPyBeginAllowThreads();
34222 result = (wxDataObject *)(arg1)->GetDataObject();
34223 wxPyEndAllowThreads(__tstate);
34224 if (PyErr_Occurred()) SWIG_fail;
34225 }
34226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34234 PyObject *resultobj = 0;
34235 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34236 wxDataObject *arg2 = (wxDataObject *) 0 ;
34237 void *argp1 = 0 ;
34238 int res1 = 0 ;
34239 int res2 = 0 ;
34240 PyObject * obj0 = 0 ;
34241 PyObject * obj1 = 0 ;
34242 char * kwnames[] = {
34243 (char *) "self",(char *) "dataObject", NULL
34244 };
34245
34246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34248 if (!SWIG_IsOK(res1)) {
34249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34250 }
34251 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34252 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34253 if (!SWIG_IsOK(res2)) {
34254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34255 }
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 (arg1)->SetDataObject(arg2);
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 resultobj = SWIG_Py_Void();
34263 return resultobj;
34264 fail:
34265 return NULL;
34266 }
34267
34268
34269 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34270 PyObject *resultobj = 0;
34271 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34272 int arg2 ;
34273 int arg3 ;
34274 wxDragResult arg4 ;
34275 wxDragResult result;
34276 void *argp1 = 0 ;
34277 int res1 = 0 ;
34278 int val2 ;
34279 int ecode2 = 0 ;
34280 int val3 ;
34281 int ecode3 = 0 ;
34282 int val4 ;
34283 int ecode4 = 0 ;
34284 PyObject * obj0 = 0 ;
34285 PyObject * obj1 = 0 ;
34286 PyObject * obj2 = 0 ;
34287 PyObject * obj3 = 0 ;
34288 char * kwnames[] = {
34289 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34290 };
34291
34292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34294 if (!SWIG_IsOK(res1)) {
34295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34296 }
34297 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34298 ecode2 = SWIG_AsVal_int(obj1, &val2);
34299 if (!SWIG_IsOK(ecode2)) {
34300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34301 }
34302 arg2 = static_cast< int >(val2);
34303 ecode3 = SWIG_AsVal_int(obj2, &val3);
34304 if (!SWIG_IsOK(ecode3)) {
34305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34306 }
34307 arg3 = static_cast< int >(val3);
34308 ecode4 = SWIG_AsVal_int(obj3, &val4);
34309 if (!SWIG_IsOK(ecode4)) {
34310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34311 }
34312 arg4 = static_cast< wxDragResult >(val4);
34313 {
34314 PyThreadState* __tstate = wxPyBeginAllowThreads();
34315 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 resultobj = SWIG_From_int(static_cast< int >(result));
34320 return resultobj;
34321 fail:
34322 return NULL;
34323 }
34324
34325
34326 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34327 PyObject *resultobj = 0;
34328 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34329 int arg2 ;
34330 int arg3 ;
34331 wxDragResult arg4 ;
34332 wxDragResult result;
34333 void *argp1 = 0 ;
34334 int res1 = 0 ;
34335 int val2 ;
34336 int ecode2 = 0 ;
34337 int val3 ;
34338 int ecode3 = 0 ;
34339 int val4 ;
34340 int ecode4 = 0 ;
34341 PyObject * obj0 = 0 ;
34342 PyObject * obj1 = 0 ;
34343 PyObject * obj2 = 0 ;
34344 PyObject * obj3 = 0 ;
34345 char * kwnames[] = {
34346 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34347 };
34348
34349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34351 if (!SWIG_IsOK(res1)) {
34352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34353 }
34354 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34355 ecode2 = SWIG_AsVal_int(obj1, &val2);
34356 if (!SWIG_IsOK(ecode2)) {
34357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34358 }
34359 arg2 = static_cast< int >(val2);
34360 ecode3 = SWIG_AsVal_int(obj2, &val3);
34361 if (!SWIG_IsOK(ecode3)) {
34362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34363 }
34364 arg3 = static_cast< int >(val3);
34365 ecode4 = SWIG_AsVal_int(obj3, &val4);
34366 if (!SWIG_IsOK(ecode4)) {
34367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34368 }
34369 arg4 = static_cast< wxDragResult >(val4);
34370 {
34371 PyThreadState* __tstate = wxPyBeginAllowThreads();
34372 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 resultobj = SWIG_From_int(static_cast< int >(result));
34377 return resultobj;
34378 fail:
34379 return NULL;
34380 }
34381
34382
34383 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34384 PyObject *resultobj = 0;
34385 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34386 void *argp1 = 0 ;
34387 int res1 = 0 ;
34388 PyObject *swig_obj[1] ;
34389
34390 if (!args) SWIG_fail;
34391 swig_obj[0] = args;
34392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34393 if (!SWIG_IsOK(res1)) {
34394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34395 }
34396 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34397 {
34398 PyThreadState* __tstate = wxPyBeginAllowThreads();
34399 (arg1)->OnLeave();
34400 wxPyEndAllowThreads(__tstate);
34401 if (PyErr_Occurred()) SWIG_fail;
34402 }
34403 resultobj = SWIG_Py_Void();
34404 return resultobj;
34405 fail:
34406 return NULL;
34407 }
34408
34409
34410 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34411 PyObject *resultobj = 0;
34412 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34413 int arg2 ;
34414 int arg3 ;
34415 bool result;
34416 void *argp1 = 0 ;
34417 int res1 = 0 ;
34418 int val2 ;
34419 int ecode2 = 0 ;
34420 int val3 ;
34421 int ecode3 = 0 ;
34422 PyObject * obj0 = 0 ;
34423 PyObject * obj1 = 0 ;
34424 PyObject * obj2 = 0 ;
34425 char * kwnames[] = {
34426 (char *) "self",(char *) "x",(char *) "y", NULL
34427 };
34428
34429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34431 if (!SWIG_IsOK(res1)) {
34432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34433 }
34434 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34435 ecode2 = SWIG_AsVal_int(obj1, &val2);
34436 if (!SWIG_IsOK(ecode2)) {
34437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34438 }
34439 arg2 = static_cast< int >(val2);
34440 ecode3 = SWIG_AsVal_int(obj2, &val3);
34441 if (!SWIG_IsOK(ecode3)) {
34442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34443 }
34444 arg3 = static_cast< int >(val3);
34445 {
34446 PyThreadState* __tstate = wxPyBeginAllowThreads();
34447 result = (bool)(arg1)->OnDrop(arg2,arg3);
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 {
34452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34453 }
34454 return resultobj;
34455 fail:
34456 return NULL;
34457 }
34458
34459
34460 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34461 PyObject *resultobj = 0;
34462 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34463 bool result;
34464 void *argp1 = 0 ;
34465 int res1 = 0 ;
34466 PyObject *swig_obj[1] ;
34467
34468 if (!args) SWIG_fail;
34469 swig_obj[0] = args;
34470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34471 if (!SWIG_IsOK(res1)) {
34472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34473 }
34474 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34475 {
34476 PyThreadState* __tstate = wxPyBeginAllowThreads();
34477 result = (bool)(arg1)->GetData();
34478 wxPyEndAllowThreads(__tstate);
34479 if (PyErr_Occurred()) SWIG_fail;
34480 }
34481 {
34482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34483 }
34484 return resultobj;
34485 fail:
34486 return NULL;
34487 }
34488
34489
34490 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34491 PyObject *resultobj = 0;
34492 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34493 wxDragResult arg2 ;
34494 void *argp1 = 0 ;
34495 int res1 = 0 ;
34496 int val2 ;
34497 int ecode2 = 0 ;
34498 PyObject * obj0 = 0 ;
34499 PyObject * obj1 = 0 ;
34500 char * kwnames[] = {
34501 (char *) "self",(char *) "action", NULL
34502 };
34503
34504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34506 if (!SWIG_IsOK(res1)) {
34507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34508 }
34509 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34510 ecode2 = SWIG_AsVal_int(obj1, &val2);
34511 if (!SWIG_IsOK(ecode2)) {
34512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34513 }
34514 arg2 = static_cast< wxDragResult >(val2);
34515 {
34516 PyThreadState* __tstate = wxPyBeginAllowThreads();
34517 (arg1)->SetDefaultAction(arg2);
34518 wxPyEndAllowThreads(__tstate);
34519 if (PyErr_Occurred()) SWIG_fail;
34520 }
34521 resultobj = SWIG_Py_Void();
34522 return resultobj;
34523 fail:
34524 return NULL;
34525 }
34526
34527
34528 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34529 PyObject *resultobj = 0;
34530 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34531 wxDragResult result;
34532 void *argp1 = 0 ;
34533 int res1 = 0 ;
34534 PyObject *swig_obj[1] ;
34535
34536 if (!args) SWIG_fail;
34537 swig_obj[0] = args;
34538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34539 if (!SWIG_IsOK(res1)) {
34540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34541 }
34542 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34543 {
34544 PyThreadState* __tstate = wxPyBeginAllowThreads();
34545 result = (wxDragResult)(arg1)->GetDefaultAction();
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 resultobj = SWIG_From_int(static_cast< int >(result));
34550 return resultobj;
34551 fail:
34552 return NULL;
34553 }
34554
34555
34556 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34557 PyObject *obj;
34558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34559 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34560 return SWIG_Py_Void();
34561 }
34562
34563 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34564 return SWIG_Python_InitShadowInstance(args);
34565 }
34566
34567 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34568 PyObject *resultobj = 0;
34569 wxPyTextDropTarget *result = 0 ;
34570
34571 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34572 {
34573 PyThreadState* __tstate = wxPyBeginAllowThreads();
34574 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34575 wxPyEndAllowThreads(__tstate);
34576 if (PyErr_Occurred()) SWIG_fail;
34577 }
34578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34579 return resultobj;
34580 fail:
34581 return NULL;
34582 }
34583
34584
34585 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34586 PyObject *resultobj = 0;
34587 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34588 PyObject *arg2 = (PyObject *) 0 ;
34589 PyObject *arg3 = (PyObject *) 0 ;
34590 void *argp1 = 0 ;
34591 int res1 = 0 ;
34592 PyObject * obj0 = 0 ;
34593 PyObject * obj1 = 0 ;
34594 PyObject * obj2 = 0 ;
34595 char * kwnames[] = {
34596 (char *) "self",(char *) "self",(char *) "_class", NULL
34597 };
34598
34599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34601 if (!SWIG_IsOK(res1)) {
34602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34603 }
34604 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34605 arg2 = obj1;
34606 arg3 = obj2;
34607 {
34608 PyThreadState* __tstate = wxPyBeginAllowThreads();
34609 (arg1)->_setCallbackInfo(arg2,arg3);
34610 wxPyEndAllowThreads(__tstate);
34611 if (PyErr_Occurred()) SWIG_fail;
34612 }
34613 resultobj = SWIG_Py_Void();
34614 return resultobj;
34615 fail:
34616 return NULL;
34617 }
34618
34619
34620 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34621 PyObject *resultobj = 0;
34622 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34623 int arg2 ;
34624 int arg3 ;
34625 wxString *arg4 = 0 ;
34626 bool result;
34627 void *argp1 = 0 ;
34628 int res1 = 0 ;
34629 int val2 ;
34630 int ecode2 = 0 ;
34631 int val3 ;
34632 int ecode3 = 0 ;
34633 bool temp4 = false ;
34634 PyObject * obj0 = 0 ;
34635 PyObject * obj1 = 0 ;
34636 PyObject * obj2 = 0 ;
34637 PyObject * obj3 = 0 ;
34638 char * kwnames[] = {
34639 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34640 };
34641
34642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34644 if (!SWIG_IsOK(res1)) {
34645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34646 }
34647 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34648 ecode2 = SWIG_AsVal_int(obj1, &val2);
34649 if (!SWIG_IsOK(ecode2)) {
34650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34651 }
34652 arg2 = static_cast< int >(val2);
34653 ecode3 = SWIG_AsVal_int(obj2, &val3);
34654 if (!SWIG_IsOK(ecode3)) {
34655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34656 }
34657 arg3 = static_cast< int >(val3);
34658 {
34659 arg4 = wxString_in_helper(obj3);
34660 if (arg4 == NULL) SWIG_fail;
34661 temp4 = true;
34662 }
34663 {
34664 PyThreadState* __tstate = wxPyBeginAllowThreads();
34665 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34666 wxPyEndAllowThreads(__tstate);
34667 if (PyErr_Occurred()) SWIG_fail;
34668 }
34669 {
34670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34671 }
34672 {
34673 if (temp4)
34674 delete arg4;
34675 }
34676 return resultobj;
34677 fail:
34678 {
34679 if (temp4)
34680 delete arg4;
34681 }
34682 return NULL;
34683 }
34684
34685
34686 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34687 PyObject *resultobj = 0;
34688 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34689 int arg2 ;
34690 int arg3 ;
34691 wxDragResult arg4 ;
34692 wxDragResult result;
34693 void *argp1 = 0 ;
34694 int res1 = 0 ;
34695 int val2 ;
34696 int ecode2 = 0 ;
34697 int val3 ;
34698 int ecode3 = 0 ;
34699 int val4 ;
34700 int ecode4 = 0 ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 PyObject * obj2 = 0 ;
34704 PyObject * obj3 = 0 ;
34705 char * kwnames[] = {
34706 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34707 };
34708
34709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34711 if (!SWIG_IsOK(res1)) {
34712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34713 }
34714 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34715 ecode2 = SWIG_AsVal_int(obj1, &val2);
34716 if (!SWIG_IsOK(ecode2)) {
34717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34718 }
34719 arg2 = static_cast< int >(val2);
34720 ecode3 = SWIG_AsVal_int(obj2, &val3);
34721 if (!SWIG_IsOK(ecode3)) {
34722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34723 }
34724 arg3 = static_cast< int >(val3);
34725 ecode4 = SWIG_AsVal_int(obj3, &val4);
34726 if (!SWIG_IsOK(ecode4)) {
34727 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34728 }
34729 arg4 = static_cast< wxDragResult >(val4);
34730 {
34731 PyThreadState* __tstate = wxPyBeginAllowThreads();
34732 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34733 wxPyEndAllowThreads(__tstate);
34734 if (PyErr_Occurred()) SWIG_fail;
34735 }
34736 resultobj = SWIG_From_int(static_cast< int >(result));
34737 return resultobj;
34738 fail:
34739 return NULL;
34740 }
34741
34742
34743 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34744 PyObject *resultobj = 0;
34745 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34746 int arg2 ;
34747 int arg3 ;
34748 wxDragResult arg4 ;
34749 wxDragResult result;
34750 void *argp1 = 0 ;
34751 int res1 = 0 ;
34752 int val2 ;
34753 int ecode2 = 0 ;
34754 int val3 ;
34755 int ecode3 = 0 ;
34756 int val4 ;
34757 int ecode4 = 0 ;
34758 PyObject * obj0 = 0 ;
34759 PyObject * obj1 = 0 ;
34760 PyObject * obj2 = 0 ;
34761 PyObject * obj3 = 0 ;
34762 char * kwnames[] = {
34763 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34764 };
34765
34766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34768 if (!SWIG_IsOK(res1)) {
34769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34770 }
34771 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34772 ecode2 = SWIG_AsVal_int(obj1, &val2);
34773 if (!SWIG_IsOK(ecode2)) {
34774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34775 }
34776 arg2 = static_cast< int >(val2);
34777 ecode3 = SWIG_AsVal_int(obj2, &val3);
34778 if (!SWIG_IsOK(ecode3)) {
34779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34780 }
34781 arg3 = static_cast< int >(val3);
34782 ecode4 = SWIG_AsVal_int(obj3, &val4);
34783 if (!SWIG_IsOK(ecode4)) {
34784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34785 }
34786 arg4 = static_cast< wxDragResult >(val4);
34787 {
34788 PyThreadState* __tstate = wxPyBeginAllowThreads();
34789 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34790 wxPyEndAllowThreads(__tstate);
34791 if (PyErr_Occurred()) SWIG_fail;
34792 }
34793 resultobj = SWIG_From_int(static_cast< int >(result));
34794 return resultobj;
34795 fail:
34796 return NULL;
34797 }
34798
34799
34800 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34801 PyObject *resultobj = 0;
34802 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34803 void *argp1 = 0 ;
34804 int res1 = 0 ;
34805 PyObject *swig_obj[1] ;
34806
34807 if (!args) SWIG_fail;
34808 swig_obj[0] = args;
34809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34810 if (!SWIG_IsOK(res1)) {
34811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34812 }
34813 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34814 {
34815 PyThreadState* __tstate = wxPyBeginAllowThreads();
34816 (arg1)->OnLeave();
34817 wxPyEndAllowThreads(__tstate);
34818 if (PyErr_Occurred()) SWIG_fail;
34819 }
34820 resultobj = SWIG_Py_Void();
34821 return resultobj;
34822 fail:
34823 return NULL;
34824 }
34825
34826
34827 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34828 PyObject *resultobj = 0;
34829 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34830 int arg2 ;
34831 int arg3 ;
34832 bool result;
34833 void *argp1 = 0 ;
34834 int res1 = 0 ;
34835 int val2 ;
34836 int ecode2 = 0 ;
34837 int val3 ;
34838 int ecode3 = 0 ;
34839 PyObject * obj0 = 0 ;
34840 PyObject * obj1 = 0 ;
34841 PyObject * obj2 = 0 ;
34842 char * kwnames[] = {
34843 (char *) "self",(char *) "x",(char *) "y", NULL
34844 };
34845
34846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34848 if (!SWIG_IsOK(res1)) {
34849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34850 }
34851 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34852 ecode2 = SWIG_AsVal_int(obj1, &val2);
34853 if (!SWIG_IsOK(ecode2)) {
34854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34855 }
34856 arg2 = static_cast< int >(val2);
34857 ecode3 = SWIG_AsVal_int(obj2, &val3);
34858 if (!SWIG_IsOK(ecode3)) {
34859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34860 }
34861 arg3 = static_cast< int >(val3);
34862 {
34863 PyThreadState* __tstate = wxPyBeginAllowThreads();
34864 result = (bool)(arg1)->OnDrop(arg2,arg3);
34865 wxPyEndAllowThreads(__tstate);
34866 if (PyErr_Occurred()) SWIG_fail;
34867 }
34868 {
34869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34870 }
34871 return resultobj;
34872 fail:
34873 return NULL;
34874 }
34875
34876
34877 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34878 PyObject *resultobj = 0;
34879 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34880 int arg2 ;
34881 int arg3 ;
34882 wxDragResult arg4 ;
34883 wxDragResult result;
34884 void *argp1 = 0 ;
34885 int res1 = 0 ;
34886 int val2 ;
34887 int ecode2 = 0 ;
34888 int val3 ;
34889 int ecode3 = 0 ;
34890 int val4 ;
34891 int ecode4 = 0 ;
34892 PyObject * obj0 = 0 ;
34893 PyObject * obj1 = 0 ;
34894 PyObject * obj2 = 0 ;
34895 PyObject * obj3 = 0 ;
34896 char * kwnames[] = {
34897 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34898 };
34899
34900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34902 if (!SWIG_IsOK(res1)) {
34903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34904 }
34905 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34906 ecode2 = SWIG_AsVal_int(obj1, &val2);
34907 if (!SWIG_IsOK(ecode2)) {
34908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34909 }
34910 arg2 = static_cast< int >(val2);
34911 ecode3 = SWIG_AsVal_int(obj2, &val3);
34912 if (!SWIG_IsOK(ecode3)) {
34913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34914 }
34915 arg3 = static_cast< int >(val3);
34916 ecode4 = SWIG_AsVal_int(obj3, &val4);
34917 if (!SWIG_IsOK(ecode4)) {
34918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34919 }
34920 arg4 = static_cast< wxDragResult >(val4);
34921 {
34922 PyThreadState* __tstate = wxPyBeginAllowThreads();
34923 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 resultobj = SWIG_From_int(static_cast< int >(result));
34928 return resultobj;
34929 fail:
34930 return NULL;
34931 }
34932
34933
34934 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34935 PyObject *obj;
34936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34937 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34938 return SWIG_Py_Void();
34939 }
34940
34941 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34942 return SWIG_Python_InitShadowInstance(args);
34943 }
34944
34945 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34946 PyObject *resultobj = 0;
34947 wxPyFileDropTarget *result = 0 ;
34948
34949 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34950 {
34951 PyThreadState* __tstate = wxPyBeginAllowThreads();
34952 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34953 wxPyEndAllowThreads(__tstate);
34954 if (PyErr_Occurred()) SWIG_fail;
34955 }
34956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34957 return resultobj;
34958 fail:
34959 return NULL;
34960 }
34961
34962
34963 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34964 PyObject *resultobj = 0;
34965 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34966 PyObject *arg2 = (PyObject *) 0 ;
34967 PyObject *arg3 = (PyObject *) 0 ;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 PyObject * obj0 = 0 ;
34971 PyObject * obj1 = 0 ;
34972 PyObject * obj2 = 0 ;
34973 char * kwnames[] = {
34974 (char *) "self",(char *) "self",(char *) "_class", NULL
34975 };
34976
34977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34979 if (!SWIG_IsOK(res1)) {
34980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34981 }
34982 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34983 arg2 = obj1;
34984 arg3 = obj2;
34985 {
34986 PyThreadState* __tstate = wxPyBeginAllowThreads();
34987 (arg1)->_setCallbackInfo(arg2,arg3);
34988 wxPyEndAllowThreads(__tstate);
34989 if (PyErr_Occurred()) SWIG_fail;
34990 }
34991 resultobj = SWIG_Py_Void();
34992 return resultobj;
34993 fail:
34994 return NULL;
34995 }
34996
34997
34998 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34999 PyObject *resultobj = 0;
35000 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35001 int arg2 ;
35002 int arg3 ;
35003 wxArrayString *arg4 = 0 ;
35004 bool result;
35005 void *argp1 = 0 ;
35006 int res1 = 0 ;
35007 int val2 ;
35008 int ecode2 = 0 ;
35009 int val3 ;
35010 int ecode3 = 0 ;
35011 bool temp4 = false ;
35012 PyObject * obj0 = 0 ;
35013 PyObject * obj1 = 0 ;
35014 PyObject * obj2 = 0 ;
35015 PyObject * obj3 = 0 ;
35016 char * kwnames[] = {
35017 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35018 };
35019
35020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35022 if (!SWIG_IsOK(res1)) {
35023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35024 }
35025 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35026 ecode2 = SWIG_AsVal_int(obj1, &val2);
35027 if (!SWIG_IsOK(ecode2)) {
35028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35029 }
35030 arg2 = static_cast< int >(val2);
35031 ecode3 = SWIG_AsVal_int(obj2, &val3);
35032 if (!SWIG_IsOK(ecode3)) {
35033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35034 }
35035 arg3 = static_cast< int >(val3);
35036 {
35037 if (! PySequence_Check(obj3)) {
35038 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35039 SWIG_fail;
35040 }
35041 arg4 = new wxArrayString;
35042 temp4 = true;
35043 int i, len=PySequence_Length(obj3);
35044 for (i=0; i<len; i++) {
35045 PyObject* item = PySequence_GetItem(obj3, i);
35046 wxString* s = wxString_in_helper(item);
35047 if (PyErr_Occurred()) SWIG_fail;
35048 arg4->Add(*s);
35049 delete s;
35050 Py_DECREF(item);
35051 }
35052 }
35053 {
35054 PyThreadState* __tstate = wxPyBeginAllowThreads();
35055 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35056 wxPyEndAllowThreads(__tstate);
35057 if (PyErr_Occurred()) SWIG_fail;
35058 }
35059 {
35060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35061 }
35062 {
35063 if (temp4) delete arg4;
35064 }
35065 return resultobj;
35066 fail:
35067 {
35068 if (temp4) delete arg4;
35069 }
35070 return NULL;
35071 }
35072
35073
35074 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35075 PyObject *resultobj = 0;
35076 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35077 int arg2 ;
35078 int arg3 ;
35079 wxDragResult arg4 ;
35080 wxDragResult result;
35081 void *argp1 = 0 ;
35082 int res1 = 0 ;
35083 int val2 ;
35084 int ecode2 = 0 ;
35085 int val3 ;
35086 int ecode3 = 0 ;
35087 int val4 ;
35088 int ecode4 = 0 ;
35089 PyObject * obj0 = 0 ;
35090 PyObject * obj1 = 0 ;
35091 PyObject * obj2 = 0 ;
35092 PyObject * obj3 = 0 ;
35093 char * kwnames[] = {
35094 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35095 };
35096
35097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35099 if (!SWIG_IsOK(res1)) {
35100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35101 }
35102 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35103 ecode2 = SWIG_AsVal_int(obj1, &val2);
35104 if (!SWIG_IsOK(ecode2)) {
35105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35106 }
35107 arg2 = static_cast< int >(val2);
35108 ecode3 = SWIG_AsVal_int(obj2, &val3);
35109 if (!SWIG_IsOK(ecode3)) {
35110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35111 }
35112 arg3 = static_cast< int >(val3);
35113 ecode4 = SWIG_AsVal_int(obj3, &val4);
35114 if (!SWIG_IsOK(ecode4)) {
35115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35116 }
35117 arg4 = static_cast< wxDragResult >(val4);
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35121 wxPyEndAllowThreads(__tstate);
35122 if (PyErr_Occurred()) SWIG_fail;
35123 }
35124 resultobj = SWIG_From_int(static_cast< int >(result));
35125 return resultobj;
35126 fail:
35127 return NULL;
35128 }
35129
35130
35131 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35132 PyObject *resultobj = 0;
35133 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35134 int arg2 ;
35135 int arg3 ;
35136 wxDragResult arg4 ;
35137 wxDragResult result;
35138 void *argp1 = 0 ;
35139 int res1 = 0 ;
35140 int val2 ;
35141 int ecode2 = 0 ;
35142 int val3 ;
35143 int ecode3 = 0 ;
35144 int val4 ;
35145 int ecode4 = 0 ;
35146 PyObject * obj0 = 0 ;
35147 PyObject * obj1 = 0 ;
35148 PyObject * obj2 = 0 ;
35149 PyObject * obj3 = 0 ;
35150 char * kwnames[] = {
35151 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35152 };
35153
35154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35156 if (!SWIG_IsOK(res1)) {
35157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35158 }
35159 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35160 ecode2 = SWIG_AsVal_int(obj1, &val2);
35161 if (!SWIG_IsOK(ecode2)) {
35162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35163 }
35164 arg2 = static_cast< int >(val2);
35165 ecode3 = SWIG_AsVal_int(obj2, &val3);
35166 if (!SWIG_IsOK(ecode3)) {
35167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35168 }
35169 arg3 = static_cast< int >(val3);
35170 ecode4 = SWIG_AsVal_int(obj3, &val4);
35171 if (!SWIG_IsOK(ecode4)) {
35172 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35173 }
35174 arg4 = static_cast< wxDragResult >(val4);
35175 {
35176 PyThreadState* __tstate = wxPyBeginAllowThreads();
35177 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35178 wxPyEndAllowThreads(__tstate);
35179 if (PyErr_Occurred()) SWIG_fail;
35180 }
35181 resultobj = SWIG_From_int(static_cast< int >(result));
35182 return resultobj;
35183 fail:
35184 return NULL;
35185 }
35186
35187
35188 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35189 PyObject *resultobj = 0;
35190 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35191 void *argp1 = 0 ;
35192 int res1 = 0 ;
35193 PyObject *swig_obj[1] ;
35194
35195 if (!args) SWIG_fail;
35196 swig_obj[0] = args;
35197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35198 if (!SWIG_IsOK(res1)) {
35199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35200 }
35201 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 (arg1)->OnLeave();
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 resultobj = SWIG_Py_Void();
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35216 PyObject *resultobj = 0;
35217 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35218 int arg2 ;
35219 int arg3 ;
35220 bool result;
35221 void *argp1 = 0 ;
35222 int res1 = 0 ;
35223 int val2 ;
35224 int ecode2 = 0 ;
35225 int val3 ;
35226 int ecode3 = 0 ;
35227 PyObject * obj0 = 0 ;
35228 PyObject * obj1 = 0 ;
35229 PyObject * obj2 = 0 ;
35230 char * kwnames[] = {
35231 (char *) "self",(char *) "x",(char *) "y", NULL
35232 };
35233
35234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35236 if (!SWIG_IsOK(res1)) {
35237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35238 }
35239 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35240 ecode2 = SWIG_AsVal_int(obj1, &val2);
35241 if (!SWIG_IsOK(ecode2)) {
35242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35243 }
35244 arg2 = static_cast< int >(val2);
35245 ecode3 = SWIG_AsVal_int(obj2, &val3);
35246 if (!SWIG_IsOK(ecode3)) {
35247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35248 }
35249 arg3 = static_cast< int >(val3);
35250 {
35251 PyThreadState* __tstate = wxPyBeginAllowThreads();
35252 result = (bool)(arg1)->OnDrop(arg2,arg3);
35253 wxPyEndAllowThreads(__tstate);
35254 if (PyErr_Occurred()) SWIG_fail;
35255 }
35256 {
35257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35258 }
35259 return resultobj;
35260 fail:
35261 return NULL;
35262 }
35263
35264
35265 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35266 PyObject *resultobj = 0;
35267 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35268 int arg2 ;
35269 int arg3 ;
35270 wxDragResult arg4 ;
35271 wxDragResult result;
35272 void *argp1 = 0 ;
35273 int res1 = 0 ;
35274 int val2 ;
35275 int ecode2 = 0 ;
35276 int val3 ;
35277 int ecode3 = 0 ;
35278 int val4 ;
35279 int ecode4 = 0 ;
35280 PyObject * obj0 = 0 ;
35281 PyObject * obj1 = 0 ;
35282 PyObject * obj2 = 0 ;
35283 PyObject * obj3 = 0 ;
35284 char * kwnames[] = {
35285 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35286 };
35287
35288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35290 if (!SWIG_IsOK(res1)) {
35291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35292 }
35293 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35294 ecode2 = SWIG_AsVal_int(obj1, &val2);
35295 if (!SWIG_IsOK(ecode2)) {
35296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35297 }
35298 arg2 = static_cast< int >(val2);
35299 ecode3 = SWIG_AsVal_int(obj2, &val3);
35300 if (!SWIG_IsOK(ecode3)) {
35301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35302 }
35303 arg3 = static_cast< int >(val3);
35304 ecode4 = SWIG_AsVal_int(obj3, &val4);
35305 if (!SWIG_IsOK(ecode4)) {
35306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35307 }
35308 arg4 = static_cast< wxDragResult >(val4);
35309 {
35310 PyThreadState* __tstate = wxPyBeginAllowThreads();
35311 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35312 wxPyEndAllowThreads(__tstate);
35313 if (PyErr_Occurred()) SWIG_fail;
35314 }
35315 resultobj = SWIG_From_int(static_cast< int >(result));
35316 return resultobj;
35317 fail:
35318 return NULL;
35319 }
35320
35321
35322 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35323 PyObject *obj;
35324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35325 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35326 return SWIG_Py_Void();
35327 }
35328
35329 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35330 return SWIG_Python_InitShadowInstance(args);
35331 }
35332
35333 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35334 PyObject *resultobj = 0;
35335 wxClipboard *result = 0 ;
35336
35337 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35338 {
35339 PyThreadState* __tstate = wxPyBeginAllowThreads();
35340 result = (wxClipboard *)new wxClipboard();
35341 wxPyEndAllowThreads(__tstate);
35342 if (PyErr_Occurred()) SWIG_fail;
35343 }
35344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35345 return resultobj;
35346 fail:
35347 return NULL;
35348 }
35349
35350
35351 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35352 PyObject *resultobj = 0;
35353 wxClipboard *arg1 = (wxClipboard *) 0 ;
35354 void *argp1 = 0 ;
35355 int res1 = 0 ;
35356 PyObject *swig_obj[1] ;
35357
35358 if (!args) SWIG_fail;
35359 swig_obj[0] = args;
35360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35361 if (!SWIG_IsOK(res1)) {
35362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35363 }
35364 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35365 {
35366 PyThreadState* __tstate = wxPyBeginAllowThreads();
35367 delete arg1;
35368
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 resultobj = SWIG_Py_Void();
35373 return resultobj;
35374 fail:
35375 return NULL;
35376 }
35377
35378
35379 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35380 PyObject *resultobj = 0;
35381 wxClipboard *arg1 = (wxClipboard *) 0 ;
35382 bool result;
35383 void *argp1 = 0 ;
35384 int res1 = 0 ;
35385 PyObject *swig_obj[1] ;
35386
35387 if (!args) SWIG_fail;
35388 swig_obj[0] = args;
35389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35390 if (!SWIG_IsOK(res1)) {
35391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35392 }
35393 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35394 {
35395 PyThreadState* __tstate = wxPyBeginAllowThreads();
35396 result = (bool)(arg1)->Open();
35397 wxPyEndAllowThreads(__tstate);
35398 if (PyErr_Occurred()) SWIG_fail;
35399 }
35400 {
35401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35402 }
35403 return resultobj;
35404 fail:
35405 return NULL;
35406 }
35407
35408
35409 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35410 PyObject *resultobj = 0;
35411 wxClipboard *arg1 = (wxClipboard *) 0 ;
35412 void *argp1 = 0 ;
35413 int res1 = 0 ;
35414 PyObject *swig_obj[1] ;
35415
35416 if (!args) SWIG_fail;
35417 swig_obj[0] = args;
35418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35421 }
35422 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 (arg1)->Close();
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 resultobj = SWIG_Py_Void();
35430 return resultobj;
35431 fail:
35432 return NULL;
35433 }
35434
35435
35436 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35437 PyObject *resultobj = 0;
35438 wxClipboard *arg1 = (wxClipboard *) 0 ;
35439 bool result;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 PyObject *swig_obj[1] ;
35443
35444 if (!args) SWIG_fail;
35445 swig_obj[0] = args;
35446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35449 }
35450 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 {
35458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35459 }
35460 return resultobj;
35461 fail:
35462 return NULL;
35463 }
35464
35465
35466 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35467 PyObject *resultobj = 0;
35468 wxClipboard *arg1 = (wxClipboard *) 0 ;
35469 wxDataObject *arg2 = (wxDataObject *) 0 ;
35470 bool result;
35471 void *argp1 = 0 ;
35472 int res1 = 0 ;
35473 int res2 = 0 ;
35474 PyObject * obj0 = 0 ;
35475 PyObject * obj1 = 0 ;
35476 char * kwnames[] = {
35477 (char *) "self",(char *) "data", NULL
35478 };
35479
35480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35484 }
35485 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35486 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35487 if (!SWIG_IsOK(res2)) {
35488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35489 }
35490 {
35491 PyThreadState* __tstate = wxPyBeginAllowThreads();
35492 result = (bool)(arg1)->AddData(arg2);
35493 wxPyEndAllowThreads(__tstate);
35494 if (PyErr_Occurred()) SWIG_fail;
35495 }
35496 {
35497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35498 }
35499 return resultobj;
35500 fail:
35501 return NULL;
35502 }
35503
35504
35505 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35506 PyObject *resultobj = 0;
35507 wxClipboard *arg1 = (wxClipboard *) 0 ;
35508 wxDataObject *arg2 = (wxDataObject *) 0 ;
35509 bool result;
35510 void *argp1 = 0 ;
35511 int res1 = 0 ;
35512 int res2 = 0 ;
35513 PyObject * obj0 = 0 ;
35514 PyObject * obj1 = 0 ;
35515 char * kwnames[] = {
35516 (char *) "self",(char *) "data", NULL
35517 };
35518
35519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35521 if (!SWIG_IsOK(res1)) {
35522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35523 }
35524 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35525 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35526 if (!SWIG_IsOK(res2)) {
35527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35528 }
35529 {
35530 PyThreadState* __tstate = wxPyBeginAllowThreads();
35531 result = (bool)(arg1)->SetData(arg2);
35532 wxPyEndAllowThreads(__tstate);
35533 if (PyErr_Occurred()) SWIG_fail;
35534 }
35535 {
35536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35537 }
35538 return resultobj;
35539 fail:
35540 return NULL;
35541 }
35542
35543
35544 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35545 PyObject *resultobj = 0;
35546 wxClipboard *arg1 = (wxClipboard *) 0 ;
35547 wxDataFormat *arg2 = 0 ;
35548 bool result;
35549 void *argp1 = 0 ;
35550 int res1 = 0 ;
35551 void *argp2 = 0 ;
35552 int res2 = 0 ;
35553 PyObject * obj0 = 0 ;
35554 PyObject * obj1 = 0 ;
35555 char * kwnames[] = {
35556 (char *) "self",(char *) "format", NULL
35557 };
35558
35559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35561 if (!SWIG_IsOK(res1)) {
35562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35563 }
35564 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35565 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35566 if (!SWIG_IsOK(res2)) {
35567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35568 }
35569 if (!argp2) {
35570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35571 }
35572 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 {
35580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35581 }
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35589 PyObject *resultobj = 0;
35590 wxClipboard *arg1 = (wxClipboard *) 0 ;
35591 wxDataObject *arg2 = 0 ;
35592 bool result;
35593 void *argp1 = 0 ;
35594 int res1 = 0 ;
35595 void *argp2 = 0 ;
35596 int res2 = 0 ;
35597 PyObject * obj0 = 0 ;
35598 PyObject * obj1 = 0 ;
35599 char * kwnames[] = {
35600 (char *) "self",(char *) "data", NULL
35601 };
35602
35603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35605 if (!SWIG_IsOK(res1)) {
35606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35607 }
35608 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35610 if (!SWIG_IsOK(res2)) {
35611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35612 }
35613 if (!argp2) {
35614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35615 }
35616 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35617 {
35618 PyThreadState* __tstate = wxPyBeginAllowThreads();
35619 result = (bool)(arg1)->GetData(*arg2);
35620 wxPyEndAllowThreads(__tstate);
35621 if (PyErr_Occurred()) SWIG_fail;
35622 }
35623 {
35624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35625 }
35626 return resultobj;
35627 fail:
35628 return NULL;
35629 }
35630
35631
35632 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35633 PyObject *resultobj = 0;
35634 wxClipboard *arg1 = (wxClipboard *) 0 ;
35635 void *argp1 = 0 ;
35636 int res1 = 0 ;
35637 PyObject *swig_obj[1] ;
35638
35639 if (!args) SWIG_fail;
35640 swig_obj[0] = args;
35641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35642 if (!SWIG_IsOK(res1)) {
35643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35644 }
35645 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35646 {
35647 PyThreadState* __tstate = wxPyBeginAllowThreads();
35648 (arg1)->Clear();
35649 wxPyEndAllowThreads(__tstate);
35650 if (PyErr_Occurred()) SWIG_fail;
35651 }
35652 resultobj = SWIG_Py_Void();
35653 return resultobj;
35654 fail:
35655 return NULL;
35656 }
35657
35658
35659 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35660 PyObject *resultobj = 0;
35661 wxClipboard *arg1 = (wxClipboard *) 0 ;
35662 bool result;
35663 void *argp1 = 0 ;
35664 int res1 = 0 ;
35665 PyObject *swig_obj[1] ;
35666
35667 if (!args) SWIG_fail;
35668 swig_obj[0] = args;
35669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35670 if (!SWIG_IsOK(res1)) {
35671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35672 }
35673 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35674 {
35675 PyThreadState* __tstate = wxPyBeginAllowThreads();
35676 result = (bool)(arg1)->Flush();
35677 wxPyEndAllowThreads(__tstate);
35678 if (PyErr_Occurred()) SWIG_fail;
35679 }
35680 {
35681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35682 }
35683 return resultobj;
35684 fail:
35685 return NULL;
35686 }
35687
35688
35689 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35690 PyObject *resultobj = 0;
35691 wxClipboard *arg1 = (wxClipboard *) 0 ;
35692 bool arg2 = (bool) true ;
35693 void *argp1 = 0 ;
35694 int res1 = 0 ;
35695 bool val2 ;
35696 int ecode2 = 0 ;
35697 PyObject * obj0 = 0 ;
35698 PyObject * obj1 = 0 ;
35699 char * kwnames[] = {
35700 (char *) "self",(char *) "primary", NULL
35701 };
35702
35703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35705 if (!SWIG_IsOK(res1)) {
35706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35707 }
35708 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35709 if (obj1) {
35710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35711 if (!SWIG_IsOK(ecode2)) {
35712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35713 }
35714 arg2 = static_cast< bool >(val2);
35715 }
35716 {
35717 PyThreadState* __tstate = wxPyBeginAllowThreads();
35718 (arg1)->UsePrimarySelection(arg2);
35719 wxPyEndAllowThreads(__tstate);
35720 if (PyErr_Occurred()) SWIG_fail;
35721 }
35722 resultobj = SWIG_Py_Void();
35723 return resultobj;
35724 fail:
35725 return NULL;
35726 }
35727
35728
35729 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35730 PyObject *resultobj = 0;
35731 wxClipboard *result = 0 ;
35732
35733 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35734 {
35735 PyThreadState* __tstate = wxPyBeginAllowThreads();
35736 result = (wxClipboard *)wxClipboard::Get();
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35741 return resultobj;
35742 fail:
35743 return NULL;
35744 }
35745
35746
35747 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35748 PyObject *obj;
35749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35750 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35751 return SWIG_Py_Void();
35752 }
35753
35754 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35755 return SWIG_Python_InitShadowInstance(args);
35756 }
35757
35758 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35759 PyObject *resultobj = 0;
35760 wxClipboard *arg1 = (wxClipboard *) NULL ;
35761 wxClipboardLocker *result = 0 ;
35762 void *argp1 = 0 ;
35763 int res1 = 0 ;
35764 PyObject * obj0 = 0 ;
35765 char * kwnames[] = {
35766 (char *) "clipboard", NULL
35767 };
35768
35769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35770 if (obj0) {
35771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35772 if (!SWIG_IsOK(res1)) {
35773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35774 }
35775 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35776 }
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35791 PyObject *resultobj = 0;
35792 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35793 void *argp1 = 0 ;
35794 int res1 = 0 ;
35795 PyObject *swig_obj[1] ;
35796
35797 if (!args) SWIG_fail;
35798 swig_obj[0] = args;
35799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35800 if (!SWIG_IsOK(res1)) {
35801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35802 }
35803 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 delete arg1;
35807
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 resultobj = SWIG_Py_Void();
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35819 PyObject *resultobj = 0;
35820 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35821 bool result;
35822 void *argp1 = 0 ;
35823 int res1 = 0 ;
35824 PyObject *swig_obj[1] ;
35825
35826 if (!args) SWIG_fail;
35827 swig_obj[0] = args;
35828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35829 if (!SWIG_IsOK(res1)) {
35830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35831 }
35832 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35833 {
35834 PyThreadState* __tstate = wxPyBeginAllowThreads();
35835 result = (bool)wxClipboardLocker___nonzero__(arg1);
35836 wxPyEndAllowThreads(__tstate);
35837 if (PyErr_Occurred()) SWIG_fail;
35838 }
35839 {
35840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35841 }
35842 return resultobj;
35843 fail:
35844 return NULL;
35845 }
35846
35847
35848 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35849 PyObject *obj;
35850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35851 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35852 return SWIG_Py_Void();
35853 }
35854
35855 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35856 return SWIG_Python_InitShadowInstance(args);
35857 }
35858
35859 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35860 PyObject *resultobj = 0;
35861 int arg1 = (int) 0 ;
35862 int arg2 = (int) 0 ;
35863 int arg3 = (int) 0 ;
35864 int arg4 = (int) 0 ;
35865 wxVideoMode *result = 0 ;
35866 int val1 ;
35867 int ecode1 = 0 ;
35868 int val2 ;
35869 int ecode2 = 0 ;
35870 int val3 ;
35871 int ecode3 = 0 ;
35872 int val4 ;
35873 int ecode4 = 0 ;
35874 PyObject * obj0 = 0 ;
35875 PyObject * obj1 = 0 ;
35876 PyObject * obj2 = 0 ;
35877 PyObject * obj3 = 0 ;
35878 char * kwnames[] = {
35879 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35880 };
35881
35882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35883 if (obj0) {
35884 ecode1 = SWIG_AsVal_int(obj0, &val1);
35885 if (!SWIG_IsOK(ecode1)) {
35886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35887 }
35888 arg1 = static_cast< int >(val1);
35889 }
35890 if (obj1) {
35891 ecode2 = SWIG_AsVal_int(obj1, &val2);
35892 if (!SWIG_IsOK(ecode2)) {
35893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35894 }
35895 arg2 = static_cast< int >(val2);
35896 }
35897 if (obj2) {
35898 ecode3 = SWIG_AsVal_int(obj2, &val3);
35899 if (!SWIG_IsOK(ecode3)) {
35900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35901 }
35902 arg3 = static_cast< int >(val3);
35903 }
35904 if (obj3) {
35905 ecode4 = SWIG_AsVal_int(obj3, &val4);
35906 if (!SWIG_IsOK(ecode4)) {
35907 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35908 }
35909 arg4 = static_cast< int >(val4);
35910 }
35911 {
35912 PyThreadState* __tstate = wxPyBeginAllowThreads();
35913 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35914 wxPyEndAllowThreads(__tstate);
35915 if (PyErr_Occurred()) SWIG_fail;
35916 }
35917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35918 return resultobj;
35919 fail:
35920 return NULL;
35921 }
35922
35923
35924 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35925 PyObject *resultobj = 0;
35926 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 PyObject *swig_obj[1] ;
35930
35931 if (!args) SWIG_fail;
35932 swig_obj[0] = args;
35933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35934 if (!SWIG_IsOK(res1)) {
35935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35936 }
35937 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35938 {
35939 PyThreadState* __tstate = wxPyBeginAllowThreads();
35940 delete arg1;
35941
35942 wxPyEndAllowThreads(__tstate);
35943 if (PyErr_Occurred()) SWIG_fail;
35944 }
35945 resultobj = SWIG_Py_Void();
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35953 PyObject *resultobj = 0;
35954 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35955 wxVideoMode *arg2 = 0 ;
35956 bool result;
35957 void *argp1 = 0 ;
35958 int res1 = 0 ;
35959 void *argp2 = 0 ;
35960 int res2 = 0 ;
35961 PyObject * obj0 = 0 ;
35962 PyObject * obj1 = 0 ;
35963 char * kwnames[] = {
35964 (char *) "self",(char *) "other", NULL
35965 };
35966
35967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35969 if (!SWIG_IsOK(res1)) {
35970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35971 }
35972 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35973 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35974 if (!SWIG_IsOK(res2)) {
35975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35976 }
35977 if (!argp2) {
35978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35979 }
35980 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35984 wxPyEndAllowThreads(__tstate);
35985 if (PyErr_Occurred()) SWIG_fail;
35986 }
35987 {
35988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35989 }
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35997 PyObject *resultobj = 0;
35998 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35999 int result;
36000 void *argp1 = 0 ;
36001 int res1 = 0 ;
36002 PyObject *swig_obj[1] ;
36003
36004 if (!args) SWIG_fail;
36005 swig_obj[0] = args;
36006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36007 if (!SWIG_IsOK(res1)) {
36008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36009 }
36010 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36011 {
36012 PyThreadState* __tstate = wxPyBeginAllowThreads();
36013 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36014 wxPyEndAllowThreads(__tstate);
36015 if (PyErr_Occurred()) SWIG_fail;
36016 }
36017 resultobj = SWIG_From_int(static_cast< int >(result));
36018 return resultobj;
36019 fail:
36020 return NULL;
36021 }
36022
36023
36024 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36025 PyObject *resultobj = 0;
36026 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36027 int result;
36028 void *argp1 = 0 ;
36029 int res1 = 0 ;
36030 PyObject *swig_obj[1] ;
36031
36032 if (!args) SWIG_fail;
36033 swig_obj[0] = args;
36034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36035 if (!SWIG_IsOK(res1)) {
36036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36037 }
36038 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36039 {
36040 PyThreadState* __tstate = wxPyBeginAllowThreads();
36041 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36042 wxPyEndAllowThreads(__tstate);
36043 if (PyErr_Occurred()) SWIG_fail;
36044 }
36045 resultobj = SWIG_From_int(static_cast< int >(result));
36046 return resultobj;
36047 fail:
36048 return NULL;
36049 }
36050
36051
36052 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36053 PyObject *resultobj = 0;
36054 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36055 int result;
36056 void *argp1 = 0 ;
36057 int res1 = 0 ;
36058 PyObject *swig_obj[1] ;
36059
36060 if (!args) SWIG_fail;
36061 swig_obj[0] = args;
36062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36063 if (!SWIG_IsOK(res1)) {
36064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36065 }
36066 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36070 wxPyEndAllowThreads(__tstate);
36071 if (PyErr_Occurred()) SWIG_fail;
36072 }
36073 resultobj = SWIG_From_int(static_cast< int >(result));
36074 return resultobj;
36075 fail:
36076 return NULL;
36077 }
36078
36079
36080 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36081 PyObject *resultobj = 0;
36082 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36083 bool result;
36084 void *argp1 = 0 ;
36085 int res1 = 0 ;
36086 PyObject *swig_obj[1] ;
36087
36088 if (!args) SWIG_fail;
36089 swig_obj[0] = args;
36090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36091 if (!SWIG_IsOK(res1)) {
36092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36093 }
36094 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36095 {
36096 PyThreadState* __tstate = wxPyBeginAllowThreads();
36097 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36098 wxPyEndAllowThreads(__tstate);
36099 if (PyErr_Occurred()) SWIG_fail;
36100 }
36101 {
36102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36103 }
36104 return resultobj;
36105 fail:
36106 return NULL;
36107 }
36108
36109
36110 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36111 PyObject *resultobj = 0;
36112 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36113 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36114 bool result;
36115 void *argp1 = 0 ;
36116 int res1 = 0 ;
36117 void *argp2 = 0 ;
36118 int res2 = 0 ;
36119 PyObject * obj0 = 0 ;
36120 PyObject * obj1 = 0 ;
36121 char * kwnames[] = {
36122 (char *) "self",(char *) "other", NULL
36123 };
36124
36125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36127 if (!SWIG_IsOK(res1)) {
36128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36129 }
36130 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36131 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36132 if (!SWIG_IsOK(res2)) {
36133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36134 }
36135 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36136 {
36137 PyThreadState* __tstate = wxPyBeginAllowThreads();
36138 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36139 wxPyEndAllowThreads(__tstate);
36140 if (PyErr_Occurred()) SWIG_fail;
36141 }
36142 {
36143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36144 }
36145 return resultobj;
36146 fail:
36147 return NULL;
36148 }
36149
36150
36151 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36152 PyObject *resultobj = 0;
36153 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36154 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36155 bool result;
36156 void *argp1 = 0 ;
36157 int res1 = 0 ;
36158 void *argp2 = 0 ;
36159 int res2 = 0 ;
36160 PyObject * obj0 = 0 ;
36161 PyObject * obj1 = 0 ;
36162 char * kwnames[] = {
36163 (char *) "self",(char *) "other", NULL
36164 };
36165
36166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36168 if (!SWIG_IsOK(res1)) {
36169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36170 }
36171 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36173 if (!SWIG_IsOK(res2)) {
36174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36175 }
36176 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36177 {
36178 PyThreadState* __tstate = wxPyBeginAllowThreads();
36179 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36180 wxPyEndAllowThreads(__tstate);
36181 if (PyErr_Occurred()) SWIG_fail;
36182 }
36183 {
36184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36185 }
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36193 PyObject *resultobj = 0;
36194 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36195 int arg2 ;
36196 void *argp1 = 0 ;
36197 int res1 = 0 ;
36198 int val2 ;
36199 int ecode2 = 0 ;
36200 PyObject *swig_obj[2] ;
36201
36202 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36204 if (!SWIG_IsOK(res1)) {
36205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36206 }
36207 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36208 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36209 if (!SWIG_IsOK(ecode2)) {
36210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36211 }
36212 arg2 = static_cast< int >(val2);
36213 if (arg1) (arg1)->w = arg2;
36214
36215 resultobj = SWIG_Py_Void();
36216 return resultobj;
36217 fail:
36218 return NULL;
36219 }
36220
36221
36222 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36223 PyObject *resultobj = 0;
36224 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36225 int result;
36226 void *argp1 = 0 ;
36227 int res1 = 0 ;
36228 PyObject *swig_obj[1] ;
36229
36230 if (!args) SWIG_fail;
36231 swig_obj[0] = args;
36232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36233 if (!SWIG_IsOK(res1)) {
36234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36235 }
36236 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36237 result = (int) ((arg1)->w);
36238 resultobj = SWIG_From_int(static_cast< int >(result));
36239 return resultobj;
36240 fail:
36241 return NULL;
36242 }
36243
36244
36245 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36246 PyObject *resultobj = 0;
36247 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36248 int arg2 ;
36249 void *argp1 = 0 ;
36250 int res1 = 0 ;
36251 int val2 ;
36252 int ecode2 = 0 ;
36253 PyObject *swig_obj[2] ;
36254
36255 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36257 if (!SWIG_IsOK(res1)) {
36258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36259 }
36260 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36261 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36262 if (!SWIG_IsOK(ecode2)) {
36263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36264 }
36265 arg2 = static_cast< int >(val2);
36266 if (arg1) (arg1)->h = arg2;
36267
36268 resultobj = SWIG_Py_Void();
36269 return resultobj;
36270 fail:
36271 return NULL;
36272 }
36273
36274
36275 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36276 PyObject *resultobj = 0;
36277 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36278 int result;
36279 void *argp1 = 0 ;
36280 int res1 = 0 ;
36281 PyObject *swig_obj[1] ;
36282
36283 if (!args) SWIG_fail;
36284 swig_obj[0] = args;
36285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36286 if (!SWIG_IsOK(res1)) {
36287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36288 }
36289 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36290 result = (int) ((arg1)->h);
36291 resultobj = SWIG_From_int(static_cast< int >(result));
36292 return resultobj;
36293 fail:
36294 return NULL;
36295 }
36296
36297
36298 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36299 PyObject *resultobj = 0;
36300 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36301 int arg2 ;
36302 void *argp1 = 0 ;
36303 int res1 = 0 ;
36304 int val2 ;
36305 int ecode2 = 0 ;
36306 PyObject *swig_obj[2] ;
36307
36308 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36310 if (!SWIG_IsOK(res1)) {
36311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36312 }
36313 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36314 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36315 if (!SWIG_IsOK(ecode2)) {
36316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36317 }
36318 arg2 = static_cast< int >(val2);
36319 if (arg1) (arg1)->bpp = arg2;
36320
36321 resultobj = SWIG_Py_Void();
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36329 PyObject *resultobj = 0;
36330 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36331 int result;
36332 void *argp1 = 0 ;
36333 int res1 = 0 ;
36334 PyObject *swig_obj[1] ;
36335
36336 if (!args) SWIG_fail;
36337 swig_obj[0] = args;
36338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36339 if (!SWIG_IsOK(res1)) {
36340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36341 }
36342 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36343 result = (int) ((arg1)->bpp);
36344 resultobj = SWIG_From_int(static_cast< int >(result));
36345 return resultobj;
36346 fail:
36347 return NULL;
36348 }
36349
36350
36351 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36352 PyObject *resultobj = 0;
36353 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36354 int arg2 ;
36355 void *argp1 = 0 ;
36356 int res1 = 0 ;
36357 int val2 ;
36358 int ecode2 = 0 ;
36359 PyObject *swig_obj[2] ;
36360
36361 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36363 if (!SWIG_IsOK(res1)) {
36364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36365 }
36366 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36367 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36368 if (!SWIG_IsOK(ecode2)) {
36369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36370 }
36371 arg2 = static_cast< int >(val2);
36372 if (arg1) (arg1)->refresh = arg2;
36373
36374 resultobj = SWIG_Py_Void();
36375 return resultobj;
36376 fail:
36377 return NULL;
36378 }
36379
36380
36381 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36382 PyObject *resultobj = 0;
36383 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36384 int result;
36385 void *argp1 = 0 ;
36386 int res1 = 0 ;
36387 PyObject *swig_obj[1] ;
36388
36389 if (!args) SWIG_fail;
36390 swig_obj[0] = args;
36391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36392 if (!SWIG_IsOK(res1)) {
36393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36394 }
36395 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36396 result = (int) ((arg1)->refresh);
36397 resultobj = SWIG_From_int(static_cast< int >(result));
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36405 PyObject *obj;
36406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36407 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36408 return SWIG_Py_Void();
36409 }
36410
36411 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36412 return SWIG_Python_InitShadowInstance(args);
36413 }
36414
36415 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36416 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36417 return 1;
36418 }
36419
36420
36421 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36422 PyObject *pyobj = 0;
36423
36424 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36425 return pyobj;
36426 }
36427
36428
36429 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36430 PyObject *resultobj = 0;
36431 unsigned int arg1 = (unsigned int) 0 ;
36432 wxDisplay *result = 0 ;
36433 unsigned int val1 ;
36434 int ecode1 = 0 ;
36435 PyObject * obj0 = 0 ;
36436 char * kwnames[] = {
36437 (char *) "index", NULL
36438 };
36439
36440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36441 if (obj0) {
36442 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36443 if (!SWIG_IsOK(ecode1)) {
36444 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36445 }
36446 arg1 = static_cast< unsigned int >(val1);
36447 }
36448 {
36449 PyThreadState* __tstate = wxPyBeginAllowThreads();
36450 result = (wxDisplay *)new wxDisplay(arg1);
36451 wxPyEndAllowThreads(__tstate);
36452 if (PyErr_Occurred()) SWIG_fail;
36453 }
36454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36455 return resultobj;
36456 fail:
36457 return NULL;
36458 }
36459
36460
36461 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36462 PyObject *resultobj = 0;
36463 wxDisplay *arg1 = (wxDisplay *) 0 ;
36464 void *argp1 = 0 ;
36465 int res1 = 0 ;
36466 PyObject *swig_obj[1] ;
36467
36468 if (!args) SWIG_fail;
36469 swig_obj[0] = args;
36470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36471 if (!SWIG_IsOK(res1)) {
36472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36473 }
36474 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36475 {
36476 PyThreadState* __tstate = wxPyBeginAllowThreads();
36477 delete arg1;
36478
36479 wxPyEndAllowThreads(__tstate);
36480 if (PyErr_Occurred()) SWIG_fail;
36481 }
36482 resultobj = SWIG_Py_Void();
36483 return resultobj;
36484 fail:
36485 return NULL;
36486 }
36487
36488
36489 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36490 PyObject *resultobj = 0;
36491 unsigned int result;
36492
36493 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36494 {
36495 PyThreadState* __tstate = wxPyBeginAllowThreads();
36496 result = (unsigned int)wxDisplay::GetCount();
36497 wxPyEndAllowThreads(__tstate);
36498 if (PyErr_Occurred()) SWIG_fail;
36499 }
36500 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36501 return resultobj;
36502 fail:
36503 return NULL;
36504 }
36505
36506
36507 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36508 PyObject *resultobj = 0;
36509 wxPoint *arg1 = 0 ;
36510 int result;
36511 wxPoint temp1 ;
36512 PyObject * obj0 = 0 ;
36513 char * kwnames[] = {
36514 (char *) "pt", NULL
36515 };
36516
36517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36518 {
36519 arg1 = &temp1;
36520 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36521 }
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 resultobj = SWIG_From_int(static_cast< int >(result));
36529 return resultobj;
36530 fail:
36531 return NULL;
36532 }
36533
36534
36535 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36536 PyObject *resultobj = 0;
36537 wxWindow *arg1 = (wxWindow *) 0 ;
36538 int result;
36539 void *argp1 = 0 ;
36540 int res1 = 0 ;
36541 PyObject * obj0 = 0 ;
36542 char * kwnames[] = {
36543 (char *) "window", NULL
36544 };
36545
36546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36548 if (!SWIG_IsOK(res1)) {
36549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36550 }
36551 arg1 = reinterpret_cast< wxWindow * >(argp1);
36552 {
36553 PyThreadState* __tstate = wxPyBeginAllowThreads();
36554 result = (int)wxDisplay::GetFromWindow(arg1);
36555 wxPyEndAllowThreads(__tstate);
36556 if (PyErr_Occurred()) SWIG_fail;
36557 }
36558 resultobj = SWIG_From_int(static_cast< int >(result));
36559 return resultobj;
36560 fail:
36561 return NULL;
36562 }
36563
36564
36565 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36566 PyObject *resultobj = 0;
36567 wxDisplay *arg1 = (wxDisplay *) 0 ;
36568 bool result;
36569 void *argp1 = 0 ;
36570 int res1 = 0 ;
36571 PyObject *swig_obj[1] ;
36572
36573 if (!args) SWIG_fail;
36574 swig_obj[0] = args;
36575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36576 if (!SWIG_IsOK(res1)) {
36577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36578 }
36579 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36580 {
36581 PyThreadState* __tstate = wxPyBeginAllowThreads();
36582 result = (bool)((wxDisplay const *)arg1)->IsOk();
36583 wxPyEndAllowThreads(__tstate);
36584 if (PyErr_Occurred()) SWIG_fail;
36585 }
36586 {
36587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36588 }
36589 return resultobj;
36590 fail:
36591 return NULL;
36592 }
36593
36594
36595 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36596 PyObject *resultobj = 0;
36597 wxDisplay *arg1 = (wxDisplay *) 0 ;
36598 wxRect result;
36599 void *argp1 = 0 ;
36600 int res1 = 0 ;
36601 PyObject *swig_obj[1] ;
36602
36603 if (!args) SWIG_fail;
36604 swig_obj[0] = args;
36605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36606 if (!SWIG_IsOK(res1)) {
36607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36608 }
36609 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 result = ((wxDisplay const *)arg1)->GetGeometry();
36613 wxPyEndAllowThreads(__tstate);
36614 if (PyErr_Occurred()) SWIG_fail;
36615 }
36616 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36617 return resultobj;
36618 fail:
36619 return NULL;
36620 }
36621
36622
36623 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36624 PyObject *resultobj = 0;
36625 wxDisplay *arg1 = (wxDisplay *) 0 ;
36626 wxRect result;
36627 void *argp1 = 0 ;
36628 int res1 = 0 ;
36629 PyObject *swig_obj[1] ;
36630
36631 if (!args) SWIG_fail;
36632 swig_obj[0] = args;
36633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36634 if (!SWIG_IsOK(res1)) {
36635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36636 }
36637 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36638 {
36639 PyThreadState* __tstate = wxPyBeginAllowThreads();
36640 result = ((wxDisplay const *)arg1)->GetClientArea();
36641 wxPyEndAllowThreads(__tstate);
36642 if (PyErr_Occurred()) SWIG_fail;
36643 }
36644 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36645 return resultobj;
36646 fail:
36647 return NULL;
36648 }
36649
36650
36651 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36652 PyObject *resultobj = 0;
36653 wxDisplay *arg1 = (wxDisplay *) 0 ;
36654 wxString result;
36655 void *argp1 = 0 ;
36656 int res1 = 0 ;
36657 PyObject *swig_obj[1] ;
36658
36659 if (!args) SWIG_fail;
36660 swig_obj[0] = args;
36661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36662 if (!SWIG_IsOK(res1)) {
36663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36664 }
36665 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36666 {
36667 PyThreadState* __tstate = wxPyBeginAllowThreads();
36668 result = ((wxDisplay const *)arg1)->GetName();
36669 wxPyEndAllowThreads(__tstate);
36670 if (PyErr_Occurred()) SWIG_fail;
36671 }
36672 {
36673 #if wxUSE_UNICODE
36674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36675 #else
36676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36677 #endif
36678 }
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36686 PyObject *resultobj = 0;
36687 wxDisplay *arg1 = (wxDisplay *) 0 ;
36688 bool result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 PyObject *swig_obj[1] ;
36692
36693 if (!args) SWIG_fail;
36694 swig_obj[0] = args;
36695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36696 if (!SWIG_IsOK(res1)) {
36697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36698 }
36699 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 {
36707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36708 }
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36716 PyObject *resultobj = 0;
36717 wxDisplay *arg1 = (wxDisplay *) 0 ;
36718 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36719 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36720 PyObject *result = 0 ;
36721 void *argp1 = 0 ;
36722 int res1 = 0 ;
36723 void *argp2 = 0 ;
36724 int res2 = 0 ;
36725 PyObject * obj0 = 0 ;
36726 PyObject * obj1 = 0 ;
36727 char * kwnames[] = {
36728 (char *) "self",(char *) "mode", NULL
36729 };
36730
36731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36733 if (!SWIG_IsOK(res1)) {
36734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36735 }
36736 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36737 if (obj1) {
36738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36739 if (!SWIG_IsOK(res2)) {
36740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36741 }
36742 if (!argp2) {
36743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36744 }
36745 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36746 }
36747 {
36748 PyThreadState* __tstate = wxPyBeginAllowThreads();
36749 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36750 wxPyEndAllowThreads(__tstate);
36751 if (PyErr_Occurred()) SWIG_fail;
36752 }
36753 resultobj = result;
36754 return resultobj;
36755 fail:
36756 return NULL;
36757 }
36758
36759
36760 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36761 PyObject *resultobj = 0;
36762 wxDisplay *arg1 = (wxDisplay *) 0 ;
36763 wxVideoMode result;
36764 void *argp1 = 0 ;
36765 int res1 = 0 ;
36766 PyObject *swig_obj[1] ;
36767
36768 if (!args) SWIG_fail;
36769 swig_obj[0] = args;
36770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36771 if (!SWIG_IsOK(res1)) {
36772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36773 }
36774 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36775 {
36776 PyThreadState* __tstate = wxPyBeginAllowThreads();
36777 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36778 wxPyEndAllowThreads(__tstate);
36779 if (PyErr_Occurred()) SWIG_fail;
36780 }
36781 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36782 return resultobj;
36783 fail:
36784 return NULL;
36785 }
36786
36787
36788 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36789 PyObject *resultobj = 0;
36790 wxDisplay *arg1 = (wxDisplay *) 0 ;
36791 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36792 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36793 bool result;
36794 void *argp1 = 0 ;
36795 int res1 = 0 ;
36796 void *argp2 = 0 ;
36797 int res2 = 0 ;
36798 PyObject * obj0 = 0 ;
36799 PyObject * obj1 = 0 ;
36800 char * kwnames[] = {
36801 (char *) "self",(char *) "mode", NULL
36802 };
36803
36804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36806 if (!SWIG_IsOK(res1)) {
36807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36808 }
36809 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36810 if (obj1) {
36811 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36812 if (!SWIG_IsOK(res2)) {
36813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36814 }
36815 if (!argp2) {
36816 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36817 }
36818 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36819 }
36820 {
36821 PyThreadState* __tstate = wxPyBeginAllowThreads();
36822 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36823 wxPyEndAllowThreads(__tstate);
36824 if (PyErr_Occurred()) SWIG_fail;
36825 }
36826 {
36827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36828 }
36829 return resultobj;
36830 fail:
36831 return NULL;
36832 }
36833
36834
36835 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36836 PyObject *resultobj = 0;
36837 wxDisplay *arg1 = (wxDisplay *) 0 ;
36838 void *argp1 = 0 ;
36839 int res1 = 0 ;
36840 PyObject *swig_obj[1] ;
36841
36842 if (!args) SWIG_fail;
36843 swig_obj[0] = args;
36844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36845 if (!SWIG_IsOK(res1)) {
36846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36847 }
36848 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36849 {
36850 PyThreadState* __tstate = wxPyBeginAllowThreads();
36851 wxDisplay_ResetMode(arg1);
36852 wxPyEndAllowThreads(__tstate);
36853 if (PyErr_Occurred()) SWIG_fail;
36854 }
36855 resultobj = SWIG_Py_Void();
36856 return resultobj;
36857 fail:
36858 return NULL;
36859 }
36860
36861
36862 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36863 PyObject *obj;
36864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36865 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36866 return SWIG_Py_Void();
36867 }
36868
36869 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36870 return SWIG_Python_InitShadowInstance(args);
36871 }
36872
36873 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36874 PyObject *resultobj = 0;
36875 wxStandardPaths *result = 0 ;
36876
36877 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36878 {
36879 PyThreadState* __tstate = wxPyBeginAllowThreads();
36880 result = (wxStandardPaths *)wxStandardPaths_Get();
36881 wxPyEndAllowThreads(__tstate);
36882 if (PyErr_Occurred()) SWIG_fail;
36883 }
36884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36885 return resultobj;
36886 fail:
36887 return NULL;
36888 }
36889
36890
36891 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36892 PyObject *resultobj = 0;
36893 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36894 wxString result;
36895 void *argp1 = 0 ;
36896 int res1 = 0 ;
36897 PyObject *swig_obj[1] ;
36898
36899 if (!args) SWIG_fail;
36900 swig_obj[0] = args;
36901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36902 if (!SWIG_IsOK(res1)) {
36903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36904 }
36905 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36906 {
36907 PyThreadState* __tstate = wxPyBeginAllowThreads();
36908 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 {
36913 #if wxUSE_UNICODE
36914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36915 #else
36916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36917 #endif
36918 }
36919 return resultobj;
36920 fail:
36921 return NULL;
36922 }
36923
36924
36925 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36926 PyObject *resultobj = 0;
36927 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36928 wxString result;
36929 void *argp1 = 0 ;
36930 int res1 = 0 ;
36931 PyObject *swig_obj[1] ;
36932
36933 if (!args) SWIG_fail;
36934 swig_obj[0] = args;
36935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36936 if (!SWIG_IsOK(res1)) {
36937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36938 }
36939 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36940 {
36941 PyThreadState* __tstate = wxPyBeginAllowThreads();
36942 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36943 wxPyEndAllowThreads(__tstate);
36944 if (PyErr_Occurred()) SWIG_fail;
36945 }
36946 {
36947 #if wxUSE_UNICODE
36948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36949 #else
36950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36951 #endif
36952 }
36953 return resultobj;
36954 fail:
36955 return NULL;
36956 }
36957
36958
36959 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36960 PyObject *resultobj = 0;
36961 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36962 wxString result;
36963 void *argp1 = 0 ;
36964 int res1 = 0 ;
36965 PyObject *swig_obj[1] ;
36966
36967 if (!args) SWIG_fail;
36968 swig_obj[0] = args;
36969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36970 if (!SWIG_IsOK(res1)) {
36971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36972 }
36973 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36974 {
36975 PyThreadState* __tstate = wxPyBeginAllowThreads();
36976 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36977 wxPyEndAllowThreads(__tstate);
36978 if (PyErr_Occurred()) SWIG_fail;
36979 }
36980 {
36981 #if wxUSE_UNICODE
36982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36983 #else
36984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36985 #endif
36986 }
36987 return resultobj;
36988 fail:
36989 return NULL;
36990 }
36991
36992
36993 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36994 PyObject *resultobj = 0;
36995 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36996 wxString result;
36997 void *argp1 = 0 ;
36998 int res1 = 0 ;
36999 PyObject *swig_obj[1] ;
37000
37001 if (!args) SWIG_fail;
37002 swig_obj[0] = args;
37003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37004 if (!SWIG_IsOK(res1)) {
37005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37006 }
37007 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37008 {
37009 PyThreadState* __tstate = wxPyBeginAllowThreads();
37010 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37011 wxPyEndAllowThreads(__tstate);
37012 if (PyErr_Occurred()) SWIG_fail;
37013 }
37014 {
37015 #if wxUSE_UNICODE
37016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37017 #else
37018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37019 #endif
37020 }
37021 return resultobj;
37022 fail:
37023 return NULL;
37024 }
37025
37026
37027 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37028 PyObject *resultobj = 0;
37029 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37030 wxString result;
37031 void *argp1 = 0 ;
37032 int res1 = 0 ;
37033 PyObject *swig_obj[1] ;
37034
37035 if (!args) SWIG_fail;
37036 swig_obj[0] = args;
37037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37038 if (!SWIG_IsOK(res1)) {
37039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37040 }
37041 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37042 {
37043 PyThreadState* __tstate = wxPyBeginAllowThreads();
37044 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37045 wxPyEndAllowThreads(__tstate);
37046 if (PyErr_Occurred()) SWIG_fail;
37047 }
37048 {
37049 #if wxUSE_UNICODE
37050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37051 #else
37052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37053 #endif
37054 }
37055 return resultobj;
37056 fail:
37057 return NULL;
37058 }
37059
37060
37061 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37062 PyObject *resultobj = 0;
37063 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37064 wxString result;
37065 void *argp1 = 0 ;
37066 int res1 = 0 ;
37067 PyObject *swig_obj[1] ;
37068
37069 if (!args) SWIG_fail;
37070 swig_obj[0] = args;
37071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37072 if (!SWIG_IsOK(res1)) {
37073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37074 }
37075 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37076 {
37077 PyThreadState* __tstate = wxPyBeginAllowThreads();
37078 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37079 wxPyEndAllowThreads(__tstate);
37080 if (PyErr_Occurred()) SWIG_fail;
37081 }
37082 {
37083 #if wxUSE_UNICODE
37084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37085 #else
37086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37087 #endif
37088 }
37089 return resultobj;
37090 fail:
37091 return NULL;
37092 }
37093
37094
37095 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37096 PyObject *resultobj = 0;
37097 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37098 wxString result;
37099 void *argp1 = 0 ;
37100 int res1 = 0 ;
37101 PyObject *swig_obj[1] ;
37102
37103 if (!args) SWIG_fail;
37104 swig_obj[0] = args;
37105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37106 if (!SWIG_IsOK(res1)) {
37107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37108 }
37109 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37110 {
37111 PyThreadState* __tstate = wxPyBeginAllowThreads();
37112 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37113 wxPyEndAllowThreads(__tstate);
37114 if (PyErr_Occurred()) SWIG_fail;
37115 }
37116 {
37117 #if wxUSE_UNICODE
37118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37119 #else
37120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37121 #endif
37122 }
37123 return resultobj;
37124 fail:
37125 return NULL;
37126 }
37127
37128
37129 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37130 PyObject *resultobj = 0;
37131 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37132 wxString result;
37133 void *argp1 = 0 ;
37134 int res1 = 0 ;
37135 PyObject *swig_obj[1] ;
37136
37137 if (!args) SWIG_fail;
37138 swig_obj[0] = args;
37139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37140 if (!SWIG_IsOK(res1)) {
37141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37142 }
37143 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37144 {
37145 PyThreadState* __tstate = wxPyBeginAllowThreads();
37146 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37147 wxPyEndAllowThreads(__tstate);
37148 if (PyErr_Occurred()) SWIG_fail;
37149 }
37150 {
37151 #if wxUSE_UNICODE
37152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37153 #else
37154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37155 #endif
37156 }
37157 return resultobj;
37158 fail:
37159 return NULL;
37160 }
37161
37162
37163 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37164 PyObject *resultobj = 0;
37165 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37166 wxString result;
37167 void *argp1 = 0 ;
37168 int res1 = 0 ;
37169 PyObject *swig_obj[1] ;
37170
37171 if (!args) SWIG_fail;
37172 swig_obj[0] = args;
37173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37174 if (!SWIG_IsOK(res1)) {
37175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37176 }
37177 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37178 {
37179 PyThreadState* __tstate = wxPyBeginAllowThreads();
37180 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37181 wxPyEndAllowThreads(__tstate);
37182 if (PyErr_Occurred()) SWIG_fail;
37183 }
37184 {
37185 #if wxUSE_UNICODE
37186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37187 #else
37188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37189 #endif
37190 }
37191 return resultobj;
37192 fail:
37193 return NULL;
37194 }
37195
37196
37197 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37198 PyObject *resultobj = 0;
37199 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37200 wxString *arg2 = 0 ;
37201 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37202 wxString result;
37203 void *argp1 = 0 ;
37204 int res1 = 0 ;
37205 bool temp2 = false ;
37206 int val3 ;
37207 int ecode3 = 0 ;
37208 PyObject * obj0 = 0 ;
37209 PyObject * obj1 = 0 ;
37210 PyObject * obj2 = 0 ;
37211 char * kwnames[] = {
37212 (char *) "self",(char *) "lang",(char *) "category", NULL
37213 };
37214
37215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37217 if (!SWIG_IsOK(res1)) {
37218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37219 }
37220 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37221 {
37222 arg2 = wxString_in_helper(obj1);
37223 if (arg2 == NULL) SWIG_fail;
37224 temp2 = true;
37225 }
37226 if (obj2) {
37227 ecode3 = SWIG_AsVal_int(obj2, &val3);
37228 if (!SWIG_IsOK(ecode3)) {
37229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37230 }
37231 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37232 }
37233 {
37234 PyThreadState* __tstate = wxPyBeginAllowThreads();
37235 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37236 wxPyEndAllowThreads(__tstate);
37237 if (PyErr_Occurred()) SWIG_fail;
37238 }
37239 {
37240 #if wxUSE_UNICODE
37241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37242 #else
37243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37244 #endif
37245 }
37246 {
37247 if (temp2)
37248 delete arg2;
37249 }
37250 return resultobj;
37251 fail:
37252 {
37253 if (temp2)
37254 delete arg2;
37255 }
37256 return NULL;
37257 }
37258
37259
37260 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37261 PyObject *resultobj = 0;
37262 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37263 wxString result;
37264 void *argp1 = 0 ;
37265 int res1 = 0 ;
37266 PyObject *swig_obj[1] ;
37267
37268 if (!args) SWIG_fail;
37269 swig_obj[0] = args;
37270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37271 if (!SWIG_IsOK(res1)) {
37272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37273 }
37274 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37275 {
37276 PyThreadState* __tstate = wxPyBeginAllowThreads();
37277 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37278 wxPyEndAllowThreads(__tstate);
37279 if (PyErr_Occurred()) SWIG_fail;
37280 }
37281 {
37282 #if wxUSE_UNICODE
37283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37284 #else
37285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37286 #endif
37287 }
37288 return resultobj;
37289 fail:
37290 return NULL;
37291 }
37292
37293
37294 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37295 PyObject *resultobj = 0;
37296 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37297 wxString result;
37298 void *argp1 = 0 ;
37299 int res1 = 0 ;
37300 PyObject *swig_obj[1] ;
37301
37302 if (!args) SWIG_fail;
37303 swig_obj[0] = args;
37304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37305 if (!SWIG_IsOK(res1)) {
37306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37307 }
37308 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37309 {
37310 PyThreadState* __tstate = wxPyBeginAllowThreads();
37311 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37312 wxPyEndAllowThreads(__tstate);
37313 if (PyErr_Occurred()) SWIG_fail;
37314 }
37315 {
37316 #if wxUSE_UNICODE
37317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37318 #else
37319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37320 #endif
37321 }
37322 return resultobj;
37323 fail:
37324 return NULL;
37325 }
37326
37327
37328 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37329 PyObject *resultobj = 0;
37330 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37331 wxString *arg2 = 0 ;
37332 void *argp1 = 0 ;
37333 int res1 = 0 ;
37334 bool temp2 = false ;
37335 PyObject * obj0 = 0 ;
37336 PyObject * obj1 = 0 ;
37337 char * kwnames[] = {
37338 (char *) "self",(char *) "prefix", NULL
37339 };
37340
37341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37343 if (!SWIG_IsOK(res1)) {
37344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37345 }
37346 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37347 {
37348 arg2 = wxString_in_helper(obj1);
37349 if (arg2 == NULL) SWIG_fail;
37350 temp2 = true;
37351 }
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37355 wxPyEndAllowThreads(__tstate);
37356 if (PyErr_Occurred()) SWIG_fail;
37357 }
37358 resultobj = SWIG_Py_Void();
37359 {
37360 if (temp2)
37361 delete arg2;
37362 }
37363 return resultobj;
37364 fail:
37365 {
37366 if (temp2)
37367 delete arg2;
37368 }
37369 return NULL;
37370 }
37371
37372
37373 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37374 PyObject *resultobj = 0;
37375 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37376 wxString result;
37377 void *argp1 = 0 ;
37378 int res1 = 0 ;
37379 PyObject *swig_obj[1] ;
37380
37381 if (!args) SWIG_fail;
37382 swig_obj[0] = args;
37383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37384 if (!SWIG_IsOK(res1)) {
37385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37386 }
37387 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37388 {
37389 PyThreadState* __tstate = wxPyBeginAllowThreads();
37390 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37391 wxPyEndAllowThreads(__tstate);
37392 if (PyErr_Occurred()) SWIG_fail;
37393 }
37394 {
37395 #if wxUSE_UNICODE
37396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37397 #else
37398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37399 #endif
37400 }
37401 return resultobj;
37402 fail:
37403 return NULL;
37404 }
37405
37406
37407 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37408 PyObject *obj;
37409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37410 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37411 return SWIG_Py_Void();
37412 }
37413
37414 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37415 PyObject *resultobj = 0;
37416 wxEventType arg1 ;
37417 wxPowerEvent *result = 0 ;
37418 int val1 ;
37419 int ecode1 = 0 ;
37420 PyObject * obj0 = 0 ;
37421 char * kwnames[] = {
37422 (char *) "evtType", NULL
37423 };
37424
37425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37426 ecode1 = SWIG_AsVal_int(obj0, &val1);
37427 if (!SWIG_IsOK(ecode1)) {
37428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37429 }
37430 arg1 = static_cast< wxEventType >(val1);
37431 {
37432 PyThreadState* __tstate = wxPyBeginAllowThreads();
37433 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37434 wxPyEndAllowThreads(__tstate);
37435 if (PyErr_Occurred()) SWIG_fail;
37436 }
37437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37438 return resultobj;
37439 fail:
37440 return NULL;
37441 }
37442
37443
37444 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37445 PyObject *resultobj = 0;
37446 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37447 void *argp1 = 0 ;
37448 int res1 = 0 ;
37449 PyObject *swig_obj[1] ;
37450
37451 if (!args) SWIG_fail;
37452 swig_obj[0] = args;
37453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37454 if (!SWIG_IsOK(res1)) {
37455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37456 }
37457 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37458 {
37459 PyThreadState* __tstate = wxPyBeginAllowThreads();
37460 (arg1)->Veto();
37461 wxPyEndAllowThreads(__tstate);
37462 if (PyErr_Occurred()) SWIG_fail;
37463 }
37464 resultobj = SWIG_Py_Void();
37465 return resultobj;
37466 fail:
37467 return NULL;
37468 }
37469
37470
37471 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37472 PyObject *resultobj = 0;
37473 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37474 bool result;
37475 void *argp1 = 0 ;
37476 int res1 = 0 ;
37477 PyObject *swig_obj[1] ;
37478
37479 if (!args) SWIG_fail;
37480 swig_obj[0] = args;
37481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37482 if (!SWIG_IsOK(res1)) {
37483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37484 }
37485 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37486 {
37487 PyThreadState* __tstate = wxPyBeginAllowThreads();
37488 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37489 wxPyEndAllowThreads(__tstate);
37490 if (PyErr_Occurred()) SWIG_fail;
37491 }
37492 {
37493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37494 }
37495 return resultobj;
37496 fail:
37497 return NULL;
37498 }
37499
37500
37501 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37502 PyObject *obj;
37503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37504 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37505 return SWIG_Py_Void();
37506 }
37507
37508 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37509 return SWIG_Python_InitShadowInstance(args);
37510 }
37511
37512 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37513 PyObject *resultobj = 0;
37514 wxPowerType result;
37515
37516 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37517 {
37518 PyThreadState* __tstate = wxPyBeginAllowThreads();
37519 result = (wxPowerType)wxGetPowerType();
37520 wxPyEndAllowThreads(__tstate);
37521 if (PyErr_Occurred()) SWIG_fail;
37522 }
37523 resultobj = SWIG_From_int(static_cast< int >(result));
37524 return resultobj;
37525 fail:
37526 return NULL;
37527 }
37528
37529
37530 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37531 PyObject *resultobj = 0;
37532 wxBatteryState result;
37533
37534 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 result = (wxBatteryState)wxGetBatteryState();
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 resultobj = SWIG_From_int(static_cast< int >(result));
37542 return resultobj;
37543 fail:
37544 return NULL;
37545 }
37546
37547
37548 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37549 PyObject *resultobj = 0;
37550 wxAboutDialogInfo *result = 0 ;
37551
37552 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37560 return resultobj;
37561 fail:
37562 return NULL;
37563 }
37564
37565
37566 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37567 PyObject *resultobj = 0;
37568 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37569 void *argp1 = 0 ;
37570 int res1 = 0 ;
37571 PyObject *swig_obj[1] ;
37572
37573 if (!args) SWIG_fail;
37574 swig_obj[0] = args;
37575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37576 if (!SWIG_IsOK(res1)) {
37577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37578 }
37579 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37580 {
37581 PyThreadState* __tstate = wxPyBeginAllowThreads();
37582 delete arg1;
37583
37584 wxPyEndAllowThreads(__tstate);
37585 if (PyErr_Occurred()) SWIG_fail;
37586 }
37587 resultobj = SWIG_Py_Void();
37588 return resultobj;
37589 fail:
37590 return NULL;
37591 }
37592
37593
37594 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37595 PyObject *resultobj = 0;
37596 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37597 wxString *arg2 = 0 ;
37598 void *argp1 = 0 ;
37599 int res1 = 0 ;
37600 bool temp2 = false ;
37601 PyObject * obj0 = 0 ;
37602 PyObject * obj1 = 0 ;
37603 char * kwnames[] = {
37604 (char *) "self",(char *) "name", NULL
37605 };
37606
37607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37609 if (!SWIG_IsOK(res1)) {
37610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37611 }
37612 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37613 {
37614 arg2 = wxString_in_helper(obj1);
37615 if (arg2 == NULL) SWIG_fail;
37616 temp2 = true;
37617 }
37618 {
37619 PyThreadState* __tstate = wxPyBeginAllowThreads();
37620 (arg1)->SetName((wxString const &)*arg2);
37621 wxPyEndAllowThreads(__tstate);
37622 if (PyErr_Occurred()) SWIG_fail;
37623 }
37624 resultobj = SWIG_Py_Void();
37625 {
37626 if (temp2)
37627 delete arg2;
37628 }
37629 return resultobj;
37630 fail:
37631 {
37632 if (temp2)
37633 delete arg2;
37634 }
37635 return NULL;
37636 }
37637
37638
37639 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37640 PyObject *resultobj = 0;
37641 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37642 wxString result;
37643 void *argp1 = 0 ;
37644 int res1 = 0 ;
37645 PyObject *swig_obj[1] ;
37646
37647 if (!args) SWIG_fail;
37648 swig_obj[0] = args;
37649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37650 if (!SWIG_IsOK(res1)) {
37651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37652 }
37653 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 {
37661 #if wxUSE_UNICODE
37662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37663 #else
37664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37665 #endif
37666 }
37667 return resultobj;
37668 fail:
37669 return NULL;
37670 }
37671
37672
37673 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37674 PyObject *resultobj = 0;
37675 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37676 wxString *arg2 = 0 ;
37677 void *argp1 = 0 ;
37678 int res1 = 0 ;
37679 bool temp2 = false ;
37680 PyObject * obj0 = 0 ;
37681 PyObject * obj1 = 0 ;
37682 char * kwnames[] = {
37683 (char *) "self",(char *) "version", NULL
37684 };
37685
37686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37688 if (!SWIG_IsOK(res1)) {
37689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37690 }
37691 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37692 {
37693 arg2 = wxString_in_helper(obj1);
37694 if (arg2 == NULL) SWIG_fail;
37695 temp2 = true;
37696 }
37697 {
37698 PyThreadState* __tstate = wxPyBeginAllowThreads();
37699 (arg1)->SetVersion((wxString const &)*arg2);
37700 wxPyEndAllowThreads(__tstate);
37701 if (PyErr_Occurred()) SWIG_fail;
37702 }
37703 resultobj = SWIG_Py_Void();
37704 {
37705 if (temp2)
37706 delete arg2;
37707 }
37708 return resultobj;
37709 fail:
37710 {
37711 if (temp2)
37712 delete arg2;
37713 }
37714 return NULL;
37715 }
37716
37717
37718 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37719 PyObject *resultobj = 0;
37720 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37721 bool result;
37722 void *argp1 = 0 ;
37723 int res1 = 0 ;
37724 PyObject *swig_obj[1] ;
37725
37726 if (!args) SWIG_fail;
37727 swig_obj[0] = args;
37728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37729 if (!SWIG_IsOK(res1)) {
37730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37731 }
37732 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37733 {
37734 PyThreadState* __tstate = wxPyBeginAllowThreads();
37735 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37736 wxPyEndAllowThreads(__tstate);
37737 if (PyErr_Occurred()) SWIG_fail;
37738 }
37739 {
37740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37741 }
37742 return resultobj;
37743 fail:
37744 return NULL;
37745 }
37746
37747
37748 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37749 PyObject *resultobj = 0;
37750 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37751 wxString result;
37752 void *argp1 = 0 ;
37753 int res1 = 0 ;
37754 PyObject *swig_obj[1] ;
37755
37756 if (!args) SWIG_fail;
37757 swig_obj[0] = args;
37758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37759 if (!SWIG_IsOK(res1)) {
37760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37761 }
37762 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37763 {
37764 PyThreadState* __tstate = wxPyBeginAllowThreads();
37765 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37766 wxPyEndAllowThreads(__tstate);
37767 if (PyErr_Occurred()) SWIG_fail;
37768 }
37769 {
37770 #if wxUSE_UNICODE
37771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37772 #else
37773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37774 #endif
37775 }
37776 return resultobj;
37777 fail:
37778 return NULL;
37779 }
37780
37781
37782 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37783 PyObject *resultobj = 0;
37784 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37785 wxString *arg2 = 0 ;
37786 void *argp1 = 0 ;
37787 int res1 = 0 ;
37788 bool temp2 = false ;
37789 PyObject * obj0 = 0 ;
37790 PyObject * obj1 = 0 ;
37791 char * kwnames[] = {
37792 (char *) "self",(char *) "desc", NULL
37793 };
37794
37795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37797 if (!SWIG_IsOK(res1)) {
37798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37799 }
37800 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37801 {
37802 arg2 = wxString_in_helper(obj1);
37803 if (arg2 == NULL) SWIG_fail;
37804 temp2 = true;
37805 }
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 (arg1)->SetDescription((wxString const &)*arg2);
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 resultobj = SWIG_Py_Void();
37813 {
37814 if (temp2)
37815 delete arg2;
37816 }
37817 return resultobj;
37818 fail:
37819 {
37820 if (temp2)
37821 delete arg2;
37822 }
37823 return NULL;
37824 }
37825
37826
37827 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37828 PyObject *resultobj = 0;
37829 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37830 bool result;
37831 void *argp1 = 0 ;
37832 int res1 = 0 ;
37833 PyObject *swig_obj[1] ;
37834
37835 if (!args) SWIG_fail;
37836 swig_obj[0] = args;
37837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37838 if (!SWIG_IsOK(res1)) {
37839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37840 }
37841 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37842 {
37843 PyThreadState* __tstate = wxPyBeginAllowThreads();
37844 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37845 wxPyEndAllowThreads(__tstate);
37846 if (PyErr_Occurred()) SWIG_fail;
37847 }
37848 {
37849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37850 }
37851 return resultobj;
37852 fail:
37853 return NULL;
37854 }
37855
37856
37857 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37858 PyObject *resultobj = 0;
37859 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37860 wxString result;
37861 void *argp1 = 0 ;
37862 int res1 = 0 ;
37863 PyObject *swig_obj[1] ;
37864
37865 if (!args) SWIG_fail;
37866 swig_obj[0] = args;
37867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37868 if (!SWIG_IsOK(res1)) {
37869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37870 }
37871 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37872 {
37873 PyThreadState* __tstate = wxPyBeginAllowThreads();
37874 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37875 wxPyEndAllowThreads(__tstate);
37876 if (PyErr_Occurred()) SWIG_fail;
37877 }
37878 {
37879 #if wxUSE_UNICODE
37880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37881 #else
37882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37883 #endif
37884 }
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37892 PyObject *resultobj = 0;
37893 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37894 wxString *arg2 = 0 ;
37895 void *argp1 = 0 ;
37896 int res1 = 0 ;
37897 bool temp2 = false ;
37898 PyObject * obj0 = 0 ;
37899 PyObject * obj1 = 0 ;
37900 char * kwnames[] = {
37901 (char *) "self",(char *) "copyright", NULL
37902 };
37903
37904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37906 if (!SWIG_IsOK(res1)) {
37907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37908 }
37909 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37910 {
37911 arg2 = wxString_in_helper(obj1);
37912 if (arg2 == NULL) SWIG_fail;
37913 temp2 = true;
37914 }
37915 {
37916 PyThreadState* __tstate = wxPyBeginAllowThreads();
37917 (arg1)->SetCopyright((wxString const &)*arg2);
37918 wxPyEndAllowThreads(__tstate);
37919 if (PyErr_Occurred()) SWIG_fail;
37920 }
37921 resultobj = SWIG_Py_Void();
37922 {
37923 if (temp2)
37924 delete arg2;
37925 }
37926 return resultobj;
37927 fail:
37928 {
37929 if (temp2)
37930 delete arg2;
37931 }
37932 return NULL;
37933 }
37934
37935
37936 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37937 PyObject *resultobj = 0;
37938 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37939 bool result;
37940 void *argp1 = 0 ;
37941 int res1 = 0 ;
37942 PyObject *swig_obj[1] ;
37943
37944 if (!args) SWIG_fail;
37945 swig_obj[0] = args;
37946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37947 if (!SWIG_IsOK(res1)) {
37948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37949 }
37950 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37951 {
37952 PyThreadState* __tstate = wxPyBeginAllowThreads();
37953 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37954 wxPyEndAllowThreads(__tstate);
37955 if (PyErr_Occurred()) SWIG_fail;
37956 }
37957 {
37958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37959 }
37960 return resultobj;
37961 fail:
37962 return NULL;
37963 }
37964
37965
37966 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37967 PyObject *resultobj = 0;
37968 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37969 wxString result;
37970 void *argp1 = 0 ;
37971 int res1 = 0 ;
37972 PyObject *swig_obj[1] ;
37973
37974 if (!args) SWIG_fail;
37975 swig_obj[0] = args;
37976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37977 if (!SWIG_IsOK(res1)) {
37978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37979 }
37980 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37981 {
37982 PyThreadState* __tstate = wxPyBeginAllowThreads();
37983 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37984 wxPyEndAllowThreads(__tstate);
37985 if (PyErr_Occurred()) SWIG_fail;
37986 }
37987 {
37988 #if wxUSE_UNICODE
37989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37990 #else
37991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37992 #endif
37993 }
37994 return resultobj;
37995 fail:
37996 return NULL;
37997 }
37998
37999
38000 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38001 PyObject *resultobj = 0;
38002 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38003 wxString *arg2 = 0 ;
38004 void *argp1 = 0 ;
38005 int res1 = 0 ;
38006 bool temp2 = false ;
38007 PyObject * obj0 = 0 ;
38008 PyObject * obj1 = 0 ;
38009 char * kwnames[] = {
38010 (char *) "self",(char *) "licence", NULL
38011 };
38012
38013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38015 if (!SWIG_IsOK(res1)) {
38016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38017 }
38018 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38019 {
38020 arg2 = wxString_in_helper(obj1);
38021 if (arg2 == NULL) SWIG_fail;
38022 temp2 = true;
38023 }
38024 {
38025 PyThreadState* __tstate = wxPyBeginAllowThreads();
38026 (arg1)->SetLicence((wxString const &)*arg2);
38027 wxPyEndAllowThreads(__tstate);
38028 if (PyErr_Occurred()) SWIG_fail;
38029 }
38030 resultobj = SWIG_Py_Void();
38031 {
38032 if (temp2)
38033 delete arg2;
38034 }
38035 return resultobj;
38036 fail:
38037 {
38038 if (temp2)
38039 delete arg2;
38040 }
38041 return NULL;
38042 }
38043
38044
38045 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38046 PyObject *resultobj = 0;
38047 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38048 wxString *arg2 = 0 ;
38049 void *argp1 = 0 ;
38050 int res1 = 0 ;
38051 bool temp2 = false ;
38052 PyObject * obj0 = 0 ;
38053 PyObject * obj1 = 0 ;
38054 char * kwnames[] = {
38055 (char *) "self",(char *) "licence", NULL
38056 };
38057
38058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38060 if (!SWIG_IsOK(res1)) {
38061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38062 }
38063 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38064 {
38065 arg2 = wxString_in_helper(obj1);
38066 if (arg2 == NULL) SWIG_fail;
38067 temp2 = true;
38068 }
38069 {
38070 PyThreadState* __tstate = wxPyBeginAllowThreads();
38071 (arg1)->SetLicense((wxString const &)*arg2);
38072 wxPyEndAllowThreads(__tstate);
38073 if (PyErr_Occurred()) SWIG_fail;
38074 }
38075 resultobj = SWIG_Py_Void();
38076 {
38077 if (temp2)
38078 delete arg2;
38079 }
38080 return resultobj;
38081 fail:
38082 {
38083 if (temp2)
38084 delete arg2;
38085 }
38086 return NULL;
38087 }
38088
38089
38090 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38091 PyObject *resultobj = 0;
38092 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38093 bool result;
38094 void *argp1 = 0 ;
38095 int res1 = 0 ;
38096 PyObject *swig_obj[1] ;
38097
38098 if (!args) SWIG_fail;
38099 swig_obj[0] = args;
38100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38101 if (!SWIG_IsOK(res1)) {
38102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38103 }
38104 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38105 {
38106 PyThreadState* __tstate = wxPyBeginAllowThreads();
38107 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38108 wxPyEndAllowThreads(__tstate);
38109 if (PyErr_Occurred()) SWIG_fail;
38110 }
38111 {
38112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38113 }
38114 return resultobj;
38115 fail:
38116 return NULL;
38117 }
38118
38119
38120 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38121 PyObject *resultobj = 0;
38122 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38123 wxString result;
38124 void *argp1 = 0 ;
38125 int res1 = 0 ;
38126 PyObject *swig_obj[1] ;
38127
38128 if (!args) SWIG_fail;
38129 swig_obj[0] = args;
38130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38131 if (!SWIG_IsOK(res1)) {
38132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38133 }
38134 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38135 {
38136 PyThreadState* __tstate = wxPyBeginAllowThreads();
38137 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38138 wxPyEndAllowThreads(__tstate);
38139 if (PyErr_Occurred()) SWIG_fail;
38140 }
38141 {
38142 #if wxUSE_UNICODE
38143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38144 #else
38145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38146 #endif
38147 }
38148 return resultobj;
38149 fail:
38150 return NULL;
38151 }
38152
38153
38154 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38155 PyObject *resultobj = 0;
38156 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38157 wxIcon *arg2 = 0 ;
38158 void *argp1 = 0 ;
38159 int res1 = 0 ;
38160 void *argp2 = 0 ;
38161 int res2 = 0 ;
38162 PyObject * obj0 = 0 ;
38163 PyObject * obj1 = 0 ;
38164 char * kwnames[] = {
38165 (char *) "self",(char *) "icon", NULL
38166 };
38167
38168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38170 if (!SWIG_IsOK(res1)) {
38171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38172 }
38173 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38175 if (!SWIG_IsOK(res2)) {
38176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38177 }
38178 if (!argp2) {
38179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38180 }
38181 arg2 = reinterpret_cast< wxIcon * >(argp2);
38182 {
38183 PyThreadState* __tstate = wxPyBeginAllowThreads();
38184 (arg1)->SetIcon((wxIcon const &)*arg2);
38185 wxPyEndAllowThreads(__tstate);
38186 if (PyErr_Occurred()) SWIG_fail;
38187 }
38188 resultobj = SWIG_Py_Void();
38189 return resultobj;
38190 fail:
38191 return NULL;
38192 }
38193
38194
38195 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38196 PyObject *resultobj = 0;
38197 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38198 bool result;
38199 void *argp1 = 0 ;
38200 int res1 = 0 ;
38201 PyObject *swig_obj[1] ;
38202
38203 if (!args) SWIG_fail;
38204 swig_obj[0] = args;
38205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38206 if (!SWIG_IsOK(res1)) {
38207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38208 }
38209 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38210 {
38211 PyThreadState* __tstate = wxPyBeginAllowThreads();
38212 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38213 wxPyEndAllowThreads(__tstate);
38214 if (PyErr_Occurred()) SWIG_fail;
38215 }
38216 {
38217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38218 }
38219 return resultobj;
38220 fail:
38221 return NULL;
38222 }
38223
38224
38225 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38226 PyObject *resultobj = 0;
38227 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38228 wxIcon result;
38229 void *argp1 = 0 ;
38230 int res1 = 0 ;
38231 PyObject *swig_obj[1] ;
38232
38233 if (!args) SWIG_fail;
38234 swig_obj[0] = args;
38235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38236 if (!SWIG_IsOK(res1)) {
38237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38238 }
38239 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38240 {
38241 PyThreadState* __tstate = wxPyBeginAllowThreads();
38242 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38243 wxPyEndAllowThreads(__tstate);
38244 if (PyErr_Occurred()) SWIG_fail;
38245 }
38246 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38247 return resultobj;
38248 fail:
38249 return NULL;
38250 }
38251
38252
38253 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38254 PyObject *resultobj = 0;
38255 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38256 wxString *arg2 = 0 ;
38257 wxString const &arg3_defvalue = wxEmptyString ;
38258 wxString *arg3 = (wxString *) &arg3_defvalue ;
38259 void *argp1 = 0 ;
38260 int res1 = 0 ;
38261 bool temp2 = false ;
38262 bool temp3 = false ;
38263 PyObject * obj0 = 0 ;
38264 PyObject * obj1 = 0 ;
38265 PyObject * obj2 = 0 ;
38266 char * kwnames[] = {
38267 (char *) "self",(char *) "url",(char *) "desc", NULL
38268 };
38269
38270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38272 if (!SWIG_IsOK(res1)) {
38273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38274 }
38275 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38276 {
38277 arg2 = wxString_in_helper(obj1);
38278 if (arg2 == NULL) SWIG_fail;
38279 temp2 = true;
38280 }
38281 if (obj2) {
38282 {
38283 arg3 = wxString_in_helper(obj2);
38284 if (arg3 == NULL) SWIG_fail;
38285 temp3 = true;
38286 }
38287 }
38288 {
38289 PyThreadState* __tstate = wxPyBeginAllowThreads();
38290 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38291 wxPyEndAllowThreads(__tstate);
38292 if (PyErr_Occurred()) SWIG_fail;
38293 }
38294 resultobj = SWIG_Py_Void();
38295 {
38296 if (temp2)
38297 delete arg2;
38298 }
38299 {
38300 if (temp3)
38301 delete arg3;
38302 }
38303 return resultobj;
38304 fail:
38305 {
38306 if (temp2)
38307 delete arg2;
38308 }
38309 {
38310 if (temp3)
38311 delete arg3;
38312 }
38313 return NULL;
38314 }
38315
38316
38317 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38318 PyObject *resultobj = 0;
38319 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38320 wxString result;
38321 void *argp1 = 0 ;
38322 int res1 = 0 ;
38323 PyObject *swig_obj[1] ;
38324
38325 if (!args) SWIG_fail;
38326 swig_obj[0] = args;
38327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38328 if (!SWIG_IsOK(res1)) {
38329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38330 }
38331 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38332 {
38333 PyThreadState* __tstate = wxPyBeginAllowThreads();
38334 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38335 wxPyEndAllowThreads(__tstate);
38336 if (PyErr_Occurred()) SWIG_fail;
38337 }
38338 {
38339 #if wxUSE_UNICODE
38340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38341 #else
38342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38343 #endif
38344 }
38345 return resultobj;
38346 fail:
38347 return NULL;
38348 }
38349
38350
38351 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38352 PyObject *resultobj = 0;
38353 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38354 wxString result;
38355 void *argp1 = 0 ;
38356 int res1 = 0 ;
38357 PyObject *swig_obj[1] ;
38358
38359 if (!args) SWIG_fail;
38360 swig_obj[0] = args;
38361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38362 if (!SWIG_IsOK(res1)) {
38363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38364 }
38365 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38366 {
38367 PyThreadState* __tstate = wxPyBeginAllowThreads();
38368 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38369 wxPyEndAllowThreads(__tstate);
38370 if (PyErr_Occurred()) SWIG_fail;
38371 }
38372 {
38373 #if wxUSE_UNICODE
38374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38375 #else
38376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38377 #endif
38378 }
38379 return resultobj;
38380 fail:
38381 return NULL;
38382 }
38383
38384
38385 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38386 PyObject *resultobj = 0;
38387 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38388 bool result;
38389 void *argp1 = 0 ;
38390 int res1 = 0 ;
38391 PyObject *swig_obj[1] ;
38392
38393 if (!args) SWIG_fail;
38394 swig_obj[0] = args;
38395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38396 if (!SWIG_IsOK(res1)) {
38397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38398 }
38399 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38400 {
38401 PyThreadState* __tstate = wxPyBeginAllowThreads();
38402 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38403 wxPyEndAllowThreads(__tstate);
38404 if (PyErr_Occurred()) SWIG_fail;
38405 }
38406 {
38407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38408 }
38409 return resultobj;
38410 fail:
38411 return NULL;
38412 }
38413
38414
38415 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38416 PyObject *resultobj = 0;
38417 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38418 wxArrayString *arg2 = 0 ;
38419 void *argp1 = 0 ;
38420 int res1 = 0 ;
38421 bool temp2 = false ;
38422 PyObject * obj0 = 0 ;
38423 PyObject * obj1 = 0 ;
38424 char * kwnames[] = {
38425 (char *) "self",(char *) "developers", NULL
38426 };
38427
38428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38430 if (!SWIG_IsOK(res1)) {
38431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38432 }
38433 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38434 {
38435 if (! PySequence_Check(obj1)) {
38436 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38437 SWIG_fail;
38438 }
38439 arg2 = new wxArrayString;
38440 temp2 = true;
38441 int i, len=PySequence_Length(obj1);
38442 for (i=0; i<len; i++) {
38443 PyObject* item = PySequence_GetItem(obj1, i);
38444 wxString* s = wxString_in_helper(item);
38445 if (PyErr_Occurred()) SWIG_fail;
38446 arg2->Add(*s);
38447 delete s;
38448 Py_DECREF(item);
38449 }
38450 }
38451 {
38452 PyThreadState* __tstate = wxPyBeginAllowThreads();
38453 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38454 wxPyEndAllowThreads(__tstate);
38455 if (PyErr_Occurred()) SWIG_fail;
38456 }
38457 resultobj = SWIG_Py_Void();
38458 {
38459 if (temp2) delete arg2;
38460 }
38461 return resultobj;
38462 fail:
38463 {
38464 if (temp2) delete arg2;
38465 }
38466 return NULL;
38467 }
38468
38469
38470 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38471 PyObject *resultobj = 0;
38472 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38473 wxString *arg2 = 0 ;
38474 void *argp1 = 0 ;
38475 int res1 = 0 ;
38476 bool temp2 = false ;
38477 PyObject * obj0 = 0 ;
38478 PyObject * obj1 = 0 ;
38479 char * kwnames[] = {
38480 (char *) "self",(char *) "developer", NULL
38481 };
38482
38483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38485 if (!SWIG_IsOK(res1)) {
38486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38487 }
38488 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38489 {
38490 arg2 = wxString_in_helper(obj1);
38491 if (arg2 == NULL) SWIG_fail;
38492 temp2 = true;
38493 }
38494 {
38495 PyThreadState* __tstate = wxPyBeginAllowThreads();
38496 (arg1)->AddDeveloper((wxString const &)*arg2);
38497 wxPyEndAllowThreads(__tstate);
38498 if (PyErr_Occurred()) SWIG_fail;
38499 }
38500 resultobj = SWIG_Py_Void();
38501 {
38502 if (temp2)
38503 delete arg2;
38504 }
38505 return resultobj;
38506 fail:
38507 {
38508 if (temp2)
38509 delete arg2;
38510 }
38511 return NULL;
38512 }
38513
38514
38515 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38516 PyObject *resultobj = 0;
38517 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38518 bool result;
38519 void *argp1 = 0 ;
38520 int res1 = 0 ;
38521 PyObject *swig_obj[1] ;
38522
38523 if (!args) SWIG_fail;
38524 swig_obj[0] = args;
38525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38526 if (!SWIG_IsOK(res1)) {
38527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38528 }
38529 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38530 {
38531 PyThreadState* __tstate = wxPyBeginAllowThreads();
38532 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38533 wxPyEndAllowThreads(__tstate);
38534 if (PyErr_Occurred()) SWIG_fail;
38535 }
38536 {
38537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38538 }
38539 return resultobj;
38540 fail:
38541 return NULL;
38542 }
38543
38544
38545 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38546 PyObject *resultobj = 0;
38547 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38548 wxArrayString *result = 0 ;
38549 void *argp1 = 0 ;
38550 int res1 = 0 ;
38551 PyObject *swig_obj[1] ;
38552
38553 if (!args) SWIG_fail;
38554 swig_obj[0] = args;
38555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38556 if (!SWIG_IsOK(res1)) {
38557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38558 }
38559 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38560 {
38561 PyThreadState* __tstate = wxPyBeginAllowThreads();
38562 {
38563 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38564 result = (wxArrayString *) &_result_ref;
38565 }
38566 wxPyEndAllowThreads(__tstate);
38567 if (PyErr_Occurred()) SWIG_fail;
38568 }
38569 {
38570 resultobj = wxArrayString2PyList_helper(*result);
38571 }
38572 return resultobj;
38573 fail:
38574 return NULL;
38575 }
38576
38577
38578 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38579 PyObject *resultobj = 0;
38580 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38581 wxArrayString *arg2 = 0 ;
38582 void *argp1 = 0 ;
38583 int res1 = 0 ;
38584 bool temp2 = false ;
38585 PyObject * obj0 = 0 ;
38586 PyObject * obj1 = 0 ;
38587 char * kwnames[] = {
38588 (char *) "self",(char *) "docwriters", NULL
38589 };
38590
38591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38593 if (!SWIG_IsOK(res1)) {
38594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38595 }
38596 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38597 {
38598 if (! PySequence_Check(obj1)) {
38599 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38600 SWIG_fail;
38601 }
38602 arg2 = new wxArrayString;
38603 temp2 = true;
38604 int i, len=PySequence_Length(obj1);
38605 for (i=0; i<len; i++) {
38606 PyObject* item = PySequence_GetItem(obj1, i);
38607 wxString* s = wxString_in_helper(item);
38608 if (PyErr_Occurred()) SWIG_fail;
38609 arg2->Add(*s);
38610 delete s;
38611 Py_DECREF(item);
38612 }
38613 }
38614 {
38615 PyThreadState* __tstate = wxPyBeginAllowThreads();
38616 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38617 wxPyEndAllowThreads(__tstate);
38618 if (PyErr_Occurred()) SWIG_fail;
38619 }
38620 resultobj = SWIG_Py_Void();
38621 {
38622 if (temp2) delete arg2;
38623 }
38624 return resultobj;
38625 fail:
38626 {
38627 if (temp2) delete arg2;
38628 }
38629 return NULL;
38630 }
38631
38632
38633 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38634 PyObject *resultobj = 0;
38635 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38636 wxString *arg2 = 0 ;
38637 void *argp1 = 0 ;
38638 int res1 = 0 ;
38639 bool temp2 = false ;
38640 PyObject * obj0 = 0 ;
38641 PyObject * obj1 = 0 ;
38642 char * kwnames[] = {
38643 (char *) "self",(char *) "docwriter", NULL
38644 };
38645
38646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38648 if (!SWIG_IsOK(res1)) {
38649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38650 }
38651 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38652 {
38653 arg2 = wxString_in_helper(obj1);
38654 if (arg2 == NULL) SWIG_fail;
38655 temp2 = true;
38656 }
38657 {
38658 PyThreadState* __tstate = wxPyBeginAllowThreads();
38659 (arg1)->AddDocWriter((wxString const &)*arg2);
38660 wxPyEndAllowThreads(__tstate);
38661 if (PyErr_Occurred()) SWIG_fail;
38662 }
38663 resultobj = SWIG_Py_Void();
38664 {
38665 if (temp2)
38666 delete arg2;
38667 }
38668 return resultobj;
38669 fail:
38670 {
38671 if (temp2)
38672 delete arg2;
38673 }
38674 return NULL;
38675 }
38676
38677
38678 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38679 PyObject *resultobj = 0;
38680 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38681 bool result;
38682 void *argp1 = 0 ;
38683 int res1 = 0 ;
38684 PyObject *swig_obj[1] ;
38685
38686 if (!args) SWIG_fail;
38687 swig_obj[0] = args;
38688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38689 if (!SWIG_IsOK(res1)) {
38690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38691 }
38692 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38693 {
38694 PyThreadState* __tstate = wxPyBeginAllowThreads();
38695 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38696 wxPyEndAllowThreads(__tstate);
38697 if (PyErr_Occurred()) SWIG_fail;
38698 }
38699 {
38700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38701 }
38702 return resultobj;
38703 fail:
38704 return NULL;
38705 }
38706
38707
38708 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38709 PyObject *resultobj = 0;
38710 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38711 wxArrayString *result = 0 ;
38712 void *argp1 = 0 ;
38713 int res1 = 0 ;
38714 PyObject *swig_obj[1] ;
38715
38716 if (!args) SWIG_fail;
38717 swig_obj[0] = args;
38718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38719 if (!SWIG_IsOK(res1)) {
38720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38721 }
38722 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38723 {
38724 PyThreadState* __tstate = wxPyBeginAllowThreads();
38725 {
38726 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38727 result = (wxArrayString *) &_result_ref;
38728 }
38729 wxPyEndAllowThreads(__tstate);
38730 if (PyErr_Occurred()) SWIG_fail;
38731 }
38732 {
38733 resultobj = wxArrayString2PyList_helper(*result);
38734 }
38735 return resultobj;
38736 fail:
38737 return NULL;
38738 }
38739
38740
38741 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38742 PyObject *resultobj = 0;
38743 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38744 wxArrayString *arg2 = 0 ;
38745 void *argp1 = 0 ;
38746 int res1 = 0 ;
38747 bool temp2 = false ;
38748 PyObject * obj0 = 0 ;
38749 PyObject * obj1 = 0 ;
38750 char * kwnames[] = {
38751 (char *) "self",(char *) "artists", NULL
38752 };
38753
38754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38756 if (!SWIG_IsOK(res1)) {
38757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38758 }
38759 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38760 {
38761 if (! PySequence_Check(obj1)) {
38762 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38763 SWIG_fail;
38764 }
38765 arg2 = new wxArrayString;
38766 temp2 = true;
38767 int i, len=PySequence_Length(obj1);
38768 for (i=0; i<len; i++) {
38769 PyObject* item = PySequence_GetItem(obj1, i);
38770 wxString* s = wxString_in_helper(item);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 arg2->Add(*s);
38773 delete s;
38774 Py_DECREF(item);
38775 }
38776 }
38777 {
38778 PyThreadState* __tstate = wxPyBeginAllowThreads();
38779 (arg1)->SetArtists((wxArrayString const &)*arg2);
38780 wxPyEndAllowThreads(__tstate);
38781 if (PyErr_Occurred()) SWIG_fail;
38782 }
38783 resultobj = SWIG_Py_Void();
38784 {
38785 if (temp2) delete arg2;
38786 }
38787 return resultobj;
38788 fail:
38789 {
38790 if (temp2) delete arg2;
38791 }
38792 return NULL;
38793 }
38794
38795
38796 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38797 PyObject *resultobj = 0;
38798 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38799 wxString *arg2 = 0 ;
38800 void *argp1 = 0 ;
38801 int res1 = 0 ;
38802 bool temp2 = false ;
38803 PyObject * obj0 = 0 ;
38804 PyObject * obj1 = 0 ;
38805 char * kwnames[] = {
38806 (char *) "self",(char *) "artist", NULL
38807 };
38808
38809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38811 if (!SWIG_IsOK(res1)) {
38812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38813 }
38814 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38815 {
38816 arg2 = wxString_in_helper(obj1);
38817 if (arg2 == NULL) SWIG_fail;
38818 temp2 = true;
38819 }
38820 {
38821 PyThreadState* __tstate = wxPyBeginAllowThreads();
38822 (arg1)->AddArtist((wxString const &)*arg2);
38823 wxPyEndAllowThreads(__tstate);
38824 if (PyErr_Occurred()) SWIG_fail;
38825 }
38826 resultobj = SWIG_Py_Void();
38827 {
38828 if (temp2)
38829 delete arg2;
38830 }
38831 return resultobj;
38832 fail:
38833 {
38834 if (temp2)
38835 delete arg2;
38836 }
38837 return NULL;
38838 }
38839
38840
38841 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38842 PyObject *resultobj = 0;
38843 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38844 bool result;
38845 void *argp1 = 0 ;
38846 int res1 = 0 ;
38847 PyObject *swig_obj[1] ;
38848
38849 if (!args) SWIG_fail;
38850 swig_obj[0] = args;
38851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38852 if (!SWIG_IsOK(res1)) {
38853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38854 }
38855 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38856 {
38857 PyThreadState* __tstate = wxPyBeginAllowThreads();
38858 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38859 wxPyEndAllowThreads(__tstate);
38860 if (PyErr_Occurred()) SWIG_fail;
38861 }
38862 {
38863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38864 }
38865 return resultobj;
38866 fail:
38867 return NULL;
38868 }
38869
38870
38871 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38872 PyObject *resultobj = 0;
38873 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38874 wxArrayString *result = 0 ;
38875 void *argp1 = 0 ;
38876 int res1 = 0 ;
38877 PyObject *swig_obj[1] ;
38878
38879 if (!args) SWIG_fail;
38880 swig_obj[0] = args;
38881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38882 if (!SWIG_IsOK(res1)) {
38883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38884 }
38885 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38886 {
38887 PyThreadState* __tstate = wxPyBeginAllowThreads();
38888 {
38889 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38890 result = (wxArrayString *) &_result_ref;
38891 }
38892 wxPyEndAllowThreads(__tstate);
38893 if (PyErr_Occurred()) SWIG_fail;
38894 }
38895 {
38896 resultobj = wxArrayString2PyList_helper(*result);
38897 }
38898 return resultobj;
38899 fail:
38900 return NULL;
38901 }
38902
38903
38904 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38905 PyObject *resultobj = 0;
38906 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38907 wxArrayString *arg2 = 0 ;
38908 void *argp1 = 0 ;
38909 int res1 = 0 ;
38910 bool temp2 = false ;
38911 PyObject * obj0 = 0 ;
38912 PyObject * obj1 = 0 ;
38913 char * kwnames[] = {
38914 (char *) "self",(char *) "translators", NULL
38915 };
38916
38917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38919 if (!SWIG_IsOK(res1)) {
38920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38921 }
38922 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38923 {
38924 if (! PySequence_Check(obj1)) {
38925 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38926 SWIG_fail;
38927 }
38928 arg2 = new wxArrayString;
38929 temp2 = true;
38930 int i, len=PySequence_Length(obj1);
38931 for (i=0; i<len; i++) {
38932 PyObject* item = PySequence_GetItem(obj1, i);
38933 wxString* s = wxString_in_helper(item);
38934 if (PyErr_Occurred()) SWIG_fail;
38935 arg2->Add(*s);
38936 delete s;
38937 Py_DECREF(item);
38938 }
38939 }
38940 {
38941 PyThreadState* __tstate = wxPyBeginAllowThreads();
38942 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38943 wxPyEndAllowThreads(__tstate);
38944 if (PyErr_Occurred()) SWIG_fail;
38945 }
38946 resultobj = SWIG_Py_Void();
38947 {
38948 if (temp2) delete arg2;
38949 }
38950 return resultobj;
38951 fail:
38952 {
38953 if (temp2) delete arg2;
38954 }
38955 return NULL;
38956 }
38957
38958
38959 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38960 PyObject *resultobj = 0;
38961 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38962 wxString *arg2 = 0 ;
38963 void *argp1 = 0 ;
38964 int res1 = 0 ;
38965 bool temp2 = false ;
38966 PyObject * obj0 = 0 ;
38967 PyObject * obj1 = 0 ;
38968 char * kwnames[] = {
38969 (char *) "self",(char *) "translator", NULL
38970 };
38971
38972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38974 if (!SWIG_IsOK(res1)) {
38975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38976 }
38977 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38978 {
38979 arg2 = wxString_in_helper(obj1);
38980 if (arg2 == NULL) SWIG_fail;
38981 temp2 = true;
38982 }
38983 {
38984 PyThreadState* __tstate = wxPyBeginAllowThreads();
38985 (arg1)->AddTranslator((wxString const &)*arg2);
38986 wxPyEndAllowThreads(__tstate);
38987 if (PyErr_Occurred()) SWIG_fail;
38988 }
38989 resultobj = SWIG_Py_Void();
38990 {
38991 if (temp2)
38992 delete arg2;
38993 }
38994 return resultobj;
38995 fail:
38996 {
38997 if (temp2)
38998 delete arg2;
38999 }
39000 return NULL;
39001 }
39002
39003
39004 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39005 PyObject *resultobj = 0;
39006 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39007 bool result;
39008 void *argp1 = 0 ;
39009 int res1 = 0 ;
39010 PyObject *swig_obj[1] ;
39011
39012 if (!args) SWIG_fail;
39013 swig_obj[0] = args;
39014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39015 if (!SWIG_IsOK(res1)) {
39016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39017 }
39018 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39019 {
39020 PyThreadState* __tstate = wxPyBeginAllowThreads();
39021 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39022 wxPyEndAllowThreads(__tstate);
39023 if (PyErr_Occurred()) SWIG_fail;
39024 }
39025 {
39026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39027 }
39028 return resultobj;
39029 fail:
39030 return NULL;
39031 }
39032
39033
39034 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39035 PyObject *resultobj = 0;
39036 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39037 wxArrayString *result = 0 ;
39038 void *argp1 = 0 ;
39039 int res1 = 0 ;
39040 PyObject *swig_obj[1] ;
39041
39042 if (!args) SWIG_fail;
39043 swig_obj[0] = args;
39044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39045 if (!SWIG_IsOK(res1)) {
39046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39047 }
39048 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39049 {
39050 PyThreadState* __tstate = wxPyBeginAllowThreads();
39051 {
39052 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39053 result = (wxArrayString *) &_result_ref;
39054 }
39055 wxPyEndAllowThreads(__tstate);
39056 if (PyErr_Occurred()) SWIG_fail;
39057 }
39058 {
39059 resultobj = wxArrayString2PyList_helper(*result);
39060 }
39061 return resultobj;
39062 fail:
39063 return NULL;
39064 }
39065
39066
39067 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39068 PyObject *resultobj = 0;
39069 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39070 bool result;
39071 void *argp1 = 0 ;
39072 int res1 = 0 ;
39073 PyObject *swig_obj[1] ;
39074
39075 if (!args) SWIG_fail;
39076 swig_obj[0] = args;
39077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39078 if (!SWIG_IsOK(res1)) {
39079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39080 }
39081 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39082 {
39083 PyThreadState* __tstate = wxPyBeginAllowThreads();
39084 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39085 wxPyEndAllowThreads(__tstate);
39086 if (PyErr_Occurred()) SWIG_fail;
39087 }
39088 {
39089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39090 }
39091 return resultobj;
39092 fail:
39093 return NULL;
39094 }
39095
39096
39097 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39098 PyObject *resultobj = 0;
39099 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39100 wxString result;
39101 void *argp1 = 0 ;
39102 int res1 = 0 ;
39103 PyObject *swig_obj[1] ;
39104
39105 if (!args) SWIG_fail;
39106 swig_obj[0] = args;
39107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39108 if (!SWIG_IsOK(res1)) {
39109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39110 }
39111 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39112 {
39113 PyThreadState* __tstate = wxPyBeginAllowThreads();
39114 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39115 wxPyEndAllowThreads(__tstate);
39116 if (PyErr_Occurred()) SWIG_fail;
39117 }
39118 {
39119 #if wxUSE_UNICODE
39120 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39121 #else
39122 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39123 #endif
39124 }
39125 return resultobj;
39126 fail:
39127 return NULL;
39128 }
39129
39130
39131 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39132 PyObject *obj;
39133 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39134 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39135 return SWIG_Py_Void();
39136 }
39137
39138 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39139 return SWIG_Python_InitShadowInstance(args);
39140 }
39141
39142 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39143 PyObject *resultobj = 0;
39144 wxAboutDialogInfo *arg1 = 0 ;
39145 void *argp1 = 0 ;
39146 int res1 = 0 ;
39147 PyObject * obj0 = 0 ;
39148 char * kwnames[] = {
39149 (char *) "info", NULL
39150 };
39151
39152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39153 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39154 if (!SWIG_IsOK(res1)) {
39155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39156 }
39157 if (!argp1) {
39158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39159 }
39160 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39161 {
39162 PyThreadState* __tstate = wxPyBeginAllowThreads();
39163 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39164 wxPyEndAllowThreads(__tstate);
39165 if (PyErr_Occurred()) SWIG_fail;
39166 }
39167 resultobj = SWIG_Py_Void();
39168 return resultobj;
39169 fail:
39170 return NULL;
39171 }
39172
39173
39174 static PyMethodDef SwigMethods[] = {
39175 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39176 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39178 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39179 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39180 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39181 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39182 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39183 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39184 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39185 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39186 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39187 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39188 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39189 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39190 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39191 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39192 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39194 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39196 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39197 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39198 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39199 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39200 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39201 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39202 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39203 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39204 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39205 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39206 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39207 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39208 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39209 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39210 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39215 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39216 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39217 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39218 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39219 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39220 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39221 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39222 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39223 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39224 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39225 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39228 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39236 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39237 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39238 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39239 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39240 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39241 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39242 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39243 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39244 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39245 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39246 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39248 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39249 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39250 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39251 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39252 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39253 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39256 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39257 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39258 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39259 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39260 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39261 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39262 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39263 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39264 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39265 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39266 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39267 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39268 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39271 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39274 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39276 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39277 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39278 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39279 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39280 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39281 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39282 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39283 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39284 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39285 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39286 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39287 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39289 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39291 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39292 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39293 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39295 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39296 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39297 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39298 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39299 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39300 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39301 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39302 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39303 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39304 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39305 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39306 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39307 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39310 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39312 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39313 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39314 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39315 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39316 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39318 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39319 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39320 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39322 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39323 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39324 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39326 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39327 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39328 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39329 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39330 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39332 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39333 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39334 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39335 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39336 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39337 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39338 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39340 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39341 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39342 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39346 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39347 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39348 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39349 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39350 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39351 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39352 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39353 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39354 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39355 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39356 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39357 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39358 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39359 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39362 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39363 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39365 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39366 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39367 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39368 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39369 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39370 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39371 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39372 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39373 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39374 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39375 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39376 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39377 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39378 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39379 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39383 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39384 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39385 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39386 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39387 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39388 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39389 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39390 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39391 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39393 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39395 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39396 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39397 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39398 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39399 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39401 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39404 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39406 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39407 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39408 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39409 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39410 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39411 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39412 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39413 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39415 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39416 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39417 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39418 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39419 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39420 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39421 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39422 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39423 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39424 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39425 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39426 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39427 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39428 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39429 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39430 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39431 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39432 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39433 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39434 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39436 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39437 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39438 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39439 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39440 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39442 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39443 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39445 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39446 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39447 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39448 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39449 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39450 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39451 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39452 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39453 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39454 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39455 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39456 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39457 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39458 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39459 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39460 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39461 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39462 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39465 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39466 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39467 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39468 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39469 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39470 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39472 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39473 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39474 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39475 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39476 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39477 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39478 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39479 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39480 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39481 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39482 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39483 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39484 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39485 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39487 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39488 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39489 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39491 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39492 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39493 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39494 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39495 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39497 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39498 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39499 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39500 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39501 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39502 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39503 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39504 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39509 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39511 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39512 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39513 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39514 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39515 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39516 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39517 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39518 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39519 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39520 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39521 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39522 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39523 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39524 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39526 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39527 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39528 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39529 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39530 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39531 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39532 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39533 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39534 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39537 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39538 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39539 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39540 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39541 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39542 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39543 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39544 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39545 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39546 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39548 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39549 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39550 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39551 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39552 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39553 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39554 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39555 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39556 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39557 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39558 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39559 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39560 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39561 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39562 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39563 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39564 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39565 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39566 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39567 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39568 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39569 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39570 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39571 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39572 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39573 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39574 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39575 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39576 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39577 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39578 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39579 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39580 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39581 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39583 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39584 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39585 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39586 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39587 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39589 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39590 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39591 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39593 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39594 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39595 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39598 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39599 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39600 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39601 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39603 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39606 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39609 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39610 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39611 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39614 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39615 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39618 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39619 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39620 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39621 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39622 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39623 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39624 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39625 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39626 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39627 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39628 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39630 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39631 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39632 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39633 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39634 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39635 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39636 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39638 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39641 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39642 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39643 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39644 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39645 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39647 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39649 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39654 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39658 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39659 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39660 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39661 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39662 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39666 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39671 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39672 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39673 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39674 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39677 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39678 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39680 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39681 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39683 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39704 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39706 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39708 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39710 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39711 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39715 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39716 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39718 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39719 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39720 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39722 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39723 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39724 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39726 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39727 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39728 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39729 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39732 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39743 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39747 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39748 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39749 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39750 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39756 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39757 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39762 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39763 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39787 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39788 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39789 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39790 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39791 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39803 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39804 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39830 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39831 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39832 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39833 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39846 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39847 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39848 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39849 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39850 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39851 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39853 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39855 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39857 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39859 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39861 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39863 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39865 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39869 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39870 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39874 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39885 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39886 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39887 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39891 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39892 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39893 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39894 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39895 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39896 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39898 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39899 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39901 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39903 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39905 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39907 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39909 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39912 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39913 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39914 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39915 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39916 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39917 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39918 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39919 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39921 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39925 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39933 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39934 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39935 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39936 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39937 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39938 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39941 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39942 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39943 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39945 { (char *)"DataFormat__GetId", (PyCFunction)_wrap_DataFormat__GetId, METH_O, NULL},
39946 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39948 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39949 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39950 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39955 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39957 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39958 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39960 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39962 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39963 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39964 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39965 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39966 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39969 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39970 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39971 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39973 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39974 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39975 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39976 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39977 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39978 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39979 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39980 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39981 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39984 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39985 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39987 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39989 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39990 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39992 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39993 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39994 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39995 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39996 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39998 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39999 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40000 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40002 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40003 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40004 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40005 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40007 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40008 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40009 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40010 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40011 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40012 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40013 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40016 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40017 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40019 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40020 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40023 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40024 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40027 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40028 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40032 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40034 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40035 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40036 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40037 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40038 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40039 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40040 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40042 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40043 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40044 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40047 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40048 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40049 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40051 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40052 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40053 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40054 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40055 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40056 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40057 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40058 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40059 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40060 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40061 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40062 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40063 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40065 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40068 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40069 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40070 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40071 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40072 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40073 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40074 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40075 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40076 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40077 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40078 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40080 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40082 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40083 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40084 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40085 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40086 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40088 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40089 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40090 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40091 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40092 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40093 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40094 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40095 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40096 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40097 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40098 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40099 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40100 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40101 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40102 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40103 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40104 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40105 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40106 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40107 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40108 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40109 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40110 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40111 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40112 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40113 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40114 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40115 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40116 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40117 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40118 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40119 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40120 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40121 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40122 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40123 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40124 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40125 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40126 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40127 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40128 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40129 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40130 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40131 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40132 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40133 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40134 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40135 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40136 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40137 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40138 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40139 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40140 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40141 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40142 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40143 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40144 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40145 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40146 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40147 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40148 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40149 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40150 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40151 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40152 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40153 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40154 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40155 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40156 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40157 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40158 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40159 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40160 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40161 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40162 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40163 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40164 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40165 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40166 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40167 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40168 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40169 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40170 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40171 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40172 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40173 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40174 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40175 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40176 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40177 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40178 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40179 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40180 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40181 { NULL, NULL, 0, NULL }
40182 };
40183
40184
40185 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40186
40187 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40188 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40189 }
40190 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40191 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40192 }
40193 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40194 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40195 }
40196 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40197 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40198 }
40199 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40200 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40201 }
40202 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40203 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40204 }
40205 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40206 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40207 }
40208 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40209 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40210 }
40211 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40212 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40213 }
40214 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40215 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40216 }
40217 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40218 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40219 }
40220 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40221 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40222 }
40223 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40224 return (void *)((wxEvent *) ((wxPyEvent *) x));
40225 }
40226 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40227 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40228 }
40229 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40230 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40231 }
40232 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40233 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40234 }
40235 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40236 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40237 }
40238 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40239 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40240 }
40241 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40242 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40243 }
40244 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40245 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40246 }
40247 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40248 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40249 }
40250 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40251 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40252 }
40253 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40254 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40255 }
40256 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40257 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40258 }
40259 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40260 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40261 }
40262 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40263 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40264 }
40265 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40266 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40267 }
40268 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40269 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40270 }
40271 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40272 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40273 }
40274 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40275 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40276 }
40277 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40278 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40279 }
40280 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40281 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40282 }
40283 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40284 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40285 }
40286 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40287 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40288 }
40289 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40290 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40291 }
40292 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40293 return (void *)((wxEvent *) ((wxShowEvent *) x));
40294 }
40295 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40296 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40297 }
40298 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40299 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40300 }
40301 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40302 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40303 }
40304 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40305 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40306 }
40307 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40308 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40309 }
40310 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40311 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40312 }
40313 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40314 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40315 }
40316 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40317 return (void *)((wxConfigBase *) ((wxConfig *) x));
40318 }
40319 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40320 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40321 }
40322 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40323 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40324 }
40325 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40326 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40327 }
40328 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40329 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40330 }
40331 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40332 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40333 }
40334 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40335 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40336 }
40337 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40338 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40339 }
40340 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40341 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40342 }
40343 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40344 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40345 }
40346 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40347 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40348 }
40349 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40350 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40351 }
40352 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40353 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40354 }
40355 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40356 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40357 }
40358 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40359 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40360 }
40361 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40362 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40363 }
40364 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40365 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40366 }
40367 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40368 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40369 }
40370 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40371 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40372 }
40373 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40374 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40375 }
40376 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40377 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40378 }
40379 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40380 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40381 }
40382 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40383 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40384 }
40385 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40386 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40387 }
40388 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40389 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40390 }
40391 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40392 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40393 }
40394 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40395 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40396 }
40397 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40398 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40399 }
40400 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40401 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40402 }
40403 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40404 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40405 }
40406 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40407 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40408 }
40409 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40410 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40411 }
40412 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40413 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40414 }
40415 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40416 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40417 }
40418 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40419 return (void *)((wxObject *) ((wxSizerItem *) x));
40420 }
40421 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40422 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40423 }
40424 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40425 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40426 }
40427 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40428 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40429 }
40430 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40431 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40432 }
40433 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40434 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40435 }
40436 static void *_p_wxSizerTo_p_wxObject(void *x) {
40437 return (void *)((wxObject *) ((wxSizer *) x));
40438 }
40439 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40440 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40441 }
40442 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40443 return (void *)((wxObject *) ((wxFileHistory *) x));
40444 }
40445 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40446 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40447 }
40448 static void *_p_wxEventTo_p_wxObject(void *x) {
40449 return (void *)((wxObject *) ((wxEvent *) x));
40450 }
40451 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40452 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40453 }
40454 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40455 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40456 }
40457 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40458 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40459 }
40460 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40461 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40462 }
40463 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40464 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40465 }
40466 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40467 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40468 }
40469 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40470 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40471 }
40472 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40473 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40474 }
40475 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40476 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40477 }
40478 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40479 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40480 }
40481 static void *_p_wxControlTo_p_wxObject(void *x) {
40482 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40483 }
40484 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40485 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40486 }
40487 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40488 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40489 }
40490 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40491 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40492 }
40493 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40494 return (void *)((wxObject *) ((wxFSFile *) x));
40495 }
40496 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40497 return (void *)((wxObject *) ((wxClipboard *) x));
40498 }
40499 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40500 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40501 }
40502 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40503 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40504 }
40505 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40506 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40507 }
40508 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40509 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40510 }
40511 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40512 return (void *)((wxObject *) ((wxToolTip *) x));
40513 }
40514 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40515 return (void *)((wxObject *) ((wxMenuItem *) x));
40516 }
40517 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40518 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40519 }
40520 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40521 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40522 }
40523 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40524 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40525 }
40526 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40527 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40528 }
40529 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40530 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40531 }
40532 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40533 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40534 }
40535 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40536 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40537 }
40538 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40539 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40540 }
40541 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40542 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40543 }
40544 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40545 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40546 }
40547 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40548 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40549 }
40550 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40551 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40552 }
40553 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40554 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40555 }
40556 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40557 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40558 }
40559 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40560 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40561 }
40562 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40563 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40564 }
40565 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40566 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40567 }
40568 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40569 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40570 }
40571 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40572 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40573 }
40574 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40575 return (void *)((wxObject *) ((wxImageHandler *) x));
40576 }
40577 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40578 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40579 }
40580 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40581 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40582 }
40583 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40584 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40585 }
40586 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40587 return (void *)((wxObject *) ((wxEvtHandler *) x));
40588 }
40589 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40590 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40591 }
40592 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40593 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40594 }
40595 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40596 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40597 }
40598 static void *_p_wxImageTo_p_wxObject(void *x) {
40599 return (void *)((wxObject *) ((wxImage *) x));
40600 }
40601 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40602 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40603 }
40604 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40605 return (void *)((wxObject *) ((wxSystemOptions *) x));
40606 }
40607 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40608 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40609 }
40610 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40611 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40612 }
40613 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40614 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40615 }
40616 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40617 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40618 }
40619 static void *_p_wxWindowTo_p_wxObject(void *x) {
40620 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40621 }
40622 static void *_p_wxMenuTo_p_wxObject(void *x) {
40623 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40624 }
40625 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40626 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40627 }
40628 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40629 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40630 }
40631 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40632 return (void *)((wxObject *) ((wxFileSystem *) x));
40633 }
40634 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40635 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40636 }
40637 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40638 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40639 }
40640 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40641 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40642 }
40643 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40644 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40645 }
40646 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40647 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40648 }
40649 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40650 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40651 }
40652 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40653 return (void *)((wxObject *) ((wxBusyInfo *) x));
40654 }
40655 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40656 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40657 }
40658 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40659 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40660 }
40661 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40662 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40663 }
40664 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40665 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40666 }
40667 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40668 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40669 }
40670 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40671 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40672 }
40673 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40674 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40675 }
40676 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40677 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40678 }
40679 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40680 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40681 }
40682 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40683 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40684 }
40685 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40686 return (void *)((wxLog *) ((wxLogBuffer *) x));
40687 }
40688 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40689 return (void *)((wxLog *) ((wxLogStderr *) x));
40690 }
40691 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40692 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40693 }
40694 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40695 return (void *)((wxLog *) ((wxLogWindow *) x));
40696 }
40697 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40698 return (void *)((wxLog *) ((wxLogChain *) x));
40699 }
40700 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40701 return (void *)((wxLog *) ((wxLogGui *) x));
40702 }
40703 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40704 return (void *)((wxLog *) ((wxPyLog *) x));
40705 }
40706 static void *_p_wxControlTo_p_wxWindow(void *x) {
40707 return (void *)((wxWindow *) ((wxControl *) x));
40708 }
40709 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40710 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40711 }
40712 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40713 return (void *)((wxWindow *) ((wxMenuBar *) x));
40714 }
40715 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40716 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40717 }
40718 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40719 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40720 }
40721 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40722 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};
40723 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40736 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40737 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40738 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40739 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40740 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40741 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40742 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40743 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40744 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40745 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40746 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40747 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40748 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40749 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40750 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40751 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40752 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40753 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40754 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40755 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40773 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40774 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40775 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40776 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40777 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40778 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40779 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40780 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40781 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40782 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40783 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40784 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40785 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40786 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40787 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40788 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40789 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40790 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40791 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40792 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40793 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40795 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40796 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40797 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40798 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40799 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40800 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40812 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40813 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40814 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40815 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40816 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40818 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40819 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40820 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40821 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40822 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40823 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40824 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40825 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40828 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40832 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40833 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40835 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40836 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40837 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40838 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40839 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40840 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40841 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40842 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40843 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40844 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40845 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40846 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40847 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40848 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40849 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40850 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40851 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40852 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40853 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40854 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40855 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40856 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40857 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40858 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40859 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40860 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40861 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40862 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40863 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40866 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40867 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40868 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40870 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40871 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40875 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40876 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40877 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40878 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40879 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40880 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40881 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40882 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40883 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40884 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40885 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40886 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40887 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40888 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40889 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40890 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40891 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40892 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40893 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40894 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40895
40896 static swig_type_info *swig_type_initial[] = {
40897 &_swigt__p_char,
40898 &_swigt__p_form_ops_t,
40899 &_swigt__p_int,
40900 &_swigt__p_unsigned_char,
40901 &_swigt__p_unsigned_int,
40902 &_swigt__p_unsigned_long,
40903 &_swigt__p_void,
40904 &_swigt__p_wxANIHandler,
40905 &_swigt__p_wxAboutDialogInfo,
40906 &_swigt__p_wxAcceleratorTable,
40907 &_swigt__p_wxActivateEvent,
40908 &_swigt__p_wxArrayString,
40909 &_swigt__p_wxBMPHandler,
40910 &_swigt__p_wxBitmap,
40911 &_swigt__p_wxBitmapDataObject,
40912 &_swigt__p_wxBoxSizer,
40913 &_swigt__p_wxBusyCursor,
40914 &_swigt__p_wxBusyInfo,
40915 &_swigt__p_wxCURHandler,
40916 &_swigt__p_wxCaret,
40917 &_swigt__p_wxChar,
40918 &_swigt__p_wxChildFocusEvent,
40919 &_swigt__p_wxClipboard,
40920 &_swigt__p_wxClipboardLocker,
40921 &_swigt__p_wxClipboardTextEvent,
40922 &_swigt__p_wxCloseEvent,
40923 &_swigt__p_wxColour,
40924 &_swigt__p_wxCommandEvent,
40925 &_swigt__p_wxConfig,
40926 &_swigt__p_wxConfigBase,
40927 &_swigt__p_wxConfigPathChanger,
40928 &_swigt__p_wxContextMenuEvent,
40929 &_swigt__p_wxControl,
40930 &_swigt__p_wxControlWithItems,
40931 &_swigt__p_wxCursor,
40932 &_swigt__p_wxCustomDataObject,
40933 &_swigt__p_wxDC,
40934 &_swigt__p_wxDataFormat,
40935 &_swigt__p_wxDataObject,
40936 &_swigt__p_wxDataObjectComposite,
40937 &_swigt__p_wxDataObjectSimple,
40938 &_swigt__p_wxDateEvent,
40939 &_swigt__p_wxDateSpan,
40940 &_swigt__p_wxDateTime,
40941 &_swigt__p_wxDateTime__TimeZone,
40942 &_swigt__p_wxDisplay,
40943 &_swigt__p_wxDisplayChangedEvent,
40944 &_swigt__p_wxDropFilesEvent,
40945 &_swigt__p_wxDuplexMode,
40946 &_swigt__p_wxEraseEvent,
40947 &_swigt__p_wxEvent,
40948 &_swigt__p_wxEvtHandler,
40949 &_swigt__p_wxFSFile,
40950 &_swigt__p_wxFileConfig,
40951 &_swigt__p_wxFileDataObject,
40952 &_swigt__p_wxFileHistory,
40953 &_swigt__p_wxFileSystem,
40954 &_swigt__p_wxFileType,
40955 &_swigt__p_wxFileTypeInfo,
40956 &_swigt__p_wxFlexGridSizer,
40957 &_swigt__p_wxFocusEvent,
40958 &_swigt__p_wxFont,
40959 &_swigt__p_wxFrame,
40960 &_swigt__p_wxGBSizerItem,
40961 &_swigt__p_wxGIFHandler,
40962 &_swigt__p_wxGridBagSizer,
40963 &_swigt__p_wxGridSizer,
40964 &_swigt__p_wxICOHandler,
40965 &_swigt__p_wxIcon,
40966 &_swigt__p_wxIconizeEvent,
40967 &_swigt__p_wxIdleEvent,
40968 &_swigt__p_wxImage,
40969 &_swigt__p_wxImageHandler,
40970 &_swigt__p_wxIndividualLayoutConstraint,
40971 &_swigt__p_wxInitDialogEvent,
40972 &_swigt__p_wxJPEGHandler,
40973 &_swigt__p_wxJoystick,
40974 &_swigt__p_wxJoystickEvent,
40975 &_swigt__p_wxKeyEvent,
40976 &_swigt__p_wxKillError,
40977 &_swigt__p_wxLayoutConstraints,
40978 &_swigt__p_wxLog,
40979 &_swigt__p_wxLogBuffer,
40980 &_swigt__p_wxLogChain,
40981 &_swigt__p_wxLogGui,
40982 &_swigt__p_wxLogNull,
40983 &_swigt__p_wxLogStderr,
40984 &_swigt__p_wxLogTextCtrl,
40985 &_swigt__p_wxLogWindow,
40986 &_swigt__p_wxMaximizeEvent,
40987 &_swigt__p_wxMenu,
40988 &_swigt__p_wxMenuBar,
40989 &_swigt__p_wxMenuEvent,
40990 &_swigt__p_wxMenuItem,
40991 &_swigt__p_wxMetafileDataObject,
40992 &_swigt__p_wxMimeTypesManager,
40993 &_swigt__p_wxMouseCaptureChangedEvent,
40994 &_swigt__p_wxMouseCaptureLostEvent,
40995 &_swigt__p_wxMouseEvent,
40996 &_swigt__p_wxMouseState,
40997 &_swigt__p_wxMoveEvent,
40998 &_swigt__p_wxMutexGuiLocker,
40999 &_swigt__p_wxNavigationKeyEvent,
41000 &_swigt__p_wxNcPaintEvent,
41001 &_swigt__p_wxNotifyEvent,
41002 &_swigt__p_wxObject,
41003 &_swigt__p_wxOutputStream,
41004 &_swigt__p_wxPCXHandler,
41005 &_swigt__p_wxPNGHandler,
41006 &_swigt__p_wxPNMHandler,
41007 &_swigt__p_wxPaintEvent,
41008 &_swigt__p_wxPaletteChangedEvent,
41009 &_swigt__p_wxPaperSize,
41010 &_swigt__p_wxPlatformInfo,
41011 &_swigt__p_wxPoint,
41012 &_swigt__p_wxPowerEvent,
41013 &_swigt__p_wxProcessEvent,
41014 &_swigt__p_wxPyApp,
41015 &_swigt__p_wxPyArtProvider,
41016 &_swigt__p_wxPyBitmapDataObject,
41017 &_swigt__p_wxPyCommandEvent,
41018 &_swigt__p_wxPyDataObjectSimple,
41019 &_swigt__p_wxPyDropSource,
41020 &_swigt__p_wxPyDropTarget,
41021 &_swigt__p_wxPyEvent,
41022 &_swigt__p_wxPyFileDropTarget,
41023 &_swigt__p_wxPyImageHandler,
41024 &_swigt__p_wxPyLog,
41025 &_swigt__p_wxPyProcess,
41026 &_swigt__p_wxPySizer,
41027 &_swigt__p_wxPyTextDataObject,
41028 &_swigt__p_wxPyTextDropTarget,
41029 &_swigt__p_wxPyTimer,
41030 &_swigt__p_wxPyTipProvider,
41031 &_swigt__p_wxPyValidator,
41032 &_swigt__p_wxQueryNewPaletteEvent,
41033 &_swigt__p_wxRect,
41034 &_swigt__p_wxScrollEvent,
41035 &_swigt__p_wxScrollWinEvent,
41036 &_swigt__p_wxSetCursorEvent,
41037 &_swigt__p_wxShowEvent,
41038 &_swigt__p_wxSingleInstanceChecker,
41039 &_swigt__p_wxSize,
41040 &_swigt__p_wxSizeEvent,
41041 &_swigt__p_wxSizer,
41042 &_swigt__p_wxSizerItem,
41043 &_swigt__p_wxSound,
41044 &_swigt__p_wxStandardPaths,
41045 &_swigt__p_wxStaticBoxSizer,
41046 &_swigt__p_wxStdDialogButtonSizer,
41047 &_swigt__p_wxStopWatch,
41048 &_swigt__p_wxString,
41049 &_swigt__p_wxSysColourChangedEvent,
41050 &_swigt__p_wxSystemOptions,
41051 &_swigt__p_wxSystemSettings,
41052 &_swigt__p_wxTGAHandler,
41053 &_swigt__p_wxTIFFHandler,
41054 &_swigt__p_wxTextCtrl,
41055 &_swigt__p_wxTextDataObject,
41056 &_swigt__p_wxTimeSpan,
41057 &_swigt__p_wxTimer,
41058 &_swigt__p_wxTimerEvent,
41059 &_swigt__p_wxTimerRunner,
41060 &_swigt__p_wxTipProvider,
41061 &_swigt__p_wxToolTip,
41062 &_swigt__p_wxURLDataObject,
41063 &_swigt__p_wxUpdateUIEvent,
41064 &_swigt__p_wxValidator,
41065 &_swigt__p_wxVideoMode,
41066 &_swigt__p_wxWindow,
41067 &_swigt__p_wxWindowCreateEvent,
41068 &_swigt__p_wxWindowDestroyEvent,
41069 &_swigt__p_wxWindowDisabler,
41070 &_swigt__p_wxXPMHandler,
41071 };
41072
41073 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41083 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}};
41084 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41092 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}};
41093 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41098 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}};
41099 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41100 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}};
41101 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41144 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}};
41145 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41151 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}};
41152 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41163 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}};
41164 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41207 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}};
41208 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41218 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}};
41219 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41232 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41233 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41236 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}};
41237 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41241 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}};
41242 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41244 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41245 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}};
41246 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41247
41248 static swig_cast_info *swig_cast_initial[] = {
41249 _swigc__p_char,
41250 _swigc__p_form_ops_t,
41251 _swigc__p_int,
41252 _swigc__p_unsigned_char,
41253 _swigc__p_unsigned_int,
41254 _swigc__p_unsigned_long,
41255 _swigc__p_void,
41256 _swigc__p_wxANIHandler,
41257 _swigc__p_wxAboutDialogInfo,
41258 _swigc__p_wxAcceleratorTable,
41259 _swigc__p_wxActivateEvent,
41260 _swigc__p_wxArrayString,
41261 _swigc__p_wxBMPHandler,
41262 _swigc__p_wxBitmap,
41263 _swigc__p_wxBitmapDataObject,
41264 _swigc__p_wxBoxSizer,
41265 _swigc__p_wxBusyCursor,
41266 _swigc__p_wxBusyInfo,
41267 _swigc__p_wxCURHandler,
41268 _swigc__p_wxCaret,
41269 _swigc__p_wxChar,
41270 _swigc__p_wxChildFocusEvent,
41271 _swigc__p_wxClipboard,
41272 _swigc__p_wxClipboardLocker,
41273 _swigc__p_wxClipboardTextEvent,
41274 _swigc__p_wxCloseEvent,
41275 _swigc__p_wxColour,
41276 _swigc__p_wxCommandEvent,
41277 _swigc__p_wxConfig,
41278 _swigc__p_wxConfigBase,
41279 _swigc__p_wxConfigPathChanger,
41280 _swigc__p_wxContextMenuEvent,
41281 _swigc__p_wxControl,
41282 _swigc__p_wxControlWithItems,
41283 _swigc__p_wxCursor,
41284 _swigc__p_wxCustomDataObject,
41285 _swigc__p_wxDC,
41286 _swigc__p_wxDataFormat,
41287 _swigc__p_wxDataObject,
41288 _swigc__p_wxDataObjectComposite,
41289 _swigc__p_wxDataObjectSimple,
41290 _swigc__p_wxDateEvent,
41291 _swigc__p_wxDateSpan,
41292 _swigc__p_wxDateTime,
41293 _swigc__p_wxDateTime__TimeZone,
41294 _swigc__p_wxDisplay,
41295 _swigc__p_wxDisplayChangedEvent,
41296 _swigc__p_wxDropFilesEvent,
41297 _swigc__p_wxDuplexMode,
41298 _swigc__p_wxEraseEvent,
41299 _swigc__p_wxEvent,
41300 _swigc__p_wxEvtHandler,
41301 _swigc__p_wxFSFile,
41302 _swigc__p_wxFileConfig,
41303 _swigc__p_wxFileDataObject,
41304 _swigc__p_wxFileHistory,
41305 _swigc__p_wxFileSystem,
41306 _swigc__p_wxFileType,
41307 _swigc__p_wxFileTypeInfo,
41308 _swigc__p_wxFlexGridSizer,
41309 _swigc__p_wxFocusEvent,
41310 _swigc__p_wxFont,
41311 _swigc__p_wxFrame,
41312 _swigc__p_wxGBSizerItem,
41313 _swigc__p_wxGIFHandler,
41314 _swigc__p_wxGridBagSizer,
41315 _swigc__p_wxGridSizer,
41316 _swigc__p_wxICOHandler,
41317 _swigc__p_wxIcon,
41318 _swigc__p_wxIconizeEvent,
41319 _swigc__p_wxIdleEvent,
41320 _swigc__p_wxImage,
41321 _swigc__p_wxImageHandler,
41322 _swigc__p_wxIndividualLayoutConstraint,
41323 _swigc__p_wxInitDialogEvent,
41324 _swigc__p_wxJPEGHandler,
41325 _swigc__p_wxJoystick,
41326 _swigc__p_wxJoystickEvent,
41327 _swigc__p_wxKeyEvent,
41328 _swigc__p_wxKillError,
41329 _swigc__p_wxLayoutConstraints,
41330 _swigc__p_wxLog,
41331 _swigc__p_wxLogBuffer,
41332 _swigc__p_wxLogChain,
41333 _swigc__p_wxLogGui,
41334 _swigc__p_wxLogNull,
41335 _swigc__p_wxLogStderr,
41336 _swigc__p_wxLogTextCtrl,
41337 _swigc__p_wxLogWindow,
41338 _swigc__p_wxMaximizeEvent,
41339 _swigc__p_wxMenu,
41340 _swigc__p_wxMenuBar,
41341 _swigc__p_wxMenuEvent,
41342 _swigc__p_wxMenuItem,
41343 _swigc__p_wxMetafileDataObject,
41344 _swigc__p_wxMimeTypesManager,
41345 _swigc__p_wxMouseCaptureChangedEvent,
41346 _swigc__p_wxMouseCaptureLostEvent,
41347 _swigc__p_wxMouseEvent,
41348 _swigc__p_wxMouseState,
41349 _swigc__p_wxMoveEvent,
41350 _swigc__p_wxMutexGuiLocker,
41351 _swigc__p_wxNavigationKeyEvent,
41352 _swigc__p_wxNcPaintEvent,
41353 _swigc__p_wxNotifyEvent,
41354 _swigc__p_wxObject,
41355 _swigc__p_wxOutputStream,
41356 _swigc__p_wxPCXHandler,
41357 _swigc__p_wxPNGHandler,
41358 _swigc__p_wxPNMHandler,
41359 _swigc__p_wxPaintEvent,
41360 _swigc__p_wxPaletteChangedEvent,
41361 _swigc__p_wxPaperSize,
41362 _swigc__p_wxPlatformInfo,
41363 _swigc__p_wxPoint,
41364 _swigc__p_wxPowerEvent,
41365 _swigc__p_wxProcessEvent,
41366 _swigc__p_wxPyApp,
41367 _swigc__p_wxPyArtProvider,
41368 _swigc__p_wxPyBitmapDataObject,
41369 _swigc__p_wxPyCommandEvent,
41370 _swigc__p_wxPyDataObjectSimple,
41371 _swigc__p_wxPyDropSource,
41372 _swigc__p_wxPyDropTarget,
41373 _swigc__p_wxPyEvent,
41374 _swigc__p_wxPyFileDropTarget,
41375 _swigc__p_wxPyImageHandler,
41376 _swigc__p_wxPyLog,
41377 _swigc__p_wxPyProcess,
41378 _swigc__p_wxPySizer,
41379 _swigc__p_wxPyTextDataObject,
41380 _swigc__p_wxPyTextDropTarget,
41381 _swigc__p_wxPyTimer,
41382 _swigc__p_wxPyTipProvider,
41383 _swigc__p_wxPyValidator,
41384 _swigc__p_wxQueryNewPaletteEvent,
41385 _swigc__p_wxRect,
41386 _swigc__p_wxScrollEvent,
41387 _swigc__p_wxScrollWinEvent,
41388 _swigc__p_wxSetCursorEvent,
41389 _swigc__p_wxShowEvent,
41390 _swigc__p_wxSingleInstanceChecker,
41391 _swigc__p_wxSize,
41392 _swigc__p_wxSizeEvent,
41393 _swigc__p_wxSizer,
41394 _swigc__p_wxSizerItem,
41395 _swigc__p_wxSound,
41396 _swigc__p_wxStandardPaths,
41397 _swigc__p_wxStaticBoxSizer,
41398 _swigc__p_wxStdDialogButtonSizer,
41399 _swigc__p_wxStopWatch,
41400 _swigc__p_wxString,
41401 _swigc__p_wxSysColourChangedEvent,
41402 _swigc__p_wxSystemOptions,
41403 _swigc__p_wxSystemSettings,
41404 _swigc__p_wxTGAHandler,
41405 _swigc__p_wxTIFFHandler,
41406 _swigc__p_wxTextCtrl,
41407 _swigc__p_wxTextDataObject,
41408 _swigc__p_wxTimeSpan,
41409 _swigc__p_wxTimer,
41410 _swigc__p_wxTimerEvent,
41411 _swigc__p_wxTimerRunner,
41412 _swigc__p_wxTipProvider,
41413 _swigc__p_wxToolTip,
41414 _swigc__p_wxURLDataObject,
41415 _swigc__p_wxUpdateUIEvent,
41416 _swigc__p_wxValidator,
41417 _swigc__p_wxVideoMode,
41418 _swigc__p_wxWindow,
41419 _swigc__p_wxWindowCreateEvent,
41420 _swigc__p_wxWindowDestroyEvent,
41421 _swigc__p_wxWindowDisabler,
41422 _swigc__p_wxXPMHandler,
41423 };
41424
41425
41426 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41427
41428 static swig_const_info swig_const_table[] = {
41429 {0, 0, 0, 0.0, 0, 0}};
41430
41431 #ifdef __cplusplus
41432 }
41433 #endif
41434 /* -----------------------------------------------------------------------------
41435 * Type initialization:
41436 * This problem is tough by the requirement that no dynamic
41437 * memory is used. Also, since swig_type_info structures store pointers to
41438 * swig_cast_info structures and swig_cast_info structures store pointers back
41439 * to swig_type_info structures, we need some lookup code at initialization.
41440 * The idea is that swig generates all the structures that are needed.
41441 * The runtime then collects these partially filled structures.
41442 * The SWIG_InitializeModule function takes these initial arrays out of
41443 * swig_module, and does all the lookup, filling in the swig_module.types
41444 * array with the correct data and linking the correct swig_cast_info
41445 * structures together.
41446 *
41447 * The generated swig_type_info structures are assigned staticly to an initial
41448 * array. We just loop though that array, and handle each type individually.
41449 * First we lookup if this type has been already loaded, and if so, use the
41450 * loaded structure instead of the generated one. Then we have to fill in the
41451 * cast linked list. The cast data is initially stored in something like a
41452 * two-dimensional array. Each row corresponds to a type (there are the same
41453 * number of rows as there are in the swig_type_initial array). Each entry in
41454 * a column is one of the swig_cast_info structures for that type.
41455 * The cast_initial array is actually an array of arrays, because each row has
41456 * a variable number of columns. So to actually build the cast linked list,
41457 * we find the array of casts associated with the type, and loop through it
41458 * adding the casts to the list. The one last trick we need to do is making
41459 * sure the type pointer in the swig_cast_info struct is correct.
41460 *
41461 * First off, we lookup the cast->type name to see if it is already loaded.
41462 * There are three cases to handle:
41463 * 1) If the cast->type has already been loaded AND the type we are adding
41464 * casting info to has not been loaded (it is in this module), THEN we
41465 * replace the cast->type pointer with the type pointer that has already
41466 * been loaded.
41467 * 2) If BOTH types (the one we are adding casting info to, and the
41468 * cast->type) are loaded, THEN the cast info has already been loaded by
41469 * the previous module so we just ignore it.
41470 * 3) Finally, if cast->type has not already been loaded, then we add that
41471 * swig_cast_info to the linked list (because the cast->type) pointer will
41472 * be correct.
41473 * ----------------------------------------------------------------------------- */
41474
41475 #ifdef __cplusplus
41476 extern "C" {
41477 #if 0
41478 } /* c-mode */
41479 #endif
41480 #endif
41481
41482 #if 0
41483 #define SWIGRUNTIME_DEBUG
41484 #endif
41485
41486 SWIGRUNTIME void
41487 SWIG_InitializeModule(void *clientdata) {
41488 size_t i;
41489 swig_module_info *module_head;
41490 static int init_run = 0;
41491
41492 clientdata = clientdata;
41493
41494 if (init_run) return;
41495 init_run = 1;
41496
41497 /* Initialize the swig_module */
41498 swig_module.type_initial = swig_type_initial;
41499 swig_module.cast_initial = swig_cast_initial;
41500
41501 /* Try and load any already created modules */
41502 module_head = SWIG_GetModule(clientdata);
41503 if (module_head) {
41504 swig_module.next = module_head->next;
41505 module_head->next = &swig_module;
41506 } else {
41507 /* This is the first module loaded */
41508 swig_module.next = &swig_module;
41509 SWIG_SetModule(clientdata, &swig_module);
41510 }
41511
41512 /* Now work on filling in swig_module.types */
41513 #ifdef SWIGRUNTIME_DEBUG
41514 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41515 #endif
41516 for (i = 0; i < swig_module.size; ++i) {
41517 swig_type_info *type = 0;
41518 swig_type_info *ret;
41519 swig_cast_info *cast;
41520
41521 #ifdef SWIGRUNTIME_DEBUG
41522 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41523 #endif
41524
41525 /* if there is another module already loaded */
41526 if (swig_module.next != &swig_module) {
41527 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41528 }
41529 if (type) {
41530 /* Overwrite clientdata field */
41531 #ifdef SWIGRUNTIME_DEBUG
41532 printf("SWIG_InitializeModule: found type %s\n", type->name);
41533 #endif
41534 if (swig_module.type_initial[i]->clientdata) {
41535 type->clientdata = swig_module.type_initial[i]->clientdata;
41536 #ifdef SWIGRUNTIME_DEBUG
41537 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41538 #endif
41539 }
41540 } else {
41541 type = swig_module.type_initial[i];
41542 }
41543
41544 /* Insert casting types */
41545 cast = swig_module.cast_initial[i];
41546 while (cast->type) {
41547 /* Don't need to add information already in the list */
41548 ret = 0;
41549 #ifdef SWIGRUNTIME_DEBUG
41550 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41551 #endif
41552 if (swig_module.next != &swig_module) {
41553 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41554 #ifdef SWIGRUNTIME_DEBUG
41555 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41556 #endif
41557 }
41558 if (ret) {
41559 if (type == swig_module.type_initial[i]) {
41560 #ifdef SWIGRUNTIME_DEBUG
41561 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41562 #endif
41563 cast->type = ret;
41564 ret = 0;
41565 } else {
41566 /* Check for casting already in the list */
41567 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41568 #ifdef SWIGRUNTIME_DEBUG
41569 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41570 #endif
41571 if (!ocast) ret = 0;
41572 }
41573 }
41574
41575 if (!ret) {
41576 #ifdef SWIGRUNTIME_DEBUG
41577 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41578 #endif
41579 if (type->cast) {
41580 type->cast->prev = cast;
41581 cast->next = type->cast;
41582 }
41583 type->cast = cast;
41584 }
41585 cast++;
41586 }
41587 /* Set entry in modules->types array equal to the type */
41588 swig_module.types[i] = type;
41589 }
41590 swig_module.types[i] = 0;
41591
41592 #ifdef SWIGRUNTIME_DEBUG
41593 printf("**** SWIG_InitializeModule: Cast List ******\n");
41594 for (i = 0; i < swig_module.size; ++i) {
41595 int j = 0;
41596 swig_cast_info *cast = swig_module.cast_initial[i];
41597 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41598 while (cast->type) {
41599 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41600 cast++;
41601 ++j;
41602 }
41603 printf("---- Total casts: %d\n",j);
41604 }
41605 printf("**** SWIG_InitializeModule: Cast List ******\n");
41606 #endif
41607 }
41608
41609 /* This function will propagate the clientdata field of type to
41610 * any new swig_type_info structures that have been added into the list
41611 * of equivalent types. It is like calling
41612 * SWIG_TypeClientData(type, clientdata) a second time.
41613 */
41614 SWIGRUNTIME void
41615 SWIG_PropagateClientData(void) {
41616 size_t i;
41617 swig_cast_info *equiv;
41618 static int init_run = 0;
41619
41620 if (init_run) return;
41621 init_run = 1;
41622
41623 for (i = 0; i < swig_module.size; i++) {
41624 if (swig_module.types[i]->clientdata) {
41625 equiv = swig_module.types[i]->cast;
41626 while (equiv) {
41627 if (!equiv->converter) {
41628 if (equiv->type && !equiv->type->clientdata)
41629 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41630 }
41631 equiv = equiv->next;
41632 }
41633 }
41634 }
41635 }
41636
41637 #ifdef __cplusplus
41638 #if 0
41639 {
41640 /* c-mode */
41641 #endif
41642 }
41643 #endif
41644
41645
41646
41647 #ifdef __cplusplus
41648 extern "C" {
41649 #endif
41650
41651 /* Python-specific SWIG API */
41652 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41653 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41654 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41655
41656 /* -----------------------------------------------------------------------------
41657 * global variable support code.
41658 * ----------------------------------------------------------------------------- */
41659
41660 typedef struct swig_globalvar {
41661 char *name; /* Name of global variable */
41662 PyObject *(*get_attr)(void); /* Return the current value */
41663 int (*set_attr)(PyObject *); /* Set the value */
41664 struct swig_globalvar *next;
41665 } swig_globalvar;
41666
41667 typedef struct swig_varlinkobject {
41668 PyObject_HEAD
41669 swig_globalvar *vars;
41670 } swig_varlinkobject;
41671
41672 SWIGINTERN PyObject *
41673 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41674 return PyString_FromString("<Swig global variables>");
41675 }
41676
41677 SWIGINTERN PyObject *
41678 swig_varlink_str(swig_varlinkobject *v) {
41679 PyObject *str = PyString_FromString("(");
41680 swig_globalvar *var;
41681 for (var = v->vars; var; var=var->next) {
41682 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41683 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41684 }
41685 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41686 return str;
41687 }
41688
41689 SWIGINTERN int
41690 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41691 PyObject *str = swig_varlink_str(v);
41692 fprintf(fp,"Swig global variables ");
41693 fprintf(fp,"%s\n", PyString_AsString(str));
41694 Py_DECREF(str);
41695 return 0;
41696 }
41697
41698 SWIGINTERN void
41699 swig_varlink_dealloc(swig_varlinkobject *v) {
41700 swig_globalvar *var = v->vars;
41701 while (var) {
41702 swig_globalvar *n = var->next;
41703 free(var->name);
41704 free(var);
41705 var = n;
41706 }
41707 }
41708
41709 SWIGINTERN PyObject *
41710 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41711 PyObject *res = NULL;
41712 swig_globalvar *var = v->vars;
41713 while (var) {
41714 if (strcmp(var->name,n) == 0) {
41715 res = (*var->get_attr)();
41716 break;
41717 }
41718 var = var->next;
41719 }
41720 if (res == NULL && !PyErr_Occurred()) {
41721 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41722 }
41723 return res;
41724 }
41725
41726 SWIGINTERN int
41727 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41728 int res = 1;
41729 swig_globalvar *var = v->vars;
41730 while (var) {
41731 if (strcmp(var->name,n) == 0) {
41732 res = (*var->set_attr)(p);
41733 break;
41734 }
41735 var = var->next;
41736 }
41737 if (res == 1 && !PyErr_Occurred()) {
41738 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41739 }
41740 return res;
41741 }
41742
41743 SWIGINTERN PyTypeObject*
41744 swig_varlink_type(void) {
41745 static char varlink__doc__[] = "Swig var link object";
41746 static PyTypeObject varlink_type;
41747 static int type_init = 0;
41748 if (!type_init) {
41749 const PyTypeObject tmp
41750 = {
41751 PyObject_HEAD_INIT(NULL)
41752 0, /* Number of items in variable part (ob_size) */
41753 (char *)"swigvarlink", /* Type name (tp_name) */
41754 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41755 0, /* Itemsize (tp_itemsize) */
41756 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41757 (printfunc) swig_varlink_print, /* Print (tp_print) */
41758 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41759 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41760 0, /* tp_compare */
41761 (reprfunc) swig_varlink_repr, /* tp_repr */
41762 0, /* tp_as_number */
41763 0, /* tp_as_sequence */
41764 0, /* tp_as_mapping */
41765 0, /* tp_hash */
41766 0, /* tp_call */
41767 (reprfunc)swig_varlink_str, /* tp_str */
41768 0, /* tp_getattro */
41769 0, /* tp_setattro */
41770 0, /* tp_as_buffer */
41771 0, /* tp_flags */
41772 varlink__doc__, /* tp_doc */
41773 0, /* tp_traverse */
41774 0, /* tp_clear */
41775 0, /* tp_richcompare */
41776 0, /* tp_weaklistoffset */
41777 #if PY_VERSION_HEX >= 0x02020000
41778 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41779 #endif
41780 #if PY_VERSION_HEX >= 0x02030000
41781 0, /* tp_del */
41782 #endif
41783 #ifdef COUNT_ALLOCS
41784 0,0,0,0 /* tp_alloc -> tp_next */
41785 #endif
41786 };
41787 varlink_type = tmp;
41788 varlink_type.ob_type = &PyType_Type;
41789 type_init = 1;
41790 }
41791 return &varlink_type;
41792 }
41793
41794 /* Create a variable linking object for use later */
41795 SWIGINTERN PyObject *
41796 SWIG_Python_newvarlink(void) {
41797 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41798 if (result) {
41799 result->vars = 0;
41800 }
41801 return ((PyObject*) result);
41802 }
41803
41804 SWIGINTERN void
41805 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41806 swig_varlinkobject *v = (swig_varlinkobject *) p;
41807 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41808 if (gv) {
41809 size_t size = strlen(name)+1;
41810 gv->name = (char *)malloc(size);
41811 if (gv->name) {
41812 strncpy(gv->name,name,size);
41813 gv->get_attr = get_attr;
41814 gv->set_attr = set_attr;
41815 gv->next = v->vars;
41816 }
41817 }
41818 v->vars = gv;
41819 }
41820
41821 SWIGINTERN PyObject *
41822 SWIG_globals() {
41823 static PyObject *_SWIG_globals = 0;
41824 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41825 return _SWIG_globals;
41826 }
41827
41828 /* -----------------------------------------------------------------------------
41829 * constants/methods manipulation
41830 * ----------------------------------------------------------------------------- */
41831
41832 /* Install Constants */
41833 SWIGINTERN void
41834 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41835 PyObject *obj = 0;
41836 size_t i;
41837 for (i = 0; constants[i].type; ++i) {
41838 switch(constants[i].type) {
41839 case SWIG_PY_POINTER:
41840 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41841 break;
41842 case SWIG_PY_BINARY:
41843 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41844 break;
41845 default:
41846 obj = 0;
41847 break;
41848 }
41849 if (obj) {
41850 PyDict_SetItemString(d, constants[i].name, obj);
41851 Py_DECREF(obj);
41852 }
41853 }
41854 }
41855
41856 /* -----------------------------------------------------------------------------*/
41857 /* Fix SwigMethods to carry the callback ptrs when needed */
41858 /* -----------------------------------------------------------------------------*/
41859
41860 SWIGINTERN void
41861 SWIG_Python_FixMethods(PyMethodDef *methods,
41862 swig_const_info *const_table,
41863 swig_type_info **types,
41864 swig_type_info **types_initial) {
41865 size_t i;
41866 for (i = 0; methods[i].ml_name; ++i) {
41867 const char *c = methods[i].ml_doc;
41868 if (c && (c = strstr(c, "swig_ptr: "))) {
41869 int j;
41870 swig_const_info *ci = 0;
41871 const char *name = c + 10;
41872 for (j = 0; const_table[j].type; ++j) {
41873 if (strncmp(const_table[j].name, name,
41874 strlen(const_table[j].name)) == 0) {
41875 ci = &(const_table[j]);
41876 break;
41877 }
41878 }
41879 if (ci) {
41880 size_t shift = (ci->ptype) - types;
41881 swig_type_info *ty = types_initial[shift];
41882 size_t ldoc = (c - methods[i].ml_doc);
41883 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41884 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41885 if (ndoc) {
41886 char *buff = ndoc;
41887 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41888 if (ptr) {
41889 strncpy(buff, methods[i].ml_doc, ldoc);
41890 buff += ldoc;
41891 strncpy(buff, "swig_ptr: ", 10);
41892 buff += 10;
41893 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41894 methods[i].ml_doc = ndoc;
41895 }
41896 }
41897 }
41898 }
41899 }
41900 }
41901
41902 #ifdef __cplusplus
41903 }
41904 #endif
41905
41906 /* -----------------------------------------------------------------------------*
41907 * Partial Init method
41908 * -----------------------------------------------------------------------------*/
41909
41910 #ifdef __cplusplus
41911 extern "C"
41912 #endif
41913 SWIGEXPORT void SWIG_init(void) {
41914 PyObject *m, *d;
41915
41916 /* Fix SwigMethods to carry the callback ptrs when needed */
41917 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41918
41919 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41920 d = PyModule_GetDict(m);
41921
41922 SWIG_InitializeModule(0);
41923 SWIG_InstallConstants(d,swig_const_table);
41924
41925
41926 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41927 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41928 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41929 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41930 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41931 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41932 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41933 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41934 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41935 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41936 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41937 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41938 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41939 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41940 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41941 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41942 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41943 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41944 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41945 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41946 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41947 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41948 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41949 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41950 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41951 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41952 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41953 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41954 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41955 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41956 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41957 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41958 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41959 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41960 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41961 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41962 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41963 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41964 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41965 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41966 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41967 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41968 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41969 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41970 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41971 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41972 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41973 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41974 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41975 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41976 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41977 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41978 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41979 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41980 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41981 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41982 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41983 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41984 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41985 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41986 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41987 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41988 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41989 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41990 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41991 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41992 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41993 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41994 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41995 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41996 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41997 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41998 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41999 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42000 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42001 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42002 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42003 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42004 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42005 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42006 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42007 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42008 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42009 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42010 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42011 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42012 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42013 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42014 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42015 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42016 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42017 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42018 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42019 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42020 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42021 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42022 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42023 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42024 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42025 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42026 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42027 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42028 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42029 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42030 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42031 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42032 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42033 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42034 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42035 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42036 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42037 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42038 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42039 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42040 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42041 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42042 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42043 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42044 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42045 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42046 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42047 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42048 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42049 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42050 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42051 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42052 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42053 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42054 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42055 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42056 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42057 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42058 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42059 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42060 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42061 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42062 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42063 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42064 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42065 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42066 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42067 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42068 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42069 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42070 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42071 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42072 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42073 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42074
42075 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42076
42077 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42078 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42079 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42080 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42081 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42082 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42083 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42084 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42085 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42086 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42087 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42088 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42089 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42090 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42091 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42092 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42093 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42094 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42095 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42096 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42097 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42098 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42099 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42100 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42101 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42102 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42103 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42104 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42105 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42106 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42107 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42108 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42109 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42110 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42111 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42112 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42113 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42114 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42115 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42116 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42117 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42118 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42119 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42120 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42121 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42122 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42123 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42124 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42125 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42126 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42127 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42128 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42129 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42130
42131 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42132
42133 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42134 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42135 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42136 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42137 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42138 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42139 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42140 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42141 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42142 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42143 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42144 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42145 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42146 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42147 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42148 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42149 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42150 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42151 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42152 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42209
42210 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42211
42212 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42213 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42214 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42215 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42216 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42217 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42218 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42219 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42220 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42221 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42222 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42223 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42224 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42225 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42226 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42227 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42228 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42229 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42230 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42231 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42232 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42233 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42234 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42235 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42236 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42237 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42238 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42239 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42240 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42241 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42242 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42243 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42244 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42245 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42246 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42247 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42248 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42249 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42250 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42251 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42252 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42253 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42254 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42255 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42256 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42257 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42258 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42259 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42260 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42261 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42262 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42263 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42264 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42265 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42266 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42267 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42268 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42269 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42270 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42271 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42272 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42273 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42274 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42275 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42276 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42277 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42278 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42279 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42280 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42281 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42282 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42283 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42284 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42285 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42286 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42287 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42288 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42289 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42290 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42291 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42292 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42293 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42294 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42295 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42296 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42297 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42298 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42299 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42300 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42301 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42302 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42303 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42304 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42305 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42306 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42307 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42308 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42309 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42310 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42311 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42312 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42313 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42314 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42315 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42316 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42317 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42318 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42319 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42320 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42321 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42322 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42323 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42324 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42325 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42326 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42327 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42328 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42329 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42330 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42331 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42332 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42333 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42334 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42335 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42336 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42337 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42338 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42339 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42340 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42341 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42342 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42343 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42344 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42345 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42346 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42347 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42348 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42349 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42350 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42351 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42352 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42353 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42354 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42355 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42356 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42357 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42358 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42359 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42360 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42361 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42362 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42363 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42364 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42365 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42366 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42367 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42368 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42369 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42370 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42371 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42372 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42373 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42374 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42375 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42376 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42377 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42378 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42379 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42380 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42381 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42382 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42383 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42384 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42385 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42386 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42387 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42388 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42389 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42390 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42391 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42392 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42393 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42394 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42395 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42396 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42397 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42398 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42399 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42400 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42401 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42402 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42403 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42404 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42405 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42406 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42407 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42408 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42409 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42410 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42411 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42412 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42413 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42414 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42415
42416 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42417 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42418 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42419 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42420
42421 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42422 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42423 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42424 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42425 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42426 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42427 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42428 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42429 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42430 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42431 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42432 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42433 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42434 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42435 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42436 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42437 }
42438
wxWidgets (Impactor)