]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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_wxArtClient swig_types[12]
2479 #define SWIGTYPE_p_wxArtID swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBitmapDataObject swig_types[16]
2483 #define SWIGTYPE_p_wxBoxSizer swig_types[17]
2484 #define SWIGTYPE_p_wxBusyCursor swig_types[18]
2485 #define SWIGTYPE_p_wxBusyInfo swig_types[19]
2486 #define SWIGTYPE_p_wxCURHandler swig_types[20]
2487 #define SWIGTYPE_p_wxCaret swig_types[21]
2488 #define SWIGTYPE_p_wxChar swig_types[22]
2489 #define SWIGTYPE_p_wxChildFocusEvent swig_types[23]
2490 #define SWIGTYPE_p_wxClipboard swig_types[24]
2491 #define SWIGTYPE_p_wxClipboardLocker swig_types[25]
2492 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[26]
2493 #define SWIGTYPE_p_wxCloseEvent swig_types[27]
2494 #define SWIGTYPE_p_wxColour swig_types[28]
2495 #define SWIGTYPE_p_wxCommandEvent swig_types[29]
2496 #define SWIGTYPE_p_wxConfig swig_types[30]
2497 #define SWIGTYPE_p_wxConfigBase swig_types[31]
2498 #define SWIGTYPE_p_wxConfigPathChanger swig_types[32]
2499 #define SWIGTYPE_p_wxContextMenuEvent swig_types[33]
2500 #define SWIGTYPE_p_wxControl swig_types[34]
2501 #define SWIGTYPE_p_wxControlWithItems swig_types[35]
2502 #define SWIGTYPE_p_wxCursor swig_types[36]
2503 #define SWIGTYPE_p_wxCustomDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDC swig_types[38]
2505 #define SWIGTYPE_p_wxDataFormat swig_types[39]
2506 #define SWIGTYPE_p_wxDataObject swig_types[40]
2507 #define SWIGTYPE_p_wxDataObjectComposite swig_types[41]
2508 #define SWIGTYPE_p_wxDataObjectSimple swig_types[42]
2509 #define SWIGTYPE_p_wxDateEvent swig_types[43]
2510 #define SWIGTYPE_p_wxDateSpan swig_types[44]
2511 #define SWIGTYPE_p_wxDateTime swig_types[45]
2512 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[46]
2513 #define SWIGTYPE_p_wxDisplay swig_types[47]
2514 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[48]
2515 #define SWIGTYPE_p_wxDropFilesEvent swig_types[49]
2516 #define SWIGTYPE_p_wxDuplexMode swig_types[50]
2517 #define SWIGTYPE_p_wxEraseEvent swig_types[51]
2518 #define SWIGTYPE_p_wxEvent swig_types[52]
2519 #define SWIGTYPE_p_wxEventBlocker swig_types[53]
2520 #define SWIGTYPE_p_wxEvtHandler swig_types[54]
2521 #define SWIGTYPE_p_wxFSFile swig_types[55]
2522 #define SWIGTYPE_p_wxFileConfig swig_types[56]
2523 #define SWIGTYPE_p_wxFileDataObject swig_types[57]
2524 #define SWIGTYPE_p_wxFileHistory swig_types[58]
2525 #define SWIGTYPE_p_wxFileSystem swig_types[59]
2526 #define SWIGTYPE_p_wxFileType swig_types[60]
2527 #define SWIGTYPE_p_wxFileTypeInfo swig_types[61]
2528 #define SWIGTYPE_p_wxFlexGridSizer swig_types[62]
2529 #define SWIGTYPE_p_wxFocusEvent swig_types[63]
2530 #define SWIGTYPE_p_wxFont swig_types[64]
2531 #define SWIGTYPE_p_wxFrame swig_types[65]
2532 #define SWIGTYPE_p_wxGBSizerItem swig_types[66]
2533 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
2534 #define SWIGTYPE_p_wxGridBagSizer swig_types[68]
2535 #define SWIGTYPE_p_wxGridSizer swig_types[69]
2536 #define SWIGTYPE_p_wxICOHandler swig_types[70]
2537 #define SWIGTYPE_p_wxIcon swig_types[71]
2538 #define SWIGTYPE_p_wxIconBundle swig_types[72]
2539 #define SWIGTYPE_p_wxIconizeEvent swig_types[73]
2540 #define SWIGTYPE_p_wxIdleEvent swig_types[74]
2541 #define SWIGTYPE_p_wxImage swig_types[75]
2542 #define SWIGTYPE_p_wxImageHandler swig_types[76]
2543 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[77]
2544 #define SWIGTYPE_p_wxInitDialogEvent swig_types[78]
2545 #define SWIGTYPE_p_wxJPEGHandler swig_types[79]
2546 #define SWIGTYPE_p_wxJoystick swig_types[80]
2547 #define SWIGTYPE_p_wxJoystickEvent swig_types[81]
2548 #define SWIGTYPE_p_wxKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxKillError swig_types[83]
2550 #define SWIGTYPE_p_wxLayoutConstraints swig_types[84]
2551 #define SWIGTYPE_p_wxLog swig_types[85]
2552 #define SWIGTYPE_p_wxLogBuffer swig_types[86]
2553 #define SWIGTYPE_p_wxLogChain swig_types[87]
2554 #define SWIGTYPE_p_wxLogGui swig_types[88]
2555 #define SWIGTYPE_p_wxLogNull swig_types[89]
2556 #define SWIGTYPE_p_wxLogStderr swig_types[90]
2557 #define SWIGTYPE_p_wxLogTextCtrl swig_types[91]
2558 #define SWIGTYPE_p_wxLogWindow swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMetafileDataObject swig_types[98]
2565 #define SWIGTYPE_p_wxMimeTypesManager swig_types[99]
2566 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMouseState swig_types[103]
2570 #define SWIGTYPE_p_wxMoveEvent swig_types[104]
2571 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[105]
2572 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNcPaintEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNotifyEvent swig_types[108]
2575 #define SWIGTYPE_p_wxObject swig_types[109]
2576 #define SWIGTYPE_p_wxOutputStream swig_types[110]
2577 #define SWIGTYPE_p_wxPCXHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPNGHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPNMHandler swig_types[113]
2580 #define SWIGTYPE_p_wxPaintEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPaperSize swig_types[116]
2583 #define SWIGTYPE_p_wxPlatformInfo swig_types[117]
2584 #define SWIGTYPE_p_wxPoint swig_types[118]
2585 #define SWIGTYPE_p_wxPowerEvent swig_types[119]
2586 #define SWIGTYPE_p_wxProcessEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyApp swig_types[121]
2588 #define SWIGTYPE_p_wxPyArtProvider swig_types[122]
2589 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[123]
2590 #define SWIGTYPE_p_wxPyCommandEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[125]
2592 #define SWIGTYPE_p_wxPyDropSource swig_types[126]
2593 #define SWIGTYPE_p_wxPyDropTarget swig_types[127]
2594 #define SWIGTYPE_p_wxPyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[129]
2596 #define SWIGTYPE_p_wxPyImageHandler swig_types[130]
2597 #define SWIGTYPE_p_wxPyLog swig_types[131]
2598 #define SWIGTYPE_p_wxPyProcess swig_types[132]
2599 #define SWIGTYPE_p_wxPySizer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTextDataObject swig_types[134]
2601 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[135]
2602 #define SWIGTYPE_p_wxPyTimer swig_types[136]
2603 #define SWIGTYPE_p_wxPyTipProvider swig_types[137]
2604 #define SWIGTYPE_p_wxPyValidator swig_types[138]
2605 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[139]
2606 #define SWIGTYPE_p_wxRect swig_types[140]
2607 #define SWIGTYPE_p_wxScrollEvent swig_types[141]
2608 #define SWIGTYPE_p_wxScrollWinEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSetCursorEvent swig_types[143]
2610 #define SWIGTYPE_p_wxShowEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[145]
2612 #define SWIGTYPE_p_wxSize swig_types[146]
2613 #define SWIGTYPE_p_wxSizeEvent swig_types[147]
2614 #define SWIGTYPE_p_wxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxSizerItem swig_types[149]
2616 #define SWIGTYPE_p_wxSound swig_types[150]
2617 #define SWIGTYPE_p_wxStandardPaths swig_types[151]
2618 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[152]
2619 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[153]
2620 #define SWIGTYPE_p_wxStopWatch swig_types[154]
2621 #define SWIGTYPE_p_wxString swig_types[155]
2622 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[156]
2623 #define SWIGTYPE_p_wxSystemOptions swig_types[157]
2624 #define SWIGTYPE_p_wxSystemSettings swig_types[158]
2625 #define SWIGTYPE_p_wxTGAHandler swig_types[159]
2626 #define SWIGTYPE_p_wxTIFFHandler swig_types[160]
2627 #define SWIGTYPE_p_wxTextCtrl swig_types[161]
2628 #define SWIGTYPE_p_wxTextDataObject swig_types[162]
2629 #define SWIGTYPE_p_wxTimeSpan swig_types[163]
2630 #define SWIGTYPE_p_wxTimer swig_types[164]
2631 #define SWIGTYPE_p_wxTimerEvent swig_types[165]
2632 #define SWIGTYPE_p_wxTimerRunner swig_types[166]
2633 #define SWIGTYPE_p_wxTipProvider swig_types[167]
2634 #define SWIGTYPE_p_wxToolTip swig_types[168]
2635 #define SWIGTYPE_p_wxURLDataObject swig_types[169]
2636 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[170]
2637 #define SWIGTYPE_p_wxValidator swig_types[171]
2638 #define SWIGTYPE_p_wxVideoMode swig_types[172]
2639 #define SWIGTYPE_p_wxWindow swig_types[173]
2640 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[174]
2641 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[175]
2642 #define SWIGTYPE_p_wxWindowDisabler swig_types[176]
2643 #define SWIGTYPE_p_wxXPMHandler swig_types[177]
2644 static swig_type_info *swig_types[179];
2645 static swig_module_info swig_module = {swig_types, 178, 0, 0, 0, 0};
2646 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2647 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2648
2649 /* -------- TYPES TABLE (END) -------- */
2650
2651 #if (PY_VERSION_HEX <= 0x02000000)
2652 # if !defined(SWIG_PYTHON_CLASSIC)
2653 # error "This python version requires to use swig with the '-classic' option"
2654 # endif
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodern' option"
2658 #endif
2659 #if (PY_VERSION_HEX <= 0x02020000)
2660 # error "This python version requires to use swig with the '-nomodernargs' option"
2661 #endif
2662 #ifndef METH_O
2663 # error "This python version requires to use swig with the '-nofastunpack' option"
2664 #endif
2665
2666 /*-----------------------------------------------
2667 @(target):= _misc_.so
2668 ------------------------------------------------*/
2669 #define SWIG_init init_misc_
2670
2671 #define SWIG_name "_misc_"
2672
2673 #define SWIGVERSION 0x010329
2674
2675
2676 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2677 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2678
2679
2680 #include <stdexcept>
2681
2682
2683 namespace swig {
2684 class PyObject_ptr {
2685 protected:
2686 PyObject *_obj;
2687
2688 public:
2689 PyObject_ptr() :_obj(0)
2690 {
2691 }
2692
2693 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2694 {
2695 Py_XINCREF(_obj);
2696 }
2697
2698 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2699 {
2700 if (initial_ref) Py_XINCREF(_obj);
2701 }
2702
2703 PyObject_ptr & operator=(const PyObject_ptr& item)
2704 {
2705 Py_XINCREF(item._obj);
2706 Py_XDECREF(_obj);
2707 _obj = item._obj;
2708 return *this;
2709 }
2710
2711 ~PyObject_ptr()
2712 {
2713 Py_XDECREF(_obj);
2714 }
2715
2716 operator PyObject *() const
2717 {
2718 return _obj;
2719 }
2720
2721 PyObject *operator->() const
2722 {
2723 return _obj;
2724 }
2725 };
2726 }
2727
2728
2729 namespace swig {
2730 struct PyObject_var : PyObject_ptr {
2731 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2732
2733 PyObject_var & operator = (PyObject* obj)
2734 {
2735 Py_XDECREF(_obj);
2736 _obj = obj;
2737 return *this;
2738 }
2739 };
2740 }
2741
2742
2743 #include "wx/wxPython/wxPython.h"
2744 #include "wx/wxPython/pyclasses.h"
2745 #include "wx/wxPython/pyistream.h"
2746
2747 static const wxString wxPyEmptyString(wxEmptyString);
2748
2749
2750
2751 #define SWIG_From_long PyInt_FromLong
2752
2753
2754 SWIGINTERNINLINE PyObject *
2755 SWIG_From_int (int value)
2756 {
2757 return SWIG_From_long (value);
2758 }
2759
2760
2761 #include <limits.h>
2762 #ifndef LLONG_MIN
2763 # define LLONG_MIN LONG_LONG_MIN
2764 #endif
2765 #ifndef LLONG_MAX
2766 # define LLONG_MAX LONG_LONG_MAX
2767 #endif
2768 #ifndef ULLONG_MAX
2769 # define ULLONG_MAX ULONG_LONG_MAX
2770 #endif
2771
2772
2773 SWIGINTERN int
2774 SWIG_AsVal_long (PyObject* obj, long* val)
2775 {
2776 if (PyNumber_Check(obj)) {
2777 if (val) *val = PyInt_AsLong(obj);
2778 return SWIG_OK;
2779 }
2780 return SWIG_TypeError;
2781 }
2782
2783
2784 SWIGINTERN int
2785 SWIG_AsVal_int (PyObject * obj, int *val)
2786 {
2787 long v;
2788 int res = SWIG_AsVal_long (obj, &v);
2789 if (SWIG_IsOK(res)) {
2790 if ((v < INT_MIN || v > INT_MAX)) {
2791 return SWIG_OverflowError;
2792 } else {
2793 if (val) *val = static_cast< int >(v);
2794 }
2795 }
2796 return res;
2797 }
2798
2799 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2800
2801 #include <wx/stockitem.h>
2802
2803 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2804 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2805 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2806
2807 wxMemorySize wxGetFreeMemory()
2808 { wxPyRaiseNotImplemented(); return 0; }
2809
2810
2811 SWIGINTERN int
2812 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2813 {
2814 long v = 0;
2815 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2816 return SWIG_TypeError;
2817 }
2818 else if (val)
2819 *val = (unsigned long)v;
2820 return SWIG_OK;
2821 }
2822
2823
2824 SWIGINTERN int
2825 SWIG_AsVal_bool (PyObject *obj, bool *val)
2826 {
2827 if (obj == Py_True) {
2828 if (val) *val = true;
2829 return SWIG_OK;
2830 } else if (obj == Py_False) {
2831 if (val) *val = false;
2832 return SWIG_OK;
2833 } else {
2834 long v = 0;
2835 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2836 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2837 return res;
2838 }
2839 }
2840
2841
2842 SWIGINTERNINLINE PyObject*
2843 SWIG_From_unsigned_SS_long (unsigned long value)
2844 {
2845 return (value > LONG_MAX) ?
2846 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2847 }
2848
2849
2850 void* wxGetXDisplay()
2851 {
2852 #ifdef __WXGTK__
2853 return wxGetDisplay();
2854 #else
2855 return NULL;
2856 #endif
2857 }
2858
2859
2860 wxWindow* FindWindowAtPointer() {
2861 wxPoint unused;
2862 return wxFindWindowAtPointer(unused);
2863 }
2864
2865
2866 void wxWakeUpMainThread() {}
2867
2868
2869 bool wxThread_IsMain() {
2870 #ifdef WXP_WITH_THREAD
2871 return wxThread::IsMain();
2872 #else
2873 return true;
2874 #endif
2875 }
2876
2877 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2878 delete self;
2879 }
2880
2881 #include <wx/snglinst.h>
2882
2883
2884 #ifdef __WXMSW__
2885 #include <wx/msw/private.h>
2886 #include <wx/dynload.h>
2887 #endif
2888
2889
2890
2891 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2892 #if 0
2893 , int method
2894 #endif
2895 )
2896 {
2897 #ifdef __WXMSW__
2898 #if 0
2899 switch (method)
2900 {
2901 case 1:
2902 // This one only partially works. Appears to be an undocumented
2903 // "standard" convention that not all widgets adhear to. For
2904 // example, for some widgets backgrounds or non-client areas may
2905 // not be painted.
2906 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2907 break;
2908
2909 case 2:
2910 #endif
2911 // This one works much better, nearly all widgets and their
2912 // children are captured correctly[**]. Prior to the big
2913 // background erase changes that Vadim did in 2004-2005 this
2914 // method failed badly on XP with Themes activated, most native
2915 // widgets draw only partially, if at all. Without themes it
2916 // worked just like on Win2k. After those changes this method
2917 // works very well.
2918 //
2919 // ** For example the radio buttons in a wxRadioBox are not its
2920 // children by default, but you can capture it via the panel
2921 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2922 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2923 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2924 PRF_ERASEBKGND | PRF_OWNED );
2925 return true;
2926 #if 0
2927 break;
2928
2929 case 3:
2930 // This one is only defined in the latest SDK and is only
2931 // available on XP. MSDN says it is similar to sending WM_PRINT
2932 // so I expect that it will work similar to the above. Since it
2933 // is avaialble only on XP, it can't be compiled like this and
2934 // will have to be loaded dynamically.
2935 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2936
2937 // fall through
2938
2939 case 4:
2940 // Use PrintWindow if available, or fallback to WM_PRINT
2941 // otherwise. Unfortunately using PrintWindow is even worse than
2942 // WM_PRINT. For most native widgets nothing is drawn to the dc
2943 // at all, with or without Themes.
2944 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2945 static bool s_triedToLoad = false;
2946 static PrintWindow_t pfnPrintWindow = NULL;
2947 if ( !s_triedToLoad )
2948 {
2949
2950 s_triedToLoad = true;
2951 wxDynamicLibrary dllUser32(_T("user32.dll"));
2952 if ( dllUser32.IsLoaded() )
2953 {
2954 wxLogNull nolog; // Don't report errors here
2955 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2956 }
2957 }
2958 if (pfnPrintWindow)
2959 {
2960 //printf("Using PrintWindow\n");
2961 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2962 }
2963 else
2964 {
2965 //printf("Using WM_PRINT\n");
2966 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2967 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2968 PRF_ERASEBKGND | PRF_OWNED );
2969 }
2970 }
2971 #endif // 0
2972 #else
2973 return false;
2974 #endif // __WXMSW__
2975 }
2976
2977
2978
2979 #include <wx/tipdlg.h>
2980
2981
2982 SWIGINTERNINLINE PyObject *
2983 SWIG_From_size_t (size_t value)
2984 {
2985 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2986 }
2987
2988
2989 class wxPyTipProvider : public wxTipProvider {
2990 public:
2991 wxPyTipProvider(size_t currentTip)
2992 : wxTipProvider(currentTip) {}
2993
2994 DEC_PYCALLBACK_STRING__pure(GetTip);
2995 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2996 PYPRIVATE;
2997 };
2998
2999 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
3000 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
3001
3002
3003 SWIGINTERNINLINE int
3004 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3005 {
3006 unsigned long v;
3007 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3008 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3009 return res;
3010 }
3011
3012
3013 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3014
3015 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3016
3017 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3018 : wxTimer(owner, id)
3019 {
3020 if (owner == NULL)
3021 SetOwner(this);
3022 }
3023
3024 wxPyTimer::~wxPyTimer()
3025 {
3026 // printf("-=* ~wxPyTimer\n");
3027 }
3028
3029
3030
3031 SWIGINTERN swig_type_info*
3032 SWIG_pchar_descriptor()
3033 {
3034 static int init = 0;
3035 static swig_type_info* info = 0;
3036 if (!init) {
3037 info = SWIG_TypeQuery("_p_char");
3038 init = 1;
3039 }
3040 return info;
3041 }
3042
3043
3044 SWIGINTERNINLINE PyObject *
3045 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3046 {
3047 if (carray) {
3048 if (size > INT_MAX) {
3049 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3050 return pchar_descriptor ?
3051 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3052 } else {
3053 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3054 }
3055 } else {
3056 return SWIG_Py_Void();
3057 }
3058 }
3059
3060
3061 SWIGINTERNINLINE PyObject *
3062 SWIG_FromCharPtr(const char *cptr)
3063 {
3064 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3065 }
3066
3067
3068 SWIGINTERN int
3069 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3070 {
3071 unsigned long v;
3072 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3073 if (SWIG_IsOK(res)) {
3074 if ((v > UINT_MAX)) {
3075 return SWIG_OverflowError;
3076 } else {
3077 if (val) *val = static_cast< unsigned int >(v);
3078 }
3079 }
3080 return res;
3081 }
3082
3083 SWIGINTERN wxString wxLog_TimeStamp(){
3084 wxString msg;
3085 wxLog::TimeStamp(&msg);
3086 return msg;
3087 }
3088 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3089 // Make some wrappers that double any % signs so they are 'escaped'
3090 void wxPyLogFatalError(const wxString& msg)
3091 {
3092 wxString m(msg);
3093 m.Replace(wxT("%"), wxT("%%"));
3094 wxLogFatalError(m);
3095 }
3096
3097 void wxPyLogError(const wxString& msg)
3098 {
3099 wxString m(msg);
3100 m.Replace(wxT("%"), wxT("%%"));
3101 wxLogError(m);
3102 }
3103
3104 void wxPyLogWarning(const wxString& msg)
3105 {
3106 wxString m(msg);
3107 m.Replace(wxT("%"), wxT("%%"));
3108 wxLogWarning(m);
3109 }
3110
3111 void wxPyLogMessage(const wxString& msg)
3112 {
3113 wxString m(msg);
3114 m.Replace(wxT("%"), wxT("%%"));
3115 wxLogMessage(m);
3116 }
3117
3118 void wxPyLogInfo(const wxString& msg)
3119 {
3120 wxString m(msg);
3121 m.Replace(wxT("%"), wxT("%%"));
3122 wxLogInfo(m);
3123 }
3124
3125 void wxPyLogDebug(const wxString& msg)
3126 {
3127 wxString m(msg);
3128 m.Replace(wxT("%"), wxT("%%"));
3129 wxLogDebug(m);
3130 }
3131
3132 void wxPyLogVerbose(const wxString& msg)
3133 {
3134 wxString m(msg);
3135 m.Replace(wxT("%"), wxT("%%"));
3136 wxLogVerbose(m);
3137 }
3138
3139 void wxPyLogStatus(const wxString& msg)
3140 {
3141 wxString m(msg);
3142 m.Replace(wxT("%"), wxT("%%"));
3143 wxLogStatus(m);
3144 }
3145
3146 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3147 {
3148 wxString m(msg);
3149 m.Replace(wxT("%"), wxT("%%"));
3150 wxLogStatus(pFrame, m);
3151 }
3152
3153 void wxPyLogSysError(const wxString& msg)
3154 {
3155 wxString m(msg);
3156 m.Replace(wxT("%"), wxT("%%"));
3157 wxLogSysError(m);
3158 }
3159
3160 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3161 {
3162 wxString m(msg);
3163 m.Replace(wxT("%"), wxT("%%"));
3164 wxLogGeneric(level, m);
3165 }
3166
3167 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3168 {
3169 wxString m(msg);
3170 m.Replace(wxT("%"), wxT("%%"));
3171 wxLogTrace(mask, m);
3172 }
3173
3174 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3175 {
3176 wxString m(msg);
3177 m.Replace(wxT("%"), wxT("%%"));
3178 wxLogTrace(mask, m);
3179 }
3180
3181
3182
3183 // A wxLog class that can be derived from in wxPython
3184 class wxPyLog : public wxLog {
3185 public:
3186 wxPyLog() : wxLog() {}
3187
3188 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3189 bool found;
3190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3191 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3192 PyObject* s = wx2PyString(szString);
3193 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3194 Py_DECREF(s);
3195 }
3196 wxPyEndBlockThreads(blocked);
3197 if (! found)
3198 wxLog::DoLog(level, szString, t);
3199 }
3200
3201 virtual void DoLogString(const wxChar *szString, time_t t) {
3202 bool found;
3203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3204 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3205 PyObject* s = wx2PyString(szString);
3206 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3207 Py_DECREF(s);
3208 }
3209 wxPyEndBlockThreads(blocked);
3210 if (! found)
3211 wxLog::DoLogString(szString, t);
3212 }
3213
3214 DEC_PYCALLBACK_VOID_(Flush);
3215 PYPRIVATE;
3216 };
3217 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3218
3219
3220
3221
3222 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3223
3224
3225 #include <wx/joystick.h>
3226
3227
3228 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3229 // A C++ stub class for wxJoystick for platforms that don't have it.
3230 class wxJoystick : public wxObject {
3231 public:
3232 wxJoystick(int joystick = wxJOYSTICK1) {
3233 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3234 PyErr_SetString(PyExc_NotImplementedError,
3235 "wxJoystick is not available on this platform.");
3236 wxPyEndBlockThreads(blocked);
3237 }
3238 wxPoint GetPosition() { return wxPoint(-1,-1); }
3239 int GetZPosition() { return -1; }
3240 int GetButtonState() { return -1; }
3241 int GetPOVPosition() { return -1; }
3242 int GetPOVCTSPosition() { return -1; }
3243 int GetRudderPosition() { return -1; }
3244 int GetUPosition() { return -1; }
3245 int GetVPosition() { return -1; }
3246 int GetMovementThreshold() { return -1; }
3247 void SetMovementThreshold(int threshold) {}
3248
3249 bool IsOk(void) { return false; }
3250 int GetNumberJoysticks() { return -1; }
3251 int GetManufacturerId() { return -1; }
3252 int GetProductId() { return -1; }
3253 wxString GetProductName() { return wxEmptyString; }
3254 int GetXMin() { return -1; }
3255 int GetYMin() { return -1; }
3256 int GetZMin() { return -1; }
3257 int GetXMax() { return -1; }
3258 int GetYMax() { return -1; }
3259 int GetZMax() { return -1; }
3260 int GetNumberButtons() { return -1; }
3261 int GetNumberAxes() { return -1; }
3262 int GetMaxButtons() { return -1; }
3263 int GetMaxAxes() { return -1; }
3264 int GetPollingMin() { return -1; }
3265 int GetPollingMax() { return -1; }
3266 int GetRudderMin() { return -1; }
3267 int GetRudderMax() { return -1; }
3268 int GetUMin() { return -1; }
3269 int GetUMax() { return -1; }
3270 int GetVMin() { return -1; }
3271 int GetVMax() { return -1; }
3272
3273 bool HasRudder() { return false; }
3274 bool HasZ() { return false; }
3275 bool HasU() { return false; }
3276 bool HasV() { return false; }
3277 bool HasPOV() { return false; }
3278 bool HasPOV4Dir() { return false; }
3279 bool HasPOVCTS() { return false; }
3280
3281 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3282 bool ReleaseCapture() { return false; }
3283 };
3284 #endif
3285
3286
3287 #include <wx/sound.h>
3288
3289
3290 #if !wxUSE_SOUND
3291 // A C++ stub class for wxWave for platforms that don't have it.
3292 class wxSound : public wxObject
3293 {
3294 public:
3295 wxSound() {
3296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3297 PyErr_SetString(PyExc_NotImplementedError,
3298 "wxSound is not available on this platform.");
3299 wxPyEndBlockThreads(blocked);
3300 }
3301 wxSound(const wxString&/*, bool*/) {
3302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3303 PyErr_SetString(PyExc_NotImplementedError,
3304 "wxSound is not available on this platform.");
3305 wxPyEndBlockThreads(blocked);
3306 }
3307 wxSound(int, const wxByte*) {
3308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3309 PyErr_SetString(PyExc_NotImplementedError,
3310 "wxSound is not available on this platform.");
3311 wxPyEndBlockThreads(blocked);
3312 }
3313
3314 ~wxSound() {};
3315
3316 bool Create(const wxString&/*, bool*/) { return false; }
3317 bool Create(int, const wxByte*) { return false; };
3318 bool IsOk() { return false; };
3319 bool Play(unsigned) const { return false; }
3320 static bool Play(const wxString&, unsigned) { return false; }
3321 static void Stop() {}
3322 };
3323
3324 #endif
3325
3326 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3327 if (fileName.Length() == 0)
3328 return new wxSound;
3329 else
3330 return new wxSound(fileName);
3331 }
3332 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3333 unsigned char* buffer; int size;
3334 wxSound *sound = NULL;
3335
3336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3337 if (!PyArg_Parse(data, "t#", &buffer, &size))
3338 goto done;
3339 sound = new wxSound(size, buffer);
3340 done:
3341 wxPyEndBlockThreads(blocked);
3342 return sound;
3343 }
3344 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3345 #ifndef __WXMAC__
3346 unsigned char* buffer;
3347 int size;
3348 bool rv = false;
3349
3350 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3351 if (!PyArg_Parse(data, "t#", &buffer, &size))
3352 goto done;
3353 rv = self->Create(size, buffer);
3354 done:
3355 wxPyEndBlockThreads(blocked);
3356 return rv;
3357 #else
3358 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3359 PyErr_SetString(PyExc_NotImplementedError,
3360 "Create from data is not available on this platform.");
3361 wxPyEndBlockThreads(blocked);
3362 return false;
3363 #endif
3364 }
3365
3366 #include <wx/mimetype.h>
3367
3368 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3369 wxString str;
3370 if (self->GetMimeType(&str))
3371 return wx2PyString(str);
3372 else
3373 RETURN_NONE();
3374 }
3375 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3376 wxArrayString arr;
3377 if (self->GetMimeTypes(arr))
3378 return wxArrayString2PyList_helper(arr);
3379 else
3380 RETURN_NONE();
3381 }
3382 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3383 wxArrayString arr;
3384 if (self->GetExtensions(arr))
3385 return wxArrayString2PyList_helper(arr);
3386 else
3387 RETURN_NONE();
3388 }
3389 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3390 wxIconLocation loc;
3391 if (self->GetIcon(&loc))
3392 return new wxIcon(loc);
3393 else
3394 return NULL;
3395 }
3396 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3397 wxIconLocation loc;
3398 if (self->GetIcon(&loc)) {
3399 wxString iconFile = loc.GetFileName();
3400 int iconIndex = -1;
3401
3402
3403
3404 // Make a tuple and put the values in it
3405 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3406 PyObject* tuple = PyTuple_New(3);
3407 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3408 wxT("wxIcon"), true));
3409 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3410 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3411 wxPyEndBlockThreads(blocked);
3412 return tuple;
3413 }
3414 else
3415 RETURN_NONE();
3416 }
3417 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3418 wxString str;
3419 if (self->GetDescription(&str))
3420 return wx2PyString(str);
3421 else
3422 RETURN_NONE();
3423 }
3424 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3425 wxString str;
3426 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3427 return wx2PyString(str);
3428 else
3429 RETURN_NONE();
3430 }
3431 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3432 wxString str;
3433 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3434 return wx2PyString(str);
3435 else
3436 RETURN_NONE();
3437 }
3438 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3439 wxArrayString verbs;
3440 wxArrayString commands;
3441 if (self->GetAllCommands(&verbs, &commands,
3442 wxFileType::MessageParameters(filename, mimetype))) {
3443 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3444 PyObject* tuple = PyTuple_New(2);
3445 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3446 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3447 wxPyEndBlockThreads(blocked);
3448 return tuple;
3449 }
3450 else
3451 RETURN_NONE();
3452 }
3453 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3454 return wxFileType::ExpandCommand(command,
3455 wxFileType::MessageParameters(filename, mimetype));
3456 }
3457 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3458 wxArrayString arr;
3459 self->EnumAllFileTypes(arr);
3460 return wxArrayString2PyList_helper(arr);
3461 }
3462
3463 #include <wx/artprov.h>
3464
3465 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3466 static const wxString wxPyART_MENU(wxART_MENU);
3467 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3468 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3469 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3470 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3471 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3472 static const wxString wxPyART_LIST(wxART_LIST);
3473 static const wxString wxPyART_OTHER(wxART_OTHER);
3474 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3475 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3476 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3477 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3478 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3479 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3480 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3481 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3482 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3483 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3484 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3485 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3486 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3487 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3488 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3489 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3490 static const wxString wxPyART_PRINT(wxART_PRINT);
3491 static const wxString wxPyART_HELP(wxART_HELP);
3492 static const wxString wxPyART_TIP(wxART_TIP);
3493 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3494 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3495 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3496 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3497 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3498 static const wxString wxPyART_CDROM(wxART_CDROM);
3499 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3500 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3501 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3502 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3503 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3504 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3505 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3506 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3507 static const wxString wxPyART_ERROR(wxART_ERROR);
3508 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3509 static const wxString wxPyART_WARNING(wxART_WARNING);
3510 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3511 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3512 static const wxString wxPyART_COPY(wxART_COPY);
3513 static const wxString wxPyART_CUT(wxART_CUT);
3514 static const wxString wxPyART_PASTE(wxART_PASTE);
3515 static const wxString wxPyART_DELETE(wxART_DELETE);
3516 static const wxString wxPyART_NEW(wxART_NEW);
3517 static const wxString wxPyART_UNDO(wxART_UNDO);
3518 static const wxString wxPyART_REDO(wxART_REDO);
3519 static const wxString wxPyART_QUIT(wxART_QUIT);
3520 static const wxString wxPyART_FIND(wxART_FIND);
3521 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3522 // Python aware wxArtProvider
3523 class wxPyArtProvider : public wxArtProvider {
3524 public:
3525
3526 virtual wxBitmap CreateBitmap(const wxArtID& id,
3527 const wxArtClient& client,
3528 const wxSize& size) {
3529 wxBitmap rval = wxNullBitmap;
3530 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3531 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3532 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3533 PyObject* ro;
3534 wxBitmap* ptr;
3535 PyObject* s1, *s2;
3536 s1 = wx2PyString(id);
3537 s2 = wx2PyString(client);
3538 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3539 Py_DECREF(so);
3540 Py_DECREF(s1);
3541 Py_DECREF(s2);
3542 if (ro) {
3543 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3544 rval = *ptr;
3545 Py_DECREF(ro);
3546 }
3547 }
3548 wxPyEndBlockThreads(blocked);
3549 return rval;
3550 }
3551
3552 virtual wxIconBundle CreateIconBundle(const wxArtID& id,
3553 const wxArtClient& client)
3554 {
3555 wxIconBundle rval = wxNullIconBundle;
3556 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3557 if ((wxPyCBH_findCallback(m_myInst, "CreateIconBundle"))) {
3558 PyObject* ro;
3559 wxIconBundle* ptr;
3560 PyObject* s1, *s2;
3561 s1 = wx2PyString(id);
3562 s2 = wx2PyString(client);
3563 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)", s1, s2));
3564 Py_DECREF(s1);
3565 Py_DECREF(s2);
3566 if (ro) {
3567 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxIconBundle")))
3568 rval = *ptr;
3569 Py_DECREF(ro);
3570 }
3571 }
3572 wxPyEndBlockThreads(blocked);
3573 return rval;
3574 }
3575
3576 PYPRIVATE;
3577 };
3578
3579 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3580
3581
3582
3583 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3584 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3585 PyObject* ret = PyTuple_New(3);
3586 if (ret) {
3587 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3588 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3589 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3590 }
3591 wxPyEndBlockThreads(blocked);
3592 return ret;
3593 }
3594
3595 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3596 bool cont;
3597 long index = 0;
3598 wxString value;
3599
3600 cont = self->GetFirstGroup(value, index);
3601 return __EnumerationHelper(cont, value, index);
3602 }
3603 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3604 bool cont;
3605 wxString value;
3606
3607 cont = self->GetNextGroup(value, index);
3608 return __EnumerationHelper(cont, value, index);
3609 }
3610 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3611 bool cont;
3612 long index = 0;
3613 wxString value;
3614
3615 cont = self->GetFirstEntry(value, index);
3616 return __EnumerationHelper(cont, value, index);
3617 }
3618 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3619 bool cont;
3620 wxString value;
3621
3622 cont = self->GetNextEntry(value, index);
3623 return __EnumerationHelper(cont, value, index);
3624 }
3625 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3626 long rv;
3627 self->Read(key, &rv, defaultVal);
3628 return rv;
3629 }
3630
3631 SWIGINTERN int
3632 SWIG_AsVal_double (PyObject *obj, double* val)
3633 {
3634 if (PyNumber_Check(obj)) {
3635 if (val) *val = PyFloat_AsDouble(obj);
3636 return SWIG_OK;
3637 }
3638 return SWIG_TypeError;
3639 }
3640
3641 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3642 double rv;
3643 self->Read(key, &rv, defaultVal);
3644 return rv;
3645 }
3646
3647 #define SWIG_From_double PyFloat_FromDouble
3648
3649 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3650 bool rv;
3651 self->Read(key, &rv, defaultVal);
3652 return rv;
3653 }
3654
3655 #include <wx/datetime.h>
3656
3657 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3658 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3659
3660 #define LOCAL_TZ wxDateTime::Local
3661
3662 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3663 wxString am;
3664 wxString pm;
3665 wxDateTime::GetAmPmStrings(&am, &pm);
3666 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3667 PyObject* tup = PyTuple_New(2);
3668 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3669 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3670 wxPyEndBlockThreads(blocked);
3671 return tup;
3672 }
3673
3674 SWIGINTERNINLINE PyObject *
3675 SWIG_From_unsigned_SS_int (unsigned int value)
3676 {
3677 return SWIG_From_unsigned_SS_long (value);
3678 }
3679
3680 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3681 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3682 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3683 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3684 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3685 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3686 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3687 return (*self < *other);
3688 }
3689 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3690 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3691 return (*self <= *other);
3692 }
3693 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3694 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3695 return (*self > *other);
3696 }
3697 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3698 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3699 return (*self >= *other);
3700 }
3701 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3702 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3703 return (*self == *other);
3704 }
3705 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3706 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3707 return (*self != *other);
3708 }
3709 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3710 const wxChar* rv;
3711 const wxChar* _date = date;
3712 rv = self->ParseRfc822Date(_date);
3713 if (rv == NULL) return -1;
3714 return rv - _date;
3715 }
3716 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3717 const wxChar* rv;
3718 const wxChar* _date = date;
3719 rv = self->ParseFormat(_date, format, dateDef);
3720 if (rv == NULL) return -1;
3721 return rv - _date;
3722 }
3723 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3724 const wxChar* rv;
3725 const wxChar* _datetime = datetime;
3726 rv = self->ParseDateTime(_datetime);
3727 if (rv == NULL) return -1;
3728 return rv - _datetime;
3729 }
3730 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3731 const wxChar* rv;
3732 const wxChar* _date = date;
3733 rv = self->ParseDate(_date);
3734 if (rv == NULL) return -1;
3735 return rv - _date;
3736 }
3737 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3738 const wxChar* rv;
3739 const wxChar* _time = time;
3740 rv = self->ParseTime(_time);
3741 if (rv == NULL) return -1;
3742 return rv - _time;
3743 }
3744 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3745 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3746 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3747 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3748 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3749 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3750 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3751 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3752 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3753 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3754 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3755 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3756 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3757 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3758 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3759 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3760
3761 #include <wx/dataobj.h>
3762
3763 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3764 size_t count = self->GetFormatCount(dir);
3765 wxDataFormat* formats = new wxDataFormat[count];
3766 self->GetAllFormats(formats, dir);
3767
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770 for (size_t i=0; i<count; i++) {
3771 wxDataFormat* format = new wxDataFormat(formats[i]);
3772 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3773 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3774 }
3775 wxPyEndBlockThreads(blocked);
3776 delete [] formats;
3777 return list;
3778 }
3779 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3780 PyObject* rval = NULL;
3781 size_t size = self->GetDataSize(format);
3782 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3783 if (size) {
3784 char* buf = new char[size];
3785 if (self->GetDataHere(format, buf))
3786 rval = PyString_FromStringAndSize(buf, size);
3787 delete [] buf;
3788 }
3789 if (! rval) {
3790 rval = Py_None;
3791 Py_INCREF(rval);
3792 }
3793 wxPyEndBlockThreads(blocked);
3794 return rval;
3795 }
3796 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3797 bool rval;
3798 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3799 if (PyString_Check(data)) {
3800 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3801 }
3802 else {
3803 // raise a TypeError if not a string
3804 PyErr_SetString(PyExc_TypeError, "String expected.");
3805 rval = false;
3806 }
3807 wxPyEndBlockThreads(blocked);
3808 return rval;
3809 }
3810 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3811 PyObject* rval = NULL;
3812 size_t size = self->GetDataSize();
3813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3814 if (size) {
3815 char* buf = new char[size];
3816 if (self->GetDataHere(buf))
3817 rval = PyString_FromStringAndSize(buf, size);
3818 delete [] buf;
3819 }
3820 if (! rval) {
3821 rval = Py_None;
3822 Py_INCREF(rval);
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return rval;
3826 }
3827 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3828 bool rval;
3829 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3830 if (PyString_Check(data)) {
3831 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3832 }
3833 else {
3834 // raise a TypeError if not a string
3835 PyErr_SetString(PyExc_TypeError, "String expected.");
3836 rval = false;
3837 }
3838 wxPyEndBlockThreads(blocked);
3839 return rval;
3840 }
3841 // Create a new class for wxPython to use
3842 class wxPyDataObjectSimple : public wxDataObjectSimple {
3843 public:
3844 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3845 : wxDataObjectSimple(format) {}
3846
3847 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3848 bool GetDataHere(void *buf) const;
3849 bool SetData(size_t len, const void *buf);
3850 PYPRIVATE;
3851 };
3852
3853 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3854
3855 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3856 // We need to get the data for this object and write it to buf. I think
3857 // the best way to do this for wxPython is to have the Python method
3858 // return either a string or None and then act appropriately with the
3859 // C++ version.
3860
3861 bool rval = false;
3862 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3863 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3864 PyObject* ro;
3865 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3866 if (ro) {
3867 rval = (ro != Py_None && PyString_Check(ro));
3868 if (rval)
3869 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3870 Py_DECREF(ro);
3871 }
3872 }
3873 wxPyEndBlockThreads(blocked);
3874 return rval;
3875 }
3876
3877 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3878 // For this one we simply need to make a string from buf and len
3879 // and send it to the Python method.
3880 bool rval = false;
3881 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3882 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3883 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3884 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3885 Py_DECREF(data);
3886 }
3887 wxPyEndBlockThreads(blocked);
3888 return rval;
3889 }
3890
3891 // Create a new class for wxPython to use
3892 class wxPyTextDataObject : public wxTextDataObject {
3893 public:
3894 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3895 : wxTextDataObject(text) {}
3896
3897 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3898 DEC_PYCALLBACK_STRING__const(GetText);
3899 DEC_PYCALLBACK__STRING(SetText);
3900 PYPRIVATE;
3901 };
3902
3903 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3904 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3905 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3906
3907
3908 // Create a new class for wxPython to use
3909 class wxPyBitmapDataObject : public wxBitmapDataObject {
3910 public:
3911 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3912 : wxBitmapDataObject(bitmap) {}
3913
3914 wxBitmap GetBitmap() const;
3915 void SetBitmap(const wxBitmap& bitmap);
3916 PYPRIVATE;
3917 };
3918
3919 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3920 wxBitmap* rval = &wxNullBitmap;
3921 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3922 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3923 PyObject* ro;
3924 wxBitmap* ptr;
3925 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3926 if (ro) {
3927 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3928 rval = ptr;
3929 Py_DECREF(ro);
3930 }
3931 }
3932 wxPyEndBlockThreads(blocked);
3933 return *rval;
3934 }
3935
3936 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3937 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3938 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3939 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3940 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3941 Py_DECREF(bo);
3942 }
3943 wxPyEndBlockThreads(blocked);
3944 }
3945
3946 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3947 return new wxCustomDataObject(wxDataFormat(formatName));
3948 }
3949 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3950 bool rval;
3951 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3952 if (PyString_Check(data)) {
3953 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3954 }
3955 else {
3956 // raise a TypeError if not a string
3957 PyErr_SetString(PyExc_TypeError, "String expected.");
3958 rval = false;
3959 }
3960 wxPyEndBlockThreads(blocked);
3961 return rval;
3962 }
3963 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3964 PyObject* obj;
3965 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3966 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3967 wxPyEndBlockThreads(blocked);
3968 return obj;
3969 }
3970
3971 class wxMetafileDataObject : public wxDataObjectSimple
3972 {
3973 public:
3974 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3975 };
3976
3977
3978 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3979
3980
3981 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3982 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3983 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3984 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3985 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3986
3987
3988 class wxPyTextDropTarget : public wxTextDropTarget {
3989 public:
3990 wxPyTextDropTarget() {}
3991
3992 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3993
3994 DEC_PYCALLBACK__(OnLeave);
3995 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3996 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3997 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3998 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3999
4000 PYPRIVATE;
4001 };
4002
4003 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
4004 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
4008 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
4009
4010
4011
4012 class wxPyFileDropTarget : public wxFileDropTarget {
4013 public:
4014 wxPyFileDropTarget() {}
4015
4016 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
4017
4018 DEC_PYCALLBACK__(OnLeave);
4019 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
4020 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
4021 DEC_PYCALLBACK_DR_2WXCDR(OnData);
4022 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
4023
4024 PYPRIVATE;
4025 };
4026
4027 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
4028 const wxArrayString& filenames) {
4029 bool rval = false;
4030 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4031 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
4032 PyObject* list = wxArrayString2PyList_helper(filenames);
4033 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
4034 Py_DECREF(list);
4035 }
4036 wxPyEndBlockThreads(blocked);
4037 return rval;
4038 }
4039
4040
4041
4042 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4043 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4044 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4045 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4046 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4047
4048
4049
4050
4051 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4052
4053 #include <wx/display.h>
4054 #include <wx/vidmode.h>
4055
4056 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4057 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4058
4059 #if !wxUSE_DISPLAY
4060 const wxVideoMode wxDefaultVideoMode;
4061 #endif
4062
4063 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4064 #if wxUSE_DISPLAY
4065 PyObject* pyList = NULL;
4066 wxArrayVideoModes arr = self->GetModes(mode);
4067 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4068 pyList = PyList_New(0);
4069 for (size_t i=0; i < arr.GetCount(); i++)
4070 {
4071 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4072 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4073 PyList_Append(pyList, pyObj);
4074 Py_DECREF(pyObj);
4075 }
4076 wxPyEndBlockThreads(blocked);
4077 return pyList;
4078 #else
4079 wxPyRaiseNotImplemented();
4080 return NULL;
4081 #endif
4082 }
4083 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4084 #if wxUSE_DISPLAY
4085 return self->GetCurrentMode();
4086 #else
4087 wxPyRaiseNotImplemented();
4088 return wxDefaultVideoMode;
4089 #endif
4090 }
4091 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4092 #if wxUSE_DISPLAY
4093 return self->ChangeMode(mode);
4094 #else
4095 wxPyRaiseNotImplemented();
4096 return false;
4097 #endif
4098 }
4099 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4100 #if wxUSE_DISPLAY
4101 self->ResetMode();
4102 #else
4103 wxPyRaiseNotImplemented();
4104 #endif
4105 }
4106
4107 #include <wx/stdpaths.h>
4108
4109 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4110 return (wxStandardPaths*) &wxStandardPaths::Get();
4111 }
4112
4113 #ifndef wxHAS_POWER_EVENTS
4114 // Dummy class and other definitions for platforms that don't have them
4115
4116 // See wxPython_int.h for wxPowerEvent
4117
4118 enum {
4119 wxEVT_POWER_SUSPENDING,
4120 wxEVT_POWER_SUSPENDED,
4121 wxEVT_POWER_SUSPEND_CANCEL,
4122 wxEVT_POWER_RESUME,
4123 };
4124
4125 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4126 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4127
4128 #endif
4129
4130
4131 #include <wx/aboutdlg.h>
4132
4133 #ifdef __cplusplus
4134 extern "C" {
4135 #endif
4136 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4137 PyObject *resultobj = 0;
4138 wxSystemColour arg1 ;
4139 wxColour result;
4140 int val1 ;
4141 int ecode1 = 0 ;
4142 PyObject * obj0 = 0 ;
4143 char * kwnames[] = {
4144 (char *) "index", NULL
4145 };
4146
4147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4148 ecode1 = SWIG_AsVal_int(obj0, &val1);
4149 if (!SWIG_IsOK(ecode1)) {
4150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4151 }
4152 arg1 = static_cast< wxSystemColour >(val1);
4153 {
4154 if (!wxPyCheckForApp()) SWIG_fail;
4155 PyThreadState* __tstate = wxPyBeginAllowThreads();
4156 result = wxSystemSettings::GetColour(arg1);
4157 wxPyEndAllowThreads(__tstate);
4158 if (PyErr_Occurred()) SWIG_fail;
4159 }
4160 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4161 return resultobj;
4162 fail:
4163 return NULL;
4164 }
4165
4166
4167 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4168 PyObject *resultobj = 0;
4169 wxSystemFont arg1 ;
4170 wxFont result;
4171 int val1 ;
4172 int ecode1 = 0 ;
4173 PyObject * obj0 = 0 ;
4174 char * kwnames[] = {
4175 (char *) "index", NULL
4176 };
4177
4178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4179 ecode1 = SWIG_AsVal_int(obj0, &val1);
4180 if (!SWIG_IsOK(ecode1)) {
4181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4182 }
4183 arg1 = static_cast< wxSystemFont >(val1);
4184 {
4185 if (!wxPyCheckForApp()) SWIG_fail;
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = wxSystemSettings::GetFont(arg1);
4188 wxPyEndAllowThreads(__tstate);
4189 if (PyErr_Occurred()) SWIG_fail;
4190 }
4191 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4192 return resultobj;
4193 fail:
4194 return NULL;
4195 }
4196
4197
4198 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj = 0;
4200 wxSystemMetric arg1 ;
4201 wxWindow *arg2 = (wxWindow *) NULL ;
4202 int result;
4203 int val1 ;
4204 int ecode1 = 0 ;
4205 void *argp2 = 0 ;
4206 int res2 = 0 ;
4207 PyObject * obj0 = 0 ;
4208 PyObject * obj1 = 0 ;
4209 char * kwnames[] = {
4210 (char *) "index",(char *) "win", NULL
4211 };
4212
4213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4214 ecode1 = SWIG_AsVal_int(obj0, &val1);
4215 if (!SWIG_IsOK(ecode1)) {
4216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4217 }
4218 arg1 = static_cast< wxSystemMetric >(val1);
4219 if (obj1) {
4220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4221 if (!SWIG_IsOK(res2)) {
4222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4223 }
4224 arg2 = reinterpret_cast< wxWindow * >(argp2);
4225 }
4226 {
4227 if (!wxPyCheckForApp()) SWIG_fail;
4228 PyThreadState* __tstate = wxPyBeginAllowThreads();
4229 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4230 wxPyEndAllowThreads(__tstate);
4231 if (PyErr_Occurred()) SWIG_fail;
4232 }
4233 resultobj = SWIG_From_int(static_cast< int >(result));
4234 return resultobj;
4235 fail:
4236 return NULL;
4237 }
4238
4239
4240 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4241 PyObject *resultobj = 0;
4242 wxSystemFeature arg1 ;
4243 bool result;
4244 int val1 ;
4245 int ecode1 = 0 ;
4246 PyObject * obj0 = 0 ;
4247 char * kwnames[] = {
4248 (char *) "index", NULL
4249 };
4250
4251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4252 ecode1 = SWIG_AsVal_int(obj0, &val1);
4253 if (!SWIG_IsOK(ecode1)) {
4254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4255 }
4256 arg1 = static_cast< wxSystemFeature >(val1);
4257 {
4258 if (!wxPyCheckForApp()) SWIG_fail;
4259 PyThreadState* __tstate = wxPyBeginAllowThreads();
4260 result = (bool)wxSystemSettings::HasFeature(arg1);
4261 wxPyEndAllowThreads(__tstate);
4262 if (PyErr_Occurred()) SWIG_fail;
4263 }
4264 {
4265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4266 }
4267 return resultobj;
4268 fail:
4269 return NULL;
4270 }
4271
4272
4273 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4274 PyObject *resultobj = 0;
4275 wxSystemScreenType result;
4276
4277 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4278 {
4279 if (!wxPyCheckForApp()) SWIG_fail;
4280 PyThreadState* __tstate = wxPyBeginAllowThreads();
4281 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4282 wxPyEndAllowThreads(__tstate);
4283 if (PyErr_Occurred()) SWIG_fail;
4284 }
4285 resultobj = SWIG_From_int(static_cast< int >(result));
4286 return resultobj;
4287 fail:
4288 return NULL;
4289 }
4290
4291
4292 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4293 PyObject *resultobj = 0;
4294 wxSystemScreenType arg1 ;
4295 int val1 ;
4296 int ecode1 = 0 ;
4297 PyObject * obj0 = 0 ;
4298 char * kwnames[] = {
4299 (char *) "screen", NULL
4300 };
4301
4302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4303 ecode1 = SWIG_AsVal_int(obj0, &val1);
4304 if (!SWIG_IsOK(ecode1)) {
4305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4306 }
4307 arg1 = static_cast< wxSystemScreenType >(val1);
4308 {
4309 if (!wxPyCheckForApp()) SWIG_fail;
4310 PyThreadState* __tstate = wxPyBeginAllowThreads();
4311 wxSystemSettings::SetScreenType(arg1);
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 resultobj = SWIG_Py_Void();
4316 return resultobj;
4317 fail:
4318 return NULL;
4319 }
4320
4321
4322 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4323 PyObject *obj;
4324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4325 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4326 return SWIG_Py_Void();
4327 }
4328
4329 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4330 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4331 return 1;
4332 }
4333
4334
4335 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4336 PyObject *pyobj = 0;
4337
4338 {
4339 #if wxUSE_UNICODE
4340 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4341 #else
4342 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4343 #endif
4344 }
4345 return pyobj;
4346 }
4347
4348
4349 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4350 PyObject *resultobj = 0;
4351 wxSystemOptions *result = 0 ;
4352
4353 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4354 {
4355 PyThreadState* __tstate = wxPyBeginAllowThreads();
4356 result = (wxSystemOptions *)new wxSystemOptions();
4357 wxPyEndAllowThreads(__tstate);
4358 if (PyErr_Occurred()) SWIG_fail;
4359 }
4360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4361 return resultobj;
4362 fail:
4363 return NULL;
4364 }
4365
4366
4367 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4368 PyObject *resultobj = 0;
4369 wxString *arg1 = 0 ;
4370 wxString *arg2 = 0 ;
4371 bool temp1 = false ;
4372 bool temp2 = false ;
4373 PyObject * obj0 = 0 ;
4374 PyObject * obj1 = 0 ;
4375 char * kwnames[] = {
4376 (char *) "name",(char *) "value", NULL
4377 };
4378
4379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4380 {
4381 arg1 = wxString_in_helper(obj0);
4382 if (arg1 == NULL) SWIG_fail;
4383 temp1 = true;
4384 }
4385 {
4386 arg2 = wxString_in_helper(obj1);
4387 if (arg2 == NULL) SWIG_fail;
4388 temp2 = true;
4389 }
4390 {
4391 PyThreadState* __tstate = wxPyBeginAllowThreads();
4392 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4393 wxPyEndAllowThreads(__tstate);
4394 if (PyErr_Occurred()) SWIG_fail;
4395 }
4396 resultobj = SWIG_Py_Void();
4397 {
4398 if (temp1)
4399 delete arg1;
4400 }
4401 {
4402 if (temp2)
4403 delete arg2;
4404 }
4405 return resultobj;
4406 fail:
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 {
4412 if (temp2)
4413 delete arg2;
4414 }
4415 return NULL;
4416 }
4417
4418
4419 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj = 0;
4421 wxString *arg1 = 0 ;
4422 int arg2 ;
4423 bool temp1 = false ;
4424 int val2 ;
4425 int ecode2 = 0 ;
4426 PyObject * obj0 = 0 ;
4427 PyObject * obj1 = 0 ;
4428 char * kwnames[] = {
4429 (char *) "name",(char *) "value", NULL
4430 };
4431
4432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4433 {
4434 arg1 = wxString_in_helper(obj0);
4435 if (arg1 == NULL) SWIG_fail;
4436 temp1 = true;
4437 }
4438 ecode2 = SWIG_AsVal_int(obj1, &val2);
4439 if (!SWIG_IsOK(ecode2)) {
4440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4441 }
4442 arg2 = static_cast< int >(val2);
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 resultobj = SWIG_Py_Void();
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return resultobj;
4455 fail:
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return NULL;
4461 }
4462
4463
4464 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4465 PyObject *resultobj = 0;
4466 wxString *arg1 = 0 ;
4467 wxString result;
4468 bool temp1 = false ;
4469 PyObject * obj0 = 0 ;
4470 char * kwnames[] = {
4471 (char *) "name", NULL
4472 };
4473
4474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4475 {
4476 arg1 = wxString_in_helper(obj0);
4477 if (arg1 == NULL) SWIG_fail;
4478 temp1 = true;
4479 }
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4483 wxPyEndAllowThreads(__tstate);
4484 if (PyErr_Occurred()) SWIG_fail;
4485 }
4486 {
4487 #if wxUSE_UNICODE
4488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4489 #else
4490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4491 #endif
4492 }
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return resultobj;
4498 fail:
4499 {
4500 if (temp1)
4501 delete arg1;
4502 }
4503 return NULL;
4504 }
4505
4506
4507 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj = 0;
4509 wxString *arg1 = 0 ;
4510 int result;
4511 bool temp1 = false ;
4512 PyObject * obj0 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "name", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4518 {
4519 arg1 = wxString_in_helper(obj0);
4520 if (arg1 == NULL) SWIG_fail;
4521 temp1 = true;
4522 }
4523 {
4524 PyThreadState* __tstate = wxPyBeginAllowThreads();
4525 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4526 wxPyEndAllowThreads(__tstate);
4527 if (PyErr_Occurred()) SWIG_fail;
4528 }
4529 resultobj = SWIG_From_int(static_cast< int >(result));
4530 {
4531 if (temp1)
4532 delete arg1;
4533 }
4534 return resultobj;
4535 fail:
4536 {
4537 if (temp1)
4538 delete arg1;
4539 }
4540 return NULL;
4541 }
4542
4543
4544 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4545 PyObject *resultobj = 0;
4546 wxString *arg1 = 0 ;
4547 bool result;
4548 bool temp1 = false ;
4549 PyObject * obj0 = 0 ;
4550 char * kwnames[] = {
4551 (char *) "name", NULL
4552 };
4553
4554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4555 {
4556 arg1 = wxString_in_helper(obj0);
4557 if (arg1 == NULL) SWIG_fail;
4558 temp1 = true;
4559 }
4560 {
4561 PyThreadState* __tstate = wxPyBeginAllowThreads();
4562 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4563 wxPyEndAllowThreads(__tstate);
4564 if (PyErr_Occurred()) SWIG_fail;
4565 }
4566 {
4567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4568 }
4569 {
4570 if (temp1)
4571 delete arg1;
4572 }
4573 return resultobj;
4574 fail:
4575 {
4576 if (temp1)
4577 delete arg1;
4578 }
4579 return NULL;
4580 }
4581
4582
4583 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4584 PyObject *resultobj = 0;
4585 wxString *arg1 = 0 ;
4586 bool result;
4587 bool temp1 = false ;
4588 PyObject * obj0 = 0 ;
4589 char * kwnames[] = {
4590 (char *) "name", NULL
4591 };
4592
4593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4594 {
4595 arg1 = wxString_in_helper(obj0);
4596 if (arg1 == NULL) SWIG_fail;
4597 temp1 = true;
4598 }
4599 {
4600 PyThreadState* __tstate = wxPyBeginAllowThreads();
4601 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4602 wxPyEndAllowThreads(__tstate);
4603 if (PyErr_Occurred()) SWIG_fail;
4604 }
4605 {
4606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4607 }
4608 {
4609 if (temp1)
4610 delete arg1;
4611 }
4612 return resultobj;
4613 fail:
4614 {
4615 if (temp1)
4616 delete arg1;
4617 }
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4623 PyObject *obj;
4624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4625 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4626 return SWIG_Py_Void();
4627 }
4628
4629 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630 return SWIG_Python_InitShadowInstance(args);
4631 }
4632
4633 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4634 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4635 return 1;
4636 }
4637
4638
4639 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4640 PyObject *pyobj = 0;
4641
4642 {
4643 #if wxUSE_UNICODE
4644 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4645 #else
4646 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4647 #endif
4648 }
4649 return pyobj;
4650 }
4651
4652
4653 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4654 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4655 return 1;
4656 }
4657
4658
4659 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4660 PyObject *pyobj = 0;
4661
4662 {
4663 #if wxUSE_UNICODE
4664 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4665 #else
4666 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4667 #endif
4668 }
4669 return pyobj;
4670 }
4671
4672
4673 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4674 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4675 return 1;
4676 }
4677
4678
4679 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4680 PyObject *pyobj = 0;
4681
4682 {
4683 #if wxUSE_UNICODE
4684 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4685 #else
4686 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4687 #endif
4688 }
4689 return pyobj;
4690 }
4691
4692
4693 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4694 PyObject *resultobj = 0;
4695 long result;
4696
4697 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4698 {
4699 PyThreadState* __tstate = wxPyBeginAllowThreads();
4700 result = (long)wxNewId();
4701 wxPyEndAllowThreads(__tstate);
4702 if (PyErr_Occurred()) SWIG_fail;
4703 }
4704 resultobj = SWIG_From_long(static_cast< long >(result));
4705 return resultobj;
4706 fail:
4707 return NULL;
4708 }
4709
4710
4711 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4712 PyObject *resultobj = 0;
4713 long arg1 ;
4714 long val1 ;
4715 int ecode1 = 0 ;
4716 PyObject * obj0 = 0 ;
4717 char * kwnames[] = {
4718 (char *) "id", NULL
4719 };
4720
4721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4722 ecode1 = SWIG_AsVal_long(obj0, &val1);
4723 if (!SWIG_IsOK(ecode1)) {
4724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4725 }
4726 arg1 = static_cast< long >(val1);
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 wxRegisterId(arg1);
4730 wxPyEndAllowThreads(__tstate);
4731 if (PyErr_Occurred()) SWIG_fail;
4732 }
4733 resultobj = SWIG_Py_Void();
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4741 PyObject *resultobj = 0;
4742 long result;
4743
4744 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4745 {
4746 PyThreadState* __tstate = wxPyBeginAllowThreads();
4747 result = (long)wxGetCurrentId();
4748 wxPyEndAllowThreads(__tstate);
4749 if (PyErr_Occurred()) SWIG_fail;
4750 }
4751 resultobj = SWIG_From_long(static_cast< long >(result));
4752 return resultobj;
4753 fail:
4754 return NULL;
4755 }
4756
4757
4758 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj = 0;
4760 int arg1 ;
4761 bool result;
4762 int val1 ;
4763 int ecode1 = 0 ;
4764 PyObject * obj0 = 0 ;
4765 char * kwnames[] = {
4766 (char *) "id", NULL
4767 };
4768
4769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4770 ecode1 = SWIG_AsVal_int(obj0, &val1);
4771 if (!SWIG_IsOK(ecode1)) {
4772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4773 }
4774 arg1 = static_cast< int >(val1);
4775 {
4776 PyThreadState* __tstate = wxPyBeginAllowThreads();
4777 result = (bool)wxIsStockID(arg1);
4778 wxPyEndAllowThreads(__tstate);
4779 if (PyErr_Occurred()) SWIG_fail;
4780 }
4781 {
4782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4783 }
4784 return resultobj;
4785 fail:
4786 return NULL;
4787 }
4788
4789
4790 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4791 PyObject *resultobj = 0;
4792 int arg1 ;
4793 wxString *arg2 = 0 ;
4794 bool result;
4795 int val1 ;
4796 int ecode1 = 0 ;
4797 bool temp2 = false ;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4800 char * kwnames[] = {
4801 (char *) "id",(char *) "label", NULL
4802 };
4803
4804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4805 ecode1 = SWIG_AsVal_int(obj0, &val1);
4806 if (!SWIG_IsOK(ecode1)) {
4807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4808 }
4809 arg1 = static_cast< int >(val1);
4810 {
4811 arg2 = wxString_in_helper(obj1);
4812 if (arg2 == NULL) SWIG_fail;
4813 temp2 = true;
4814 }
4815 {
4816 PyThreadState* __tstate = wxPyBeginAllowThreads();
4817 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4818 wxPyEndAllowThreads(__tstate);
4819 if (PyErr_Occurred()) SWIG_fail;
4820 }
4821 {
4822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4823 }
4824 {
4825 if (temp2)
4826 delete arg2;
4827 }
4828 return resultobj;
4829 fail:
4830 {
4831 if (temp2)
4832 delete arg2;
4833 }
4834 return NULL;
4835 }
4836
4837
4838 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj = 0;
4840 int arg1 ;
4841 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4842 wxString result;
4843 int val1 ;
4844 int ecode1 = 0 ;
4845 long val2 ;
4846 int ecode2 = 0 ;
4847 PyObject * obj0 = 0 ;
4848 PyObject * obj1 = 0 ;
4849 char * kwnames[] = {
4850 (char *) "id",(char *) "flags", NULL
4851 };
4852
4853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4854 ecode1 = SWIG_AsVal_int(obj0, &val1);
4855 if (!SWIG_IsOK(ecode1)) {
4856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4857 }
4858 arg1 = static_cast< int >(val1);
4859 if (obj1) {
4860 ecode2 = SWIG_AsVal_long(obj1, &val2);
4861 if (!SWIG_IsOK(ecode2)) {
4862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4863 }
4864 arg2 = static_cast< long >(val2);
4865 }
4866 {
4867 PyThreadState* __tstate = wxPyBeginAllowThreads();
4868 result = wxGetStockLabel(arg1,arg2);
4869 wxPyEndAllowThreads(__tstate);
4870 if (PyErr_Occurred()) SWIG_fail;
4871 }
4872 {
4873 #if wxUSE_UNICODE
4874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4875 #else
4876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4877 #endif
4878 }
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj = 0;
4887 int arg1 ;
4888 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4889 wxString result;
4890 int val1 ;
4891 int ecode1 = 0 ;
4892 int val2 ;
4893 int ecode2 = 0 ;
4894 PyObject * obj0 = 0 ;
4895 PyObject * obj1 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "id",(char *) "client", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4901 ecode1 = SWIG_AsVal_int(obj0, &val1);
4902 if (!SWIG_IsOK(ecode1)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4904 }
4905 arg1 = static_cast< int >(val1);
4906 if (obj1) {
4907 ecode2 = SWIG_AsVal_int(obj1, &val2);
4908 if (!SWIG_IsOK(ecode2)) {
4909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4910 }
4911 arg2 = static_cast< wxStockHelpStringClient >(val2);
4912 }
4913 {
4914 PyThreadState* __tstate = wxPyBeginAllowThreads();
4915 result = wxGetStockHelpString(arg1,arg2);
4916 wxPyEndAllowThreads(__tstate);
4917 if (PyErr_Occurred()) SWIG_fail;
4918 }
4919 {
4920 #if wxUSE_UNICODE
4921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4922 #else
4923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4924 #endif
4925 }
4926 return resultobj;
4927 fail:
4928 return NULL;
4929 }
4930
4931
4932 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4933 PyObject *resultobj = 0;
4934
4935 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4936 {
4937 if (!wxPyCheckForApp()) SWIG_fail;
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 wxBell();
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 resultobj = SWIG_Py_Void();
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4951 PyObject *resultobj = 0;
4952
4953 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4954 {
4955 if (!wxPyCheckForApp()) SWIG_fail;
4956 PyThreadState* __tstate = wxPyBeginAllowThreads();
4957 wxEndBusyCursor();
4958 wxPyEndAllowThreads(__tstate);
4959 if (PyErr_Occurred()) SWIG_fail;
4960 }
4961 resultobj = SWIG_Py_Void();
4962 return resultobj;
4963 fail:
4964 return NULL;
4965 }
4966
4967
4968 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4969 PyObject *resultobj = 0;
4970 bool result;
4971
4972 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4973 {
4974 PyThreadState* __tstate = wxPyBeginAllowThreads();
4975 result = (bool)wxIsBusy();
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 {
4980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4981 }
4982 return resultobj;
4983 fail:
4984 return NULL;
4985 }
4986
4987
4988 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4989 PyObject *resultobj = 0;
4990 wxString result;
4991
4992 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4993 {
4994 PyThreadState* __tstate = wxPyBeginAllowThreads();
4995 result = wxNow();
4996 wxPyEndAllowThreads(__tstate);
4997 if (PyErr_Occurred()) SWIG_fail;
4998 }
4999 {
5000 #if wxUSE_UNICODE
5001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5002 #else
5003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5004 #endif
5005 }
5006 return resultobj;
5007 fail:
5008 return NULL;
5009 }
5010
5011
5012 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5013 PyObject *resultobj = 0;
5014 wxString const &arg1_defvalue = wxPyEmptyString ;
5015 wxString *arg1 = (wxString *) &arg1_defvalue ;
5016 bool result;
5017 bool temp1 = false ;
5018 PyObject * obj0 = 0 ;
5019 char * kwnames[] = {
5020 (char *) "command", NULL
5021 };
5022
5023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5024 if (obj0) {
5025 {
5026 arg1 = wxString_in_helper(obj0);
5027 if (arg1 == NULL) SWIG_fail;
5028 temp1 = true;
5029 }
5030 }
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 result = (bool)wxShell((wxString const &)*arg1);
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 {
5038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5039 }
5040 {
5041 if (temp1)
5042 delete arg1;
5043 }
5044 return resultobj;
5045 fail:
5046 {
5047 if (temp1)
5048 delete arg1;
5049 }
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5055 PyObject *resultobj = 0;
5056 int *arg1 = (int *) 0 ;
5057 int *arg2 = (int *) 0 ;
5058 int result;
5059 int temp1 ;
5060 int res1 = SWIG_TMPOBJ ;
5061 int temp2 ;
5062 int res2 = SWIG_TMPOBJ ;
5063
5064 arg1 = &temp1;
5065 arg2 = &temp2;
5066 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)wxGetOsVersion(arg1,arg2);
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_From_int(static_cast< int >(result));
5074 if (SWIG_IsTmpObj(res1)) {
5075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5076 } else {
5077 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5079 }
5080 if (SWIG_IsTmpObj(res2)) {
5081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5082 } else {
5083 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5085 }
5086 return resultobj;
5087 fail:
5088 return NULL;
5089 }
5090
5091
5092 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5093 PyObject *resultobj = 0;
5094 wxString result;
5095
5096 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5097 {
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = wxGetOsDescription();
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 #if wxUSE_UNICODE
5105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5106 #else
5107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5108 #endif
5109 }
5110 return resultobj;
5111 fail:
5112 return NULL;
5113 }
5114
5115
5116 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5117 PyObject *resultobj = 0;
5118 bool result;
5119
5120 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5121 {
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 result = (bool)wxIsPlatformLittleEndian();
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 {
5128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5129 }
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 bool result;
5139
5140 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 result = (bool)wxIsPlatform64Bit();
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_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5157 PyObject *resultobj = 0;
5158 wxMemorySize result;
5159
5160 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = wxGetFreeMemory();
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 #if wxUSE_LONGLONG
5169 resultobj = PyLong_FromLongLong((&result)->GetValue());
5170 #else
5171 resultobj = PyInt_FromLong(result);
5172 #endif
5173 }
5174 return resultobj;
5175 fail:
5176 return NULL;
5177 }
5178
5179
5180 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5181 PyObject *resultobj = 0;
5182 wxShutdownFlags arg1 ;
5183 bool result;
5184 int val1 ;
5185 int ecode1 = 0 ;
5186 PyObject * obj0 = 0 ;
5187 char * kwnames[] = {
5188 (char *) "wFlags", NULL
5189 };
5190
5191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5192 ecode1 = SWIG_AsVal_int(obj0, &val1);
5193 if (!SWIG_IsOK(ecode1)) {
5194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5195 }
5196 arg1 = static_cast< wxShutdownFlags >(val1);
5197 {
5198 if (!wxPyCheckForApp()) SWIG_fail;
5199 PyThreadState* __tstate = wxPyBeginAllowThreads();
5200 result = (bool)wxShutdown(arg1);
5201 wxPyEndAllowThreads(__tstate);
5202 if (PyErr_Occurred()) SWIG_fail;
5203 }
5204 {
5205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5206 }
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj = 0;
5215 int arg1 ;
5216 int val1 ;
5217 int ecode1 = 0 ;
5218 PyObject * obj0 = 0 ;
5219 char * kwnames[] = {
5220 (char *) "secs", NULL
5221 };
5222
5223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5224 ecode1 = SWIG_AsVal_int(obj0, &val1);
5225 if (!SWIG_IsOK(ecode1)) {
5226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5227 }
5228 arg1 = static_cast< int >(val1);
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 wxSleep(arg1);
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 resultobj = SWIG_Py_Void();
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5243 PyObject *resultobj = 0;
5244 unsigned long arg1 ;
5245 unsigned long val1 ;
5246 int ecode1 = 0 ;
5247 PyObject * obj0 = 0 ;
5248 char * kwnames[] = {
5249 (char *) "milliseconds", NULL
5250 };
5251
5252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5253 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5254 if (!SWIG_IsOK(ecode1)) {
5255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5256 }
5257 arg1 = static_cast< unsigned long >(val1);
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 wxMilliSleep(arg1);
5261 wxPyEndAllowThreads(__tstate);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 resultobj = SWIG_Py_Void();
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj = 0;
5273 unsigned long arg1 ;
5274 unsigned long val1 ;
5275 int ecode1 = 0 ;
5276 PyObject * obj0 = 0 ;
5277 char * kwnames[] = {
5278 (char *) "microseconds", NULL
5279 };
5280
5281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5282 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5283 if (!SWIG_IsOK(ecode1)) {
5284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5285 }
5286 arg1 = static_cast< unsigned long >(val1);
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 wxMicroSleep(arg1);
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_Py_Void();
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 bool arg1 ;
5303 bool val1 ;
5304 int ecode1 = 0 ;
5305 PyObject * obj0 = 0 ;
5306 char * kwnames[] = {
5307 (char *) "enable", NULL
5308 };
5309
5310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5311 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5312 if (!SWIG_IsOK(ecode1)) {
5313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5314 }
5315 arg1 = static_cast< bool >(val1);
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 wxEnableTopLevelWindows(arg1);
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 resultobj = SWIG_Py_Void();
5323 return resultobj;
5324 fail:
5325 return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5330 PyObject *resultobj = 0;
5331 wxString *arg1 = 0 ;
5332 wxString result;
5333 bool temp1 = false ;
5334 PyObject * obj0 = 0 ;
5335 char * kwnames[] = {
5336 (char *) "in", NULL
5337 };
5338
5339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5340 {
5341 arg1 = wxString_in_helper(obj0);
5342 if (arg1 == NULL) SWIG_fail;
5343 temp1 = true;
5344 }
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 result = wxStripMenuCodes((wxString const &)*arg1);
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 {
5352 #if wxUSE_UNICODE
5353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5354 #else
5355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5356 #endif
5357 }
5358 {
5359 if (temp1)
5360 delete arg1;
5361 }
5362 return resultobj;
5363 fail:
5364 {
5365 if (temp1)
5366 delete arg1;
5367 }
5368 return NULL;
5369 }
5370
5371
5372 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5373 PyObject *resultobj = 0;
5374 wxString result;
5375
5376 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 result = wxGetEmailAddress();
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 {
5384 #if wxUSE_UNICODE
5385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5386 #else
5387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5388 #endif
5389 }
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5397 PyObject *resultobj = 0;
5398 wxString result;
5399
5400 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5401 {
5402 PyThreadState* __tstate = wxPyBeginAllowThreads();
5403 result = wxGetHostName();
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 {
5408 #if wxUSE_UNICODE
5409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5410 #else
5411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5412 #endif
5413 }
5414 return resultobj;
5415 fail:
5416 return NULL;
5417 }
5418
5419
5420 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5421 PyObject *resultobj = 0;
5422 wxString result;
5423
5424 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5425 {
5426 PyThreadState* __tstate = wxPyBeginAllowThreads();
5427 result = wxGetFullHostName();
5428 wxPyEndAllowThreads(__tstate);
5429 if (PyErr_Occurred()) SWIG_fail;
5430 }
5431 {
5432 #if wxUSE_UNICODE
5433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5434 #else
5435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5436 #endif
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5445 PyObject *resultobj = 0;
5446 wxString result;
5447
5448 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5449 {
5450 PyThreadState* __tstate = wxPyBeginAllowThreads();
5451 result = wxGetUserId();
5452 wxPyEndAllowThreads(__tstate);
5453 if (PyErr_Occurred()) SWIG_fail;
5454 }
5455 {
5456 #if wxUSE_UNICODE
5457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5458 #else
5459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5460 #endif
5461 }
5462 return resultobj;
5463 fail:
5464 return NULL;
5465 }
5466
5467
5468 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5469 PyObject *resultobj = 0;
5470 wxString result;
5471
5472 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 result = wxGetUserName();
5476 wxPyEndAllowThreads(__tstate);
5477 if (PyErr_Occurred()) SWIG_fail;
5478 }
5479 {
5480 #if wxUSE_UNICODE
5481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5482 #else
5483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5484 #endif
5485 }
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5493 PyObject *resultobj = 0;
5494 wxString result;
5495
5496 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = wxGetHomeDir();
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 {
5504 #if wxUSE_UNICODE
5505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5506 #else
5507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5508 #endif
5509 }
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj = 0;
5518 wxString const &arg1_defvalue = wxPyEmptyString ;
5519 wxString *arg1 = (wxString *) &arg1_defvalue ;
5520 wxString result;
5521 bool temp1 = false ;
5522 PyObject * obj0 = 0 ;
5523 char * kwnames[] = {
5524 (char *) "user", NULL
5525 };
5526
5527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5528 if (obj0) {
5529 {
5530 arg1 = wxString_in_helper(obj0);
5531 if (arg1 == NULL) SWIG_fail;
5532 temp1 = true;
5533 }
5534 }
5535 {
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 result = wxGetUserHome((wxString const &)*arg1);
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 #if wxUSE_UNICODE
5543 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5544 #else
5545 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5546 #endif
5547 }
5548 {
5549 if (temp1)
5550 delete arg1;
5551 }
5552 return resultobj;
5553 fail:
5554 {
5555 if (temp1)
5556 delete arg1;
5557 }
5558 return NULL;
5559 }
5560
5561
5562 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5563 PyObject *resultobj = 0;
5564 unsigned long result;
5565
5566 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5567 {
5568 PyThreadState* __tstate = wxPyBeginAllowThreads();
5569 result = (unsigned long)wxGetProcessId();
5570 wxPyEndAllowThreads(__tstate);
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 PyObject *resultobj = 0;
5582
5583 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5584 {
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 wxTrap();
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 resultobj = SWIG_Py_Void();
5591 return resultobj;
5592 fail:
5593 return NULL;
5594 }
5595
5596
5597 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5598 PyObject *resultobj = 0;
5599 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5600 wxString *arg1 = (wxString *) &arg1_defvalue ;
5601 wxString const &arg2_defvalue = wxPyEmptyString ;
5602 wxString *arg2 = (wxString *) &arg2_defvalue ;
5603 wxString const &arg3_defvalue = wxPyEmptyString ;
5604 wxString *arg3 = (wxString *) &arg3_defvalue ;
5605 wxString const &arg4_defvalue = wxPyEmptyString ;
5606 wxString *arg4 = (wxString *) &arg4_defvalue ;
5607 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5608 wxString *arg5 = (wxString *) &arg5_defvalue ;
5609 int arg6 = (int) 0 ;
5610 wxWindow *arg7 = (wxWindow *) NULL ;
5611 int arg8 = (int) -1 ;
5612 int arg9 = (int) -1 ;
5613 wxString result;
5614 bool temp1 = false ;
5615 bool temp2 = false ;
5616 bool temp3 = false ;
5617 bool temp4 = false ;
5618 bool temp5 = false ;
5619 int val6 ;
5620 int ecode6 = 0 ;
5621 void *argp7 = 0 ;
5622 int res7 = 0 ;
5623 int val8 ;
5624 int ecode8 = 0 ;
5625 int val9 ;
5626 int ecode9 = 0 ;
5627 PyObject * obj0 = 0 ;
5628 PyObject * obj1 = 0 ;
5629 PyObject * obj2 = 0 ;
5630 PyObject * obj3 = 0 ;
5631 PyObject * obj4 = 0 ;
5632 PyObject * obj5 = 0 ;
5633 PyObject * obj6 = 0 ;
5634 PyObject * obj7 = 0 ;
5635 PyObject * obj8 = 0 ;
5636 char * kwnames[] = {
5637 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5638 };
5639
5640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5641 if (obj0) {
5642 {
5643 arg1 = wxString_in_helper(obj0);
5644 if (arg1 == NULL) SWIG_fail;
5645 temp1 = true;
5646 }
5647 }
5648 if (obj1) {
5649 {
5650 arg2 = wxString_in_helper(obj1);
5651 if (arg2 == NULL) SWIG_fail;
5652 temp2 = true;
5653 }
5654 }
5655 if (obj2) {
5656 {
5657 arg3 = wxString_in_helper(obj2);
5658 if (arg3 == NULL) SWIG_fail;
5659 temp3 = true;
5660 }
5661 }
5662 if (obj3) {
5663 {
5664 arg4 = wxString_in_helper(obj3);
5665 if (arg4 == NULL) SWIG_fail;
5666 temp4 = true;
5667 }
5668 }
5669 if (obj4) {
5670 {
5671 arg5 = wxString_in_helper(obj4);
5672 if (arg5 == NULL) SWIG_fail;
5673 temp5 = true;
5674 }
5675 }
5676 if (obj5) {
5677 ecode6 = SWIG_AsVal_int(obj5, &val6);
5678 if (!SWIG_IsOK(ecode6)) {
5679 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5680 }
5681 arg6 = static_cast< int >(val6);
5682 }
5683 if (obj6) {
5684 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5685 if (!SWIG_IsOK(res7)) {
5686 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5687 }
5688 arg7 = reinterpret_cast< wxWindow * >(argp7);
5689 }
5690 if (obj7) {
5691 ecode8 = SWIG_AsVal_int(obj7, &val8);
5692 if (!SWIG_IsOK(ecode8)) {
5693 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5694 }
5695 arg8 = static_cast< int >(val8);
5696 }
5697 if (obj8) {
5698 ecode9 = SWIG_AsVal_int(obj8, &val9);
5699 if (!SWIG_IsOK(ecode9)) {
5700 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5701 }
5702 arg9 = static_cast< int >(val9);
5703 }
5704 {
5705 if (!wxPyCheckForApp()) SWIG_fail;
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5708 wxPyEndAllowThreads(__tstate);
5709 if (PyErr_Occurred()) SWIG_fail;
5710 }
5711 {
5712 #if wxUSE_UNICODE
5713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5714 #else
5715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5716 #endif
5717 }
5718 {
5719 if (temp1)
5720 delete arg1;
5721 }
5722 {
5723 if (temp2)
5724 delete arg2;
5725 }
5726 {
5727 if (temp3)
5728 delete arg3;
5729 }
5730 {
5731 if (temp4)
5732 delete arg4;
5733 }
5734 {
5735 if (temp5)
5736 delete arg5;
5737 }
5738 return resultobj;
5739 fail:
5740 {
5741 if (temp1)
5742 delete arg1;
5743 }
5744 {
5745 if (temp2)
5746 delete arg2;
5747 }
5748 {
5749 if (temp3)
5750 delete arg3;
5751 }
5752 {
5753 if (temp4)
5754 delete arg4;
5755 }
5756 {
5757 if (temp5)
5758 delete arg5;
5759 }
5760 return NULL;
5761 }
5762
5763
5764 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5765 PyObject *resultobj = 0;
5766 wxString *arg1 = 0 ;
5767 wxString *arg2 = 0 ;
5768 wxString const &arg3_defvalue = wxPyEmptyString ;
5769 wxString *arg3 = (wxString *) &arg3_defvalue ;
5770 wxWindow *arg4 = (wxWindow *) NULL ;
5771 wxString result;
5772 bool temp1 = false ;
5773 bool temp2 = false ;
5774 bool temp3 = false ;
5775 void *argp4 = 0 ;
5776 int res4 = 0 ;
5777 PyObject * obj0 = 0 ;
5778 PyObject * obj1 = 0 ;
5779 PyObject * obj2 = 0 ;
5780 PyObject * obj3 = 0 ;
5781 char * kwnames[] = {
5782 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5783 };
5784
5785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5786 {
5787 arg1 = wxString_in_helper(obj0);
5788 if (arg1 == NULL) SWIG_fail;
5789 temp1 = true;
5790 }
5791 {
5792 arg2 = wxString_in_helper(obj1);
5793 if (arg2 == NULL) SWIG_fail;
5794 temp2 = true;
5795 }
5796 if (obj2) {
5797 {
5798 arg3 = wxString_in_helper(obj2);
5799 if (arg3 == NULL) SWIG_fail;
5800 temp3 = true;
5801 }
5802 }
5803 if (obj3) {
5804 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5805 if (!SWIG_IsOK(res4)) {
5806 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5807 }
5808 arg4 = reinterpret_cast< wxWindow * >(argp4);
5809 }
5810 {
5811 if (!wxPyCheckForApp()) SWIG_fail;
5812 PyThreadState* __tstate = wxPyBeginAllowThreads();
5813 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5814 wxPyEndAllowThreads(__tstate);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 {
5818 #if wxUSE_UNICODE
5819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5820 #else
5821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5822 #endif
5823 }
5824 {
5825 if (temp1)
5826 delete arg1;
5827 }
5828 {
5829 if (temp2)
5830 delete arg2;
5831 }
5832 {
5833 if (temp3)
5834 delete arg3;
5835 }
5836 return resultobj;
5837 fail:
5838 {
5839 if (temp1)
5840 delete arg1;
5841 }
5842 {
5843 if (temp2)
5844 delete arg2;
5845 }
5846 {
5847 if (temp3)
5848 delete arg3;
5849 }
5850 return NULL;
5851 }
5852
5853
5854 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj = 0;
5856 wxString *arg1 = 0 ;
5857 wxString *arg2 = 0 ;
5858 wxString const &arg3_defvalue = wxPyEmptyString ;
5859 wxString *arg3 = (wxString *) &arg3_defvalue ;
5860 wxWindow *arg4 = (wxWindow *) NULL ;
5861 wxString result;
5862 bool temp1 = false ;
5863 bool temp2 = false ;
5864 bool temp3 = false ;
5865 void *argp4 = 0 ;
5866 int res4 = 0 ;
5867 PyObject * obj0 = 0 ;
5868 PyObject * obj1 = 0 ;
5869 PyObject * obj2 = 0 ;
5870 PyObject * obj3 = 0 ;
5871 char * kwnames[] = {
5872 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5873 };
5874
5875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5876 {
5877 arg1 = wxString_in_helper(obj0);
5878 if (arg1 == NULL) SWIG_fail;
5879 temp1 = true;
5880 }
5881 {
5882 arg2 = wxString_in_helper(obj1);
5883 if (arg2 == NULL) SWIG_fail;
5884 temp2 = true;
5885 }
5886 if (obj2) {
5887 {
5888 arg3 = wxString_in_helper(obj2);
5889 if (arg3 == NULL) SWIG_fail;
5890 temp3 = true;
5891 }
5892 }
5893 if (obj3) {
5894 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5895 if (!SWIG_IsOK(res4)) {
5896 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5897 }
5898 arg4 = reinterpret_cast< wxWindow * >(argp4);
5899 }
5900 {
5901 if (!wxPyCheckForApp()) SWIG_fail;
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5904 wxPyEndAllowThreads(__tstate);
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 {
5908 #if wxUSE_UNICODE
5909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5910 #else
5911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5912 #endif
5913 }
5914 {
5915 if (temp1)
5916 delete arg1;
5917 }
5918 {
5919 if (temp2)
5920 delete arg2;
5921 }
5922 {
5923 if (temp3)
5924 delete arg3;
5925 }
5926 return resultobj;
5927 fail:
5928 {
5929 if (temp1)
5930 delete arg1;
5931 }
5932 {
5933 if (temp2)
5934 delete arg2;
5935 }
5936 {
5937 if (temp3)
5938 delete arg3;
5939 }
5940 return NULL;
5941 }
5942
5943
5944 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5945 PyObject *resultobj = 0;
5946 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5947 wxString *arg1 = (wxString *) &arg1_defvalue ;
5948 wxString const &arg2_defvalue = wxPyEmptyString ;
5949 wxString *arg2 = (wxString *) &arg2_defvalue ;
5950 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5951 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5952 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5953 wxWindow *arg5 = (wxWindow *) NULL ;
5954 wxString result;
5955 bool temp1 = false ;
5956 bool temp2 = false ;
5957 long val3 ;
5958 int ecode3 = 0 ;
5959 wxPoint temp4 ;
5960 void *argp5 = 0 ;
5961 int res5 = 0 ;
5962 PyObject * obj0 = 0 ;
5963 PyObject * obj1 = 0 ;
5964 PyObject * obj2 = 0 ;
5965 PyObject * obj3 = 0 ;
5966 PyObject * obj4 = 0 ;
5967 char * kwnames[] = {
5968 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5969 };
5970
5971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5972 if (obj0) {
5973 {
5974 arg1 = wxString_in_helper(obj0);
5975 if (arg1 == NULL) SWIG_fail;
5976 temp1 = true;
5977 }
5978 }
5979 if (obj1) {
5980 {
5981 arg2 = wxString_in_helper(obj1);
5982 if (arg2 == NULL) SWIG_fail;
5983 temp2 = true;
5984 }
5985 }
5986 if (obj2) {
5987 ecode3 = SWIG_AsVal_long(obj2, &val3);
5988 if (!SWIG_IsOK(ecode3)) {
5989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5990 }
5991 arg3 = static_cast< long >(val3);
5992 }
5993 if (obj3) {
5994 {
5995 arg4 = &temp4;
5996 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5997 }
5998 }
5999 if (obj4) {
6000 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6001 if (!SWIG_IsOK(res5)) {
6002 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6003 }
6004 arg5 = reinterpret_cast< wxWindow * >(argp5);
6005 }
6006 {
6007 if (!wxPyCheckForApp()) SWIG_fail;
6008 PyThreadState* __tstate = wxPyBeginAllowThreads();
6009 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 {
6014 #if wxUSE_UNICODE
6015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6016 #else
6017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6018 #endif
6019 }
6020 {
6021 if (temp1)
6022 delete arg1;
6023 }
6024 {
6025 if (temp2)
6026 delete arg2;
6027 }
6028 return resultobj;
6029 fail:
6030 {
6031 if (temp1)
6032 delete arg1;
6033 }
6034 {
6035 if (temp2)
6036 delete arg2;
6037 }
6038 return NULL;
6039 }
6040
6041
6042 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6043 PyObject *resultobj = 0;
6044 wxString *arg1 = 0 ;
6045 wxString const &arg2_defvalue = wxPyEmptyString ;
6046 wxString *arg2 = (wxString *) &arg2_defvalue ;
6047 wxString const &arg3_defvalue = wxPyEmptyString ;
6048 wxString *arg3 = (wxString *) &arg3_defvalue ;
6049 wxWindow *arg4 = (wxWindow *) NULL ;
6050 int arg5 = (int) -1 ;
6051 int arg6 = (int) -1 ;
6052 bool arg7 = (bool) true ;
6053 wxString result;
6054 bool temp1 = false ;
6055 bool temp2 = false ;
6056 bool temp3 = false ;
6057 void *argp4 = 0 ;
6058 int res4 = 0 ;
6059 int val5 ;
6060 int ecode5 = 0 ;
6061 int val6 ;
6062 int ecode6 = 0 ;
6063 bool val7 ;
6064 int ecode7 = 0 ;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 PyObject * obj2 = 0 ;
6068 PyObject * obj3 = 0 ;
6069 PyObject * obj4 = 0 ;
6070 PyObject * obj5 = 0 ;
6071 PyObject * obj6 = 0 ;
6072 char * kwnames[] = {
6073 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6074 };
6075
6076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6077 {
6078 arg1 = wxString_in_helper(obj0);
6079 if (arg1 == NULL) SWIG_fail;
6080 temp1 = true;
6081 }
6082 if (obj1) {
6083 {
6084 arg2 = wxString_in_helper(obj1);
6085 if (arg2 == NULL) SWIG_fail;
6086 temp2 = true;
6087 }
6088 }
6089 if (obj2) {
6090 {
6091 arg3 = wxString_in_helper(obj2);
6092 if (arg3 == NULL) SWIG_fail;
6093 temp3 = true;
6094 }
6095 }
6096 if (obj3) {
6097 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6098 if (!SWIG_IsOK(res4)) {
6099 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6100 }
6101 arg4 = reinterpret_cast< wxWindow * >(argp4);
6102 }
6103 if (obj4) {
6104 ecode5 = SWIG_AsVal_int(obj4, &val5);
6105 if (!SWIG_IsOK(ecode5)) {
6106 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6107 }
6108 arg5 = static_cast< int >(val5);
6109 }
6110 if (obj5) {
6111 ecode6 = SWIG_AsVal_int(obj5, &val6);
6112 if (!SWIG_IsOK(ecode6)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6114 }
6115 arg6 = static_cast< int >(val6);
6116 }
6117 if (obj6) {
6118 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6119 if (!SWIG_IsOK(ecode7)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6121 }
6122 arg7 = static_cast< bool >(val7);
6123 }
6124 {
6125 if (!wxPyCheckForApp()) SWIG_fail;
6126 PyThreadState* __tstate = wxPyBeginAllowThreads();
6127 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 {
6132 #if wxUSE_UNICODE
6133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6134 #else
6135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6136 #endif
6137 }
6138 {
6139 if (temp1)
6140 delete arg1;
6141 }
6142 {
6143 if (temp2)
6144 delete arg2;
6145 }
6146 {
6147 if (temp3)
6148 delete arg3;
6149 }
6150 return resultobj;
6151 fail:
6152 {
6153 if (temp1)
6154 delete arg1;
6155 }
6156 {
6157 if (temp2)
6158 delete arg2;
6159 }
6160 {
6161 if (temp3)
6162 delete arg3;
6163 }
6164 return NULL;
6165 }
6166
6167
6168 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj = 0;
6170 wxString *arg1 = 0 ;
6171 wxString const &arg2_defvalue = wxPyEmptyString ;
6172 wxString *arg2 = (wxString *) &arg2_defvalue ;
6173 wxString const &arg3_defvalue = wxPyEmptyString ;
6174 wxString *arg3 = (wxString *) &arg3_defvalue ;
6175 wxWindow *arg4 = (wxWindow *) NULL ;
6176 wxString result;
6177 bool temp1 = false ;
6178 bool temp2 = false ;
6179 bool temp3 = false ;
6180 void *argp4 = 0 ;
6181 int res4 = 0 ;
6182 PyObject * obj0 = 0 ;
6183 PyObject * obj1 = 0 ;
6184 PyObject * obj2 = 0 ;
6185 PyObject * obj3 = 0 ;
6186 char * kwnames[] = {
6187 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6188 };
6189
6190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6191 {
6192 arg1 = wxString_in_helper(obj0);
6193 if (arg1 == NULL) SWIG_fail;
6194 temp1 = true;
6195 }
6196 if (obj1) {
6197 {
6198 arg2 = wxString_in_helper(obj1);
6199 if (arg2 == NULL) SWIG_fail;
6200 temp2 = true;
6201 }
6202 }
6203 if (obj2) {
6204 {
6205 arg3 = wxString_in_helper(obj2);
6206 if (arg3 == NULL) SWIG_fail;
6207 temp3 = true;
6208 }
6209 }
6210 if (obj3) {
6211 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6212 if (!SWIG_IsOK(res4)) {
6213 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6214 }
6215 arg4 = reinterpret_cast< wxWindow * >(argp4);
6216 }
6217 {
6218 if (!wxPyCheckForApp()) SWIG_fail;
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6221 wxPyEndAllowThreads(__tstate);
6222 if (PyErr_Occurred()) SWIG_fail;
6223 }
6224 {
6225 #if wxUSE_UNICODE
6226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6227 #else
6228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6229 #endif
6230 }
6231 {
6232 if (temp1)
6233 delete arg1;
6234 }
6235 {
6236 if (temp2)
6237 delete arg2;
6238 }
6239 {
6240 if (temp3)
6241 delete arg3;
6242 }
6243 return resultobj;
6244 fail:
6245 {
6246 if (temp1)
6247 delete arg1;
6248 }
6249 {
6250 if (temp2)
6251 delete arg2;
6252 }
6253 {
6254 if (temp3)
6255 delete arg3;
6256 }
6257 return NULL;
6258 }
6259
6260
6261 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj = 0;
6263 wxString *arg1 = 0 ;
6264 wxString *arg2 = 0 ;
6265 int arg3 ;
6266 wxString *arg4 = (wxString *) 0 ;
6267 wxWindow *arg5 = (wxWindow *) NULL ;
6268 int arg6 = (int) -1 ;
6269 int arg7 = (int) -1 ;
6270 bool arg8 = (bool) true ;
6271 int arg9 = (int) 150 ;
6272 int arg10 = (int) 200 ;
6273 wxString result;
6274 bool temp1 = false ;
6275 bool temp2 = false ;
6276 void *argp5 = 0 ;
6277 int res5 = 0 ;
6278 int val6 ;
6279 int ecode6 = 0 ;
6280 int val7 ;
6281 int ecode7 = 0 ;
6282 bool val8 ;
6283 int ecode8 = 0 ;
6284 int val9 ;
6285 int ecode9 = 0 ;
6286 int val10 ;
6287 int ecode10 = 0 ;
6288 PyObject * obj0 = 0 ;
6289 PyObject * obj1 = 0 ;
6290 PyObject * obj2 = 0 ;
6291 PyObject * obj3 = 0 ;
6292 PyObject * obj4 = 0 ;
6293 PyObject * obj5 = 0 ;
6294 PyObject * obj6 = 0 ;
6295 PyObject * obj7 = 0 ;
6296 PyObject * obj8 = 0 ;
6297 char * kwnames[] = {
6298 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6299 };
6300
6301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6302 {
6303 arg1 = wxString_in_helper(obj0);
6304 if (arg1 == NULL) SWIG_fail;
6305 temp1 = true;
6306 }
6307 {
6308 arg2 = wxString_in_helper(obj1);
6309 if (arg2 == NULL) SWIG_fail;
6310 temp2 = true;
6311 }
6312 {
6313 arg3 = PyList_Size(obj2);
6314 arg4 = wxString_LIST_helper(obj2);
6315 if (arg4 == NULL) SWIG_fail;
6316 }
6317 if (obj3) {
6318 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6319 if (!SWIG_IsOK(res5)) {
6320 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6321 }
6322 arg5 = reinterpret_cast< wxWindow * >(argp5);
6323 }
6324 if (obj4) {
6325 ecode6 = SWIG_AsVal_int(obj4, &val6);
6326 if (!SWIG_IsOK(ecode6)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6328 }
6329 arg6 = static_cast< int >(val6);
6330 }
6331 if (obj5) {
6332 ecode7 = SWIG_AsVal_int(obj5, &val7);
6333 if (!SWIG_IsOK(ecode7)) {
6334 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6335 }
6336 arg7 = static_cast< int >(val7);
6337 }
6338 if (obj6) {
6339 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6340 if (!SWIG_IsOK(ecode8)) {
6341 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6342 }
6343 arg8 = static_cast< bool >(val8);
6344 }
6345 if (obj7) {
6346 ecode9 = SWIG_AsVal_int(obj7, &val9);
6347 if (!SWIG_IsOK(ecode9)) {
6348 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6349 }
6350 arg9 = static_cast< int >(val9);
6351 }
6352 if (obj8) {
6353 ecode10 = SWIG_AsVal_int(obj8, &val10);
6354 if (!SWIG_IsOK(ecode10)) {
6355 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6356 }
6357 arg10 = static_cast< int >(val10);
6358 }
6359 {
6360 if (!wxPyCheckForApp()) SWIG_fail;
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 {
6367 #if wxUSE_UNICODE
6368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6369 #else
6370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6371 #endif
6372 }
6373 {
6374 if (temp1)
6375 delete arg1;
6376 }
6377 {
6378 if (temp2)
6379 delete arg2;
6380 }
6381 {
6382 if (arg4) delete [] arg4;
6383 }
6384 return resultobj;
6385 fail:
6386 {
6387 if (temp1)
6388 delete arg1;
6389 }
6390 {
6391 if (temp2)
6392 delete arg2;
6393 }
6394 {
6395 if (arg4) delete [] arg4;
6396 }
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = 0;
6403 wxString *arg1 = 0 ;
6404 wxString *arg2 = 0 ;
6405 int arg3 ;
6406 wxString *arg4 = (wxString *) 0 ;
6407 wxWindow *arg5 = (wxWindow *) NULL ;
6408 int arg6 = (int) -1 ;
6409 int arg7 = (int) -1 ;
6410 bool arg8 = (bool) true ;
6411 int arg9 = (int) 150 ;
6412 int arg10 = (int) 200 ;
6413 int result;
6414 bool temp1 = false ;
6415 bool temp2 = false ;
6416 void *argp5 = 0 ;
6417 int res5 = 0 ;
6418 int val6 ;
6419 int ecode6 = 0 ;
6420 int val7 ;
6421 int ecode7 = 0 ;
6422 bool val8 ;
6423 int ecode8 = 0 ;
6424 int val9 ;
6425 int ecode9 = 0 ;
6426 int val10 ;
6427 int ecode10 = 0 ;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 PyObject * obj2 = 0 ;
6431 PyObject * obj3 = 0 ;
6432 PyObject * obj4 = 0 ;
6433 PyObject * obj5 = 0 ;
6434 PyObject * obj6 = 0 ;
6435 PyObject * obj7 = 0 ;
6436 PyObject * obj8 = 0 ;
6437 char * kwnames[] = {
6438 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6439 };
6440
6441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6442 {
6443 arg1 = wxString_in_helper(obj0);
6444 if (arg1 == NULL) SWIG_fail;
6445 temp1 = true;
6446 }
6447 {
6448 arg2 = wxString_in_helper(obj1);
6449 if (arg2 == NULL) SWIG_fail;
6450 temp2 = true;
6451 }
6452 {
6453 arg3 = PyList_Size(obj2);
6454 arg4 = wxString_LIST_helper(obj2);
6455 if (arg4 == NULL) SWIG_fail;
6456 }
6457 if (obj3) {
6458 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6459 if (!SWIG_IsOK(res5)) {
6460 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6461 }
6462 arg5 = reinterpret_cast< wxWindow * >(argp5);
6463 }
6464 if (obj4) {
6465 ecode6 = SWIG_AsVal_int(obj4, &val6);
6466 if (!SWIG_IsOK(ecode6)) {
6467 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6468 }
6469 arg6 = static_cast< int >(val6);
6470 }
6471 if (obj5) {
6472 ecode7 = SWIG_AsVal_int(obj5, &val7);
6473 if (!SWIG_IsOK(ecode7)) {
6474 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6475 }
6476 arg7 = static_cast< int >(val7);
6477 }
6478 if (obj6) {
6479 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6480 if (!SWIG_IsOK(ecode8)) {
6481 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6482 }
6483 arg8 = static_cast< bool >(val8);
6484 }
6485 if (obj7) {
6486 ecode9 = SWIG_AsVal_int(obj7, &val9);
6487 if (!SWIG_IsOK(ecode9)) {
6488 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6489 }
6490 arg9 = static_cast< int >(val9);
6491 }
6492 if (obj8) {
6493 ecode10 = SWIG_AsVal_int(obj8, &val10);
6494 if (!SWIG_IsOK(ecode10)) {
6495 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6496 }
6497 arg10 = static_cast< int >(val10);
6498 }
6499 {
6500 if (!wxPyCheckForApp()) SWIG_fail;
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6503 wxPyEndAllowThreads(__tstate);
6504 if (PyErr_Occurred()) SWIG_fail;
6505 }
6506 resultobj = SWIG_From_int(static_cast< int >(result));
6507 {
6508 if (temp1)
6509 delete arg1;
6510 }
6511 {
6512 if (temp2)
6513 delete arg2;
6514 }
6515 {
6516 if (arg4) delete [] arg4;
6517 }
6518 return resultobj;
6519 fail:
6520 {
6521 if (temp1)
6522 delete arg1;
6523 }
6524 {
6525 if (temp2)
6526 delete arg2;
6527 }
6528 {
6529 if (arg4) delete [] arg4;
6530 }
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj = 0;
6537 wxString *arg1 = 0 ;
6538 wxString const &arg2_defvalue = wxPyEmptyString ;
6539 wxString *arg2 = (wxString *) &arg2_defvalue ;
6540 int arg3 = (int) wxOK|wxCENTRE ;
6541 wxWindow *arg4 = (wxWindow *) NULL ;
6542 int arg5 = (int) -1 ;
6543 int arg6 = (int) -1 ;
6544 int result;
6545 bool temp1 = false ;
6546 bool temp2 = false ;
6547 int val3 ;
6548 int ecode3 = 0 ;
6549 void *argp4 = 0 ;
6550 int res4 = 0 ;
6551 int val5 ;
6552 int ecode5 = 0 ;
6553 int val6 ;
6554 int ecode6 = 0 ;
6555 PyObject * obj0 = 0 ;
6556 PyObject * obj1 = 0 ;
6557 PyObject * obj2 = 0 ;
6558 PyObject * obj3 = 0 ;
6559 PyObject * obj4 = 0 ;
6560 PyObject * obj5 = 0 ;
6561 char * kwnames[] = {
6562 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6563 };
6564
6565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6566 {
6567 arg1 = wxString_in_helper(obj0);
6568 if (arg1 == NULL) SWIG_fail;
6569 temp1 = true;
6570 }
6571 if (obj1) {
6572 {
6573 arg2 = wxString_in_helper(obj1);
6574 if (arg2 == NULL) SWIG_fail;
6575 temp2 = true;
6576 }
6577 }
6578 if (obj2) {
6579 ecode3 = SWIG_AsVal_int(obj2, &val3);
6580 if (!SWIG_IsOK(ecode3)) {
6581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6582 }
6583 arg3 = static_cast< int >(val3);
6584 }
6585 if (obj3) {
6586 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6587 if (!SWIG_IsOK(res4)) {
6588 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6589 }
6590 arg4 = reinterpret_cast< wxWindow * >(argp4);
6591 }
6592 if (obj4) {
6593 ecode5 = SWIG_AsVal_int(obj4, &val5);
6594 if (!SWIG_IsOK(ecode5)) {
6595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6596 }
6597 arg5 = static_cast< int >(val5);
6598 }
6599 if (obj5) {
6600 ecode6 = SWIG_AsVal_int(obj5, &val6);
6601 if (!SWIG_IsOK(ecode6)) {
6602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6603 }
6604 arg6 = static_cast< int >(val6);
6605 }
6606 {
6607 if (!wxPyCheckForApp()) SWIG_fail;
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 resultobj = SWIG_From_int(static_cast< int >(result));
6614 {
6615 if (temp1)
6616 delete arg1;
6617 }
6618 {
6619 if (temp2)
6620 delete arg2;
6621 }
6622 return resultobj;
6623 fail:
6624 {
6625 if (temp1)
6626 delete arg1;
6627 }
6628 {
6629 if (temp2)
6630 delete arg2;
6631 }
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6637 PyObject *resultobj = 0;
6638 wxString *arg1 = 0 ;
6639 wxString *arg2 = 0 ;
6640 wxString *arg3 = 0 ;
6641 long arg4 ;
6642 long arg5 = (long) 0 ;
6643 long arg6 = (long) 100 ;
6644 wxWindow *arg7 = (wxWindow *) NULL ;
6645 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6646 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6647 long result;
6648 bool temp1 = false ;
6649 bool temp2 = false ;
6650 bool temp3 = false ;
6651 long val4 ;
6652 int ecode4 = 0 ;
6653 long val5 ;
6654 int ecode5 = 0 ;
6655 long val6 ;
6656 int ecode6 = 0 ;
6657 void *argp7 = 0 ;
6658 int res7 = 0 ;
6659 wxPoint temp8 ;
6660 PyObject * obj0 = 0 ;
6661 PyObject * obj1 = 0 ;
6662 PyObject * obj2 = 0 ;
6663 PyObject * obj3 = 0 ;
6664 PyObject * obj4 = 0 ;
6665 PyObject * obj5 = 0 ;
6666 PyObject * obj6 = 0 ;
6667 PyObject * obj7 = 0 ;
6668 char * kwnames[] = {
6669 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6670 };
6671
6672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6673 {
6674 arg1 = wxString_in_helper(obj0);
6675 if (arg1 == NULL) SWIG_fail;
6676 temp1 = true;
6677 }
6678 {
6679 arg2 = wxString_in_helper(obj1);
6680 if (arg2 == NULL) SWIG_fail;
6681 temp2 = true;
6682 }
6683 {
6684 arg3 = wxString_in_helper(obj2);
6685 if (arg3 == NULL) SWIG_fail;
6686 temp3 = true;
6687 }
6688 ecode4 = SWIG_AsVal_long(obj3, &val4);
6689 if (!SWIG_IsOK(ecode4)) {
6690 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6691 }
6692 arg4 = static_cast< long >(val4);
6693 if (obj4) {
6694 ecode5 = SWIG_AsVal_long(obj4, &val5);
6695 if (!SWIG_IsOK(ecode5)) {
6696 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6697 }
6698 arg5 = static_cast< long >(val5);
6699 }
6700 if (obj5) {
6701 ecode6 = SWIG_AsVal_long(obj5, &val6);
6702 if (!SWIG_IsOK(ecode6)) {
6703 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6704 }
6705 arg6 = static_cast< long >(val6);
6706 }
6707 if (obj6) {
6708 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6709 if (!SWIG_IsOK(res7)) {
6710 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6711 }
6712 arg7 = reinterpret_cast< wxWindow * >(argp7);
6713 }
6714 if (obj7) {
6715 {
6716 arg8 = &temp8;
6717 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6718 }
6719 }
6720 {
6721 if (!wxPyCheckForApp()) SWIG_fail;
6722 PyThreadState* __tstate = wxPyBeginAllowThreads();
6723 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 resultobj = SWIG_From_long(static_cast< long >(result));
6728 {
6729 if (temp1)
6730 delete arg1;
6731 }
6732 {
6733 if (temp2)
6734 delete arg2;
6735 }
6736 {
6737 if (temp3)
6738 delete arg3;
6739 }
6740 return resultobj;
6741 fail:
6742 {
6743 if (temp1)
6744 delete arg1;
6745 }
6746 {
6747 if (temp2)
6748 delete arg2;
6749 }
6750 {
6751 if (temp3)
6752 delete arg3;
6753 }
6754 return NULL;
6755 }
6756
6757
6758 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6759 PyObject *resultobj = 0;
6760 bool result;
6761
6762 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6763 {
6764 if (!wxPyCheckForApp()) SWIG_fail;
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 result = (bool)wxColourDisplay();
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 {
6771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6772 }
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 int result;
6782
6783 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6784 {
6785 if (!wxPyCheckForApp()) SWIG_fail;
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 result = (int)wxDisplayDepth();
6788 wxPyEndAllowThreads(__tstate);
6789 if (PyErr_Occurred()) SWIG_fail;
6790 }
6791 resultobj = SWIG_From_int(static_cast< int >(result));
6792 return resultobj;
6793 fail:
6794 return NULL;
6795 }
6796
6797
6798 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6799 PyObject *resultobj = 0;
6800 int result;
6801
6802 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6803 {
6804 if (!wxPyCheckForApp()) SWIG_fail;
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (int)wxGetDisplayDepth();
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 resultobj = SWIG_From_int(static_cast< int >(result));
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6818 PyObject *resultobj = 0;
6819 int *arg1 = (int *) 0 ;
6820 int *arg2 = (int *) 0 ;
6821 int temp1 ;
6822 int res1 = SWIG_TMPOBJ ;
6823 int temp2 ;
6824 int res2 = SWIG_TMPOBJ ;
6825
6826 arg1 = &temp1;
6827 arg2 = &temp2;
6828 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6829 {
6830 if (!wxPyCheckForApp()) SWIG_fail;
6831 PyThreadState* __tstate = wxPyBeginAllowThreads();
6832 wxDisplaySize(arg1,arg2);
6833 wxPyEndAllowThreads(__tstate);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 resultobj = SWIG_Py_Void();
6837 if (SWIG_IsTmpObj(res1)) {
6838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6839 } else {
6840 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6842 }
6843 if (SWIG_IsTmpObj(res2)) {
6844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6845 } else {
6846 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6856 PyObject *resultobj = 0;
6857 wxSize result;
6858
6859 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6860 {
6861 if (!wxPyCheckForApp()) SWIG_fail;
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = wxGetDisplaySize();
6864 wxPyEndAllowThreads(__tstate);
6865 if (PyErr_Occurred()) SWIG_fail;
6866 }
6867 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6868 return resultobj;
6869 fail:
6870 return NULL;
6871 }
6872
6873
6874 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6875 PyObject *resultobj = 0;
6876 int *arg1 = (int *) 0 ;
6877 int *arg2 = (int *) 0 ;
6878 int temp1 ;
6879 int res1 = SWIG_TMPOBJ ;
6880 int temp2 ;
6881 int res2 = SWIG_TMPOBJ ;
6882
6883 arg1 = &temp1;
6884 arg2 = &temp2;
6885 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6886 {
6887 if (!wxPyCheckForApp()) SWIG_fail;
6888 PyThreadState* __tstate = wxPyBeginAllowThreads();
6889 wxDisplaySizeMM(arg1,arg2);
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 resultobj = SWIG_Py_Void();
6894 if (SWIG_IsTmpObj(res1)) {
6895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6896 } else {
6897 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6899 }
6900 if (SWIG_IsTmpObj(res2)) {
6901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6902 } else {
6903 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6905 }
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxSize result;
6915
6916 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6917 {
6918 if (!wxPyCheckForApp()) SWIG_fail;
6919 PyThreadState* __tstate = wxPyBeginAllowThreads();
6920 result = wxGetDisplaySizeMM();
6921 wxPyEndAllowThreads(__tstate);
6922 if (PyErr_Occurred()) SWIG_fail;
6923 }
6924 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6932 PyObject *resultobj = 0;
6933 int *arg1 = (int *) 0 ;
6934 int *arg2 = (int *) 0 ;
6935 int *arg3 = (int *) 0 ;
6936 int *arg4 = (int *) 0 ;
6937 int temp1 ;
6938 int res1 = SWIG_TMPOBJ ;
6939 int temp2 ;
6940 int res2 = SWIG_TMPOBJ ;
6941 int temp3 ;
6942 int res3 = SWIG_TMPOBJ ;
6943 int temp4 ;
6944 int res4 = SWIG_TMPOBJ ;
6945
6946 arg1 = &temp1;
6947 arg2 = &temp2;
6948 arg3 = &temp3;
6949 arg4 = &temp4;
6950 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6951 {
6952 if (!wxPyCheckForApp()) SWIG_fail;
6953 PyThreadState* __tstate = wxPyBeginAllowThreads();
6954 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_Py_Void();
6959 if (SWIG_IsTmpObj(res1)) {
6960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6961 } else {
6962 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6964 }
6965 if (SWIG_IsTmpObj(res2)) {
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6967 } else {
6968 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6970 }
6971 if (SWIG_IsTmpObj(res3)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6976 }
6977 if (SWIG_IsTmpObj(res4)) {
6978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6979 } else {
6980 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6982 }
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6990 PyObject *resultobj = 0;
6991 wxRect result;
6992
6993 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6994 {
6995 if (!wxPyCheckForApp()) SWIG_fail;
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 result = wxGetClientDisplayRect();
6998 wxPyEndAllowThreads(__tstate);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7009 PyObject *resultobj = 0;
7010 wxCursor *arg1 = 0 ;
7011 void *argp1 = 0 ;
7012 int res1 = 0 ;
7013 PyObject * obj0 = 0 ;
7014 char * kwnames[] = {
7015 (char *) "cursor", NULL
7016 };
7017
7018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7019 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7020 if (!SWIG_IsOK(res1)) {
7021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7022 }
7023 if (!argp1) {
7024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7025 }
7026 arg1 = reinterpret_cast< wxCursor * >(argp1);
7027 {
7028 if (!wxPyCheckForApp()) SWIG_fail;
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 wxSetCursor(*arg1);
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_Py_Void();
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7042 PyObject *resultobj = 0;
7043 void *result = 0 ;
7044
7045 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7046 {
7047 if (!wxPyCheckForApp()) SWIG_fail;
7048 PyThreadState* __tstate = wxPyBeginAllowThreads();
7049 result = (void *)wxGetXDisplay();
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj = 0;
7062 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7063 void *argp1 = 0 ;
7064 int res1 = 0 ;
7065 PyObject * obj0 = 0 ;
7066 char * kwnames[] = {
7067 (char *) "cursor", NULL
7068 };
7069
7070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7071 if (obj0) {
7072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7073 if (!SWIG_IsOK(res1)) {
7074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7075 }
7076 arg1 = reinterpret_cast< wxCursor * >(argp1);
7077 }
7078 {
7079 if (!wxPyCheckForApp()) SWIG_fail;
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 wxBeginBusyCursor(arg1);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7093 PyObject *resultobj = 0;
7094 wxPoint result;
7095
7096 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7097 {
7098 if (!wxPyCheckForApp()) SWIG_fail;
7099 PyThreadState* __tstate = wxPyBeginAllowThreads();
7100 result = wxGetMousePosition();
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7112 PyObject *resultobj = 0;
7113 wxWindow *result = 0 ;
7114
7115 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7116 {
7117 if (!wxPyCheckForApp()) SWIG_fail;
7118 PyThreadState* __tstate = wxPyBeginAllowThreads();
7119 result = (wxWindow *)FindWindowAtPointer();
7120 wxPyEndAllowThreads(__tstate);
7121 if (PyErr_Occurred()) SWIG_fail;
7122 }
7123 {
7124 resultobj = wxPyMake_wxObject(result, 0);
7125 }
7126 return resultobj;
7127 fail:
7128 return NULL;
7129 }
7130
7131
7132 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7133 PyObject *resultobj = 0;
7134 wxWindow *result = 0 ;
7135
7136 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7137 {
7138 if (!wxPyCheckForApp()) SWIG_fail;
7139 PyThreadState* __tstate = wxPyBeginAllowThreads();
7140 result = (wxWindow *)wxGetActiveWindow();
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 {
7145 resultobj = wxPyMake_wxObject(result, 0);
7146 }
7147 return resultobj;
7148 fail:
7149 return NULL;
7150 }
7151
7152
7153 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7154 PyObject *resultobj = 0;
7155 wxPoint *arg1 = 0 ;
7156 wxWindow *result = 0 ;
7157 wxPoint temp1 ;
7158 PyObject * obj0 = 0 ;
7159 char * kwnames[] = {
7160 (char *) "pt", NULL
7161 };
7162
7163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7164 {
7165 arg1 = &temp1;
7166 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7167 }
7168 {
7169 if (!wxPyCheckForApp()) SWIG_fail;
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 {
7176 resultobj = wxPyMake_wxObject(result, 0);
7177 }
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = 0;
7186 wxPoint *arg1 = 0 ;
7187 wxWindow *result = 0 ;
7188 wxPoint temp1 ;
7189 PyObject * obj0 = 0 ;
7190 char * kwnames[] = {
7191 (char *) "pt", NULL
7192 };
7193
7194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7195 {
7196 arg1 = &temp1;
7197 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7198 }
7199 {
7200 if (!wxPyCheckForApp()) SWIG_fail;
7201 PyThreadState* __tstate = wxPyBeginAllowThreads();
7202 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7203 wxPyEndAllowThreads(__tstate);
7204 if (PyErr_Occurred()) SWIG_fail;
7205 }
7206 {
7207 resultobj = wxPyMake_wxObject(result, 0);
7208 }
7209 return resultobj;
7210 fail:
7211 return NULL;
7212 }
7213
7214
7215 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7216 PyObject *resultobj = 0;
7217 wxWindow *arg1 = (wxWindow *) 0 ;
7218 wxWindow *result = 0 ;
7219 void *argp1 = 0 ;
7220 int res1 = 0 ;
7221 PyObject * obj0 = 0 ;
7222 char * kwnames[] = {
7223 (char *) "win", NULL
7224 };
7225
7226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7228 if (!SWIG_IsOK(res1)) {
7229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7230 }
7231 arg1 = reinterpret_cast< wxWindow * >(argp1);
7232 {
7233 if (!wxPyCheckForApp()) SWIG_fail;
7234 PyThreadState* __tstate = wxPyBeginAllowThreads();
7235 result = (wxWindow *)wxGetTopLevelParent(arg1);
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 {
7240 resultobj = wxPyMake_wxObject(result, 0);
7241 }
7242 return resultobj;
7243 fail:
7244 return NULL;
7245 }
7246
7247
7248 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7249 PyObject *resultobj = 0;
7250 wxString *arg1 = 0 ;
7251 bool result;
7252 bool temp1 = false ;
7253 PyObject * obj0 = 0 ;
7254 char * kwnames[] = {
7255 (char *) "url", NULL
7256 };
7257
7258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7259 {
7260 arg1 = wxString_in_helper(obj0);
7261 if (arg1 == NULL) SWIG_fail;
7262 temp1 = true;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 {
7271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7272 }
7273 {
7274 if (temp1)
7275 delete arg1;
7276 }
7277 return resultobj;
7278 fail:
7279 {
7280 if (temp1)
7281 delete arg1;
7282 }
7283 return NULL;
7284 }
7285
7286
7287 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7288 PyObject *resultobj = 0;
7289 wxKeyCode arg1 ;
7290 bool result;
7291 int val1 ;
7292 int ecode1 = 0 ;
7293 PyObject * obj0 = 0 ;
7294 char * kwnames[] = {
7295 (char *) "key", NULL
7296 };
7297
7298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7299 ecode1 = SWIG_AsVal_int(obj0, &val1);
7300 if (!SWIG_IsOK(ecode1)) {
7301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7302 }
7303 arg1 = static_cast< wxKeyCode >(val1);
7304 {
7305 if (!wxPyCheckForApp()) SWIG_fail;
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (bool)wxGetKeyState(arg1);
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7321 PyObject *resultobj = 0;
7322 wxMouseState *result = 0 ;
7323
7324 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (wxMouseState *)new wxMouseState();
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7332 return resultobj;
7333 fail:
7334 return NULL;
7335 }
7336
7337
7338 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7339 PyObject *resultobj = 0;
7340 wxMouseState *arg1 = (wxMouseState *) 0 ;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 PyObject *swig_obj[1] ;
7344
7345 if (!args) SWIG_fail;
7346 swig_obj[0] = args;
7347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7350 }
7351 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7352 {
7353 PyThreadState* __tstate = wxPyBeginAllowThreads();
7354 delete arg1;
7355
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_Py_Void();
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7367 PyObject *resultobj = 0;
7368 wxMouseState *arg1 = (wxMouseState *) 0 ;
7369 int result;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 PyObject *swig_obj[1] ;
7373
7374 if (!args) SWIG_fail;
7375 swig_obj[0] = args;
7376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7377 if (!SWIG_IsOK(res1)) {
7378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7379 }
7380 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 result = (int)(arg1)->GetX();
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_From_int(static_cast< int >(result));
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7395 PyObject *resultobj = 0;
7396 wxMouseState *arg1 = (wxMouseState *) 0 ;
7397 int result;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 PyObject *swig_obj[1] ;
7401
7402 if (!args) SWIG_fail;
7403 swig_obj[0] = args;
7404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7407 }
7408 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (int)(arg1)->GetY();
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 resultobj = SWIG_From_int(static_cast< int >(result));
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7423 PyObject *resultobj = 0;
7424 wxMouseState *arg1 = (wxMouseState *) 0 ;
7425 bool result;
7426 void *argp1 = 0 ;
7427 int res1 = 0 ;
7428 PyObject *swig_obj[1] ;
7429
7430 if (!args) SWIG_fail;
7431 swig_obj[0] = args;
7432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7433 if (!SWIG_IsOK(res1)) {
7434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7435 }
7436 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (bool)(arg1)->LeftDown();
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 {
7444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7453 PyObject *resultobj = 0;
7454 wxMouseState *arg1 = (wxMouseState *) 0 ;
7455 bool result;
7456 void *argp1 = 0 ;
7457 int res1 = 0 ;
7458 PyObject *swig_obj[1] ;
7459
7460 if (!args) SWIG_fail;
7461 swig_obj[0] = args;
7462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7463 if (!SWIG_IsOK(res1)) {
7464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7465 }
7466 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7467 {
7468 PyThreadState* __tstate = wxPyBeginAllowThreads();
7469 result = (bool)(arg1)->MiddleDown();
7470 wxPyEndAllowThreads(__tstate);
7471 if (PyErr_Occurred()) SWIG_fail;
7472 }
7473 {
7474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7475 }
7476 return resultobj;
7477 fail:
7478 return NULL;
7479 }
7480
7481
7482 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7483 PyObject *resultobj = 0;
7484 wxMouseState *arg1 = (wxMouseState *) 0 ;
7485 bool result;
7486 void *argp1 = 0 ;
7487 int res1 = 0 ;
7488 PyObject *swig_obj[1] ;
7489
7490 if (!args) SWIG_fail;
7491 swig_obj[0] = args;
7492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7493 if (!SWIG_IsOK(res1)) {
7494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7495 }
7496 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7497 {
7498 PyThreadState* __tstate = wxPyBeginAllowThreads();
7499 result = (bool)(arg1)->RightDown();
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 {
7504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7505 }
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7513 PyObject *resultobj = 0;
7514 wxMouseState *arg1 = (wxMouseState *) 0 ;
7515 bool result;
7516 void *argp1 = 0 ;
7517 int res1 = 0 ;
7518 PyObject *swig_obj[1] ;
7519
7520 if (!args) SWIG_fail;
7521 swig_obj[0] = args;
7522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7523 if (!SWIG_IsOK(res1)) {
7524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7525 }
7526 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 result = (bool)(arg1)->ControlDown();
7530 wxPyEndAllowThreads(__tstate);
7531 if (PyErr_Occurred()) SWIG_fail;
7532 }
7533 {
7534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7535 }
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7543 PyObject *resultobj = 0;
7544 wxMouseState *arg1 = (wxMouseState *) 0 ;
7545 bool result;
7546 void *argp1 = 0 ;
7547 int res1 = 0 ;
7548 PyObject *swig_obj[1] ;
7549
7550 if (!args) SWIG_fail;
7551 swig_obj[0] = args;
7552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7553 if (!SWIG_IsOK(res1)) {
7554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7555 }
7556 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 result = (bool)(arg1)->ShiftDown();
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 {
7564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7565 }
7566 return resultobj;
7567 fail:
7568 return NULL;
7569 }
7570
7571
7572 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7573 PyObject *resultobj = 0;
7574 wxMouseState *arg1 = (wxMouseState *) 0 ;
7575 bool result;
7576 void *argp1 = 0 ;
7577 int res1 = 0 ;
7578 PyObject *swig_obj[1] ;
7579
7580 if (!args) SWIG_fail;
7581 swig_obj[0] = args;
7582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7583 if (!SWIG_IsOK(res1)) {
7584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7585 }
7586 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7587 {
7588 PyThreadState* __tstate = wxPyBeginAllowThreads();
7589 result = (bool)(arg1)->AltDown();
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 {
7594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7595 }
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7603 PyObject *resultobj = 0;
7604 wxMouseState *arg1 = (wxMouseState *) 0 ;
7605 bool result;
7606 void *argp1 = 0 ;
7607 int res1 = 0 ;
7608 PyObject *swig_obj[1] ;
7609
7610 if (!args) SWIG_fail;
7611 swig_obj[0] = args;
7612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7613 if (!SWIG_IsOK(res1)) {
7614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7615 }
7616 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = (bool)(arg1)->MetaDown();
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7625 }
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633 PyObject *resultobj = 0;
7634 wxMouseState *arg1 = (wxMouseState *) 0 ;
7635 bool result;
7636 void *argp1 = 0 ;
7637 int res1 = 0 ;
7638 PyObject *swig_obj[1] ;
7639
7640 if (!args) SWIG_fail;
7641 swig_obj[0] = args;
7642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7643 if (!SWIG_IsOK(res1)) {
7644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7645 }
7646 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 result = (bool)(arg1)->CmdDown();
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 {
7654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7655 }
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj = 0;
7664 wxMouseState *arg1 = (wxMouseState *) 0 ;
7665 int arg2 ;
7666 void *argp1 = 0 ;
7667 int res1 = 0 ;
7668 int val2 ;
7669 int ecode2 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "x", NULL
7674 };
7675
7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7680 }
7681 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7682 ecode2 = SWIG_AsVal_int(obj1, &val2);
7683 if (!SWIG_IsOK(ecode2)) {
7684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7685 }
7686 arg2 = static_cast< int >(val2);
7687 {
7688 PyThreadState* __tstate = wxPyBeginAllowThreads();
7689 (arg1)->SetX(arg2);
7690 wxPyEndAllowThreads(__tstate);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 resultobj = SWIG_Py_Void();
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7701 PyObject *resultobj = 0;
7702 wxMouseState *arg1 = (wxMouseState *) 0 ;
7703 int arg2 ;
7704 void *argp1 = 0 ;
7705 int res1 = 0 ;
7706 int val2 ;
7707 int ecode2 = 0 ;
7708 PyObject * obj0 = 0 ;
7709 PyObject * obj1 = 0 ;
7710 char * kwnames[] = {
7711 (char *) "self",(char *) "y", NULL
7712 };
7713
7714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7716 if (!SWIG_IsOK(res1)) {
7717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7718 }
7719 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7720 ecode2 = SWIG_AsVal_int(obj1, &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7723 }
7724 arg2 = static_cast< int >(val2);
7725 {
7726 PyThreadState* __tstate = wxPyBeginAllowThreads();
7727 (arg1)->SetY(arg2);
7728 wxPyEndAllowThreads(__tstate);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7739 PyObject *resultobj = 0;
7740 wxMouseState *arg1 = (wxMouseState *) 0 ;
7741 bool arg2 ;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 bool val2 ;
7745 int ecode2 = 0 ;
7746 PyObject * obj0 = 0 ;
7747 PyObject * obj1 = 0 ;
7748 char * kwnames[] = {
7749 (char *) "self",(char *) "down", NULL
7750 };
7751
7752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7754 if (!SWIG_IsOK(res1)) {
7755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7756 }
7757 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7761 }
7762 arg2 = static_cast< bool >(val2);
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 (arg1)->SetLeftDown(arg2);
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj = 0;
7778 wxMouseState *arg1 = (wxMouseState *) 0 ;
7779 bool arg2 ;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 bool val2 ;
7783 int ecode2 = 0 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 char * kwnames[] = {
7787 (char *) "self",(char *) "down", NULL
7788 };
7789
7790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7794 }
7795 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7796 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7797 if (!SWIG_IsOK(ecode2)) {
7798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7799 }
7800 arg2 = static_cast< bool >(val2);
7801 {
7802 PyThreadState* __tstate = wxPyBeginAllowThreads();
7803 (arg1)->SetMiddleDown(arg2);
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 resultobj = SWIG_Py_Void();
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxMouseState *arg1 = (wxMouseState *) 0 ;
7817 bool arg2 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 bool val2 ;
7821 int ecode2 = 0 ;
7822 PyObject * obj0 = 0 ;
7823 PyObject * obj1 = 0 ;
7824 char * kwnames[] = {
7825 (char *) "self",(char *) "down", NULL
7826 };
7827
7828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7830 if (!SWIG_IsOK(res1)) {
7831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7832 }
7833 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7835 if (!SWIG_IsOK(ecode2)) {
7836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7837 }
7838 arg2 = static_cast< bool >(val2);
7839 {
7840 PyThreadState* __tstate = wxPyBeginAllowThreads();
7841 (arg1)->SetRightDown(arg2);
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 resultobj = SWIG_Py_Void();
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj = 0;
7854 wxMouseState *arg1 = (wxMouseState *) 0 ;
7855 bool arg2 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 bool val2 ;
7859 int ecode2 = 0 ;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 char * kwnames[] = {
7863 (char *) "self",(char *) "down", NULL
7864 };
7865
7866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7868 if (!SWIG_IsOK(res1)) {
7869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7870 }
7871 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7873 if (!SWIG_IsOK(ecode2)) {
7874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7875 }
7876 arg2 = static_cast< bool >(val2);
7877 {
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 (arg1)->SetControlDown(arg2);
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 resultobj = SWIG_Py_Void();
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj = 0;
7892 wxMouseState *arg1 = (wxMouseState *) 0 ;
7893 bool arg2 ;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 bool val2 ;
7897 int ecode2 = 0 ;
7898 PyObject * obj0 = 0 ;
7899 PyObject * obj1 = 0 ;
7900 char * kwnames[] = {
7901 (char *) "self",(char *) "down", NULL
7902 };
7903
7904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7906 if (!SWIG_IsOK(res1)) {
7907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7908 }
7909 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7911 if (!SWIG_IsOK(ecode2)) {
7912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7913 }
7914 arg2 = static_cast< bool >(val2);
7915 {
7916 PyThreadState* __tstate = wxPyBeginAllowThreads();
7917 (arg1)->SetShiftDown(arg2);
7918 wxPyEndAllowThreads(__tstate);
7919 if (PyErr_Occurred()) SWIG_fail;
7920 }
7921 resultobj = SWIG_Py_Void();
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7929 PyObject *resultobj = 0;
7930 wxMouseState *arg1 = (wxMouseState *) 0 ;
7931 bool arg2 ;
7932 void *argp1 = 0 ;
7933 int res1 = 0 ;
7934 bool val2 ;
7935 int ecode2 = 0 ;
7936 PyObject * obj0 = 0 ;
7937 PyObject * obj1 = 0 ;
7938 char * kwnames[] = {
7939 (char *) "self",(char *) "down", NULL
7940 };
7941
7942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7944 if (!SWIG_IsOK(res1)) {
7945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7946 }
7947 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7949 if (!SWIG_IsOK(ecode2)) {
7950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7951 }
7952 arg2 = static_cast< bool >(val2);
7953 {
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 (arg1)->SetAltDown(arg2);
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 resultobj = SWIG_Py_Void();
7960 return resultobj;
7961 fail:
7962 return NULL;
7963 }
7964
7965
7966 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7967 PyObject *resultobj = 0;
7968 wxMouseState *arg1 = (wxMouseState *) 0 ;
7969 bool arg2 ;
7970 void *argp1 = 0 ;
7971 int res1 = 0 ;
7972 bool val2 ;
7973 int ecode2 = 0 ;
7974 PyObject * obj0 = 0 ;
7975 PyObject * obj1 = 0 ;
7976 char * kwnames[] = {
7977 (char *) "self",(char *) "down", NULL
7978 };
7979
7980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7982 if (!SWIG_IsOK(res1)) {
7983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7984 }
7985 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7989 }
7990 arg2 = static_cast< bool >(val2);
7991 {
7992 PyThreadState* __tstate = wxPyBeginAllowThreads();
7993 (arg1)->SetMetaDown(arg2);
7994 wxPyEndAllowThreads(__tstate);
7995 if (PyErr_Occurred()) SWIG_fail;
7996 }
7997 resultobj = SWIG_Py_Void();
7998 return resultobj;
7999 fail:
8000 return NULL;
8001 }
8002
8003
8004 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8005 PyObject *obj;
8006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8007 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8008 return SWIG_Py_Void();
8009 }
8010
8011 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8012 return SWIG_Python_InitShadowInstance(args);
8013 }
8014
8015 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 PyObject *resultobj = 0;
8017 wxMouseState result;
8018
8019 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8020 {
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = wxGetMouseState();
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8034 PyObject *resultobj = 0;
8035
8036 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8037 {
8038 if (!wxPyCheckForApp()) SWIG_fail;
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 wxWakeUpMainThread();
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 resultobj = SWIG_Py_Void();
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8052 PyObject *resultobj = 0;
8053
8054 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8055 {
8056 if (!wxPyCheckForApp()) SWIG_fail;
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 wxMutexGuiEnter();
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 resultobj = SWIG_Py_Void();
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071
8072 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8073 {
8074 if (!wxPyCheckForApp()) SWIG_fail;
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 wxMutexGuiLeave();
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 resultobj = SWIG_Py_Void();
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8088 PyObject *resultobj = 0;
8089 wxMutexGuiLocker *result = 0 ;
8090
8091 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8092 {
8093 if (!wxPyCheckForApp()) SWIG_fail;
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8100 return resultobj;
8101 fail:
8102 return NULL;
8103 }
8104
8105
8106 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8107 PyObject *resultobj = 0;
8108 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8109 void *argp1 = 0 ;
8110 int res1 = 0 ;
8111 PyObject *swig_obj[1] ;
8112
8113 if (!args) SWIG_fail;
8114 swig_obj[0] = args;
8115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8116 if (!SWIG_IsOK(res1)) {
8117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8118 }
8119 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8120 {
8121 PyThreadState* __tstate = wxPyBeginAllowThreads();
8122 delete arg1;
8123
8124 wxPyEndAllowThreads(__tstate);
8125 if (PyErr_Occurred()) SWIG_fail;
8126 }
8127 resultobj = SWIG_Py_Void();
8128 return resultobj;
8129 fail:
8130 return NULL;
8131 }
8132
8133
8134 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8135 PyObject *obj;
8136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8137 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8138 return SWIG_Py_Void();
8139 }
8140
8141 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8142 return SWIG_Python_InitShadowInstance(args);
8143 }
8144
8145 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 bool result;
8148
8149 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8150 {
8151 PyThreadState* __tstate = wxPyBeginAllowThreads();
8152 result = (bool)wxThread_IsMain();
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 {
8157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8158 }
8159 return resultobj;
8160 fail:
8161 return NULL;
8162 }
8163
8164
8165 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8166 PyObject *resultobj = 0;
8167 wxString *arg1 = 0 ;
8168 wxToolTip *result = 0 ;
8169 bool temp1 = false ;
8170 PyObject * obj0 = 0 ;
8171 char * kwnames[] = {
8172 (char *) "tip", NULL
8173 };
8174
8175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8176 {
8177 arg1 = wxString_in_helper(obj0);
8178 if (arg1 == NULL) SWIG_fail;
8179 temp1 = true;
8180 }
8181 {
8182 if (!wxPyCheckForApp()) SWIG_fail;
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8189 {
8190 if (temp1)
8191 delete arg1;
8192 }
8193 return resultobj;
8194 fail:
8195 {
8196 if (temp1)
8197 delete arg1;
8198 }
8199 return NULL;
8200 }
8201
8202
8203 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8204 PyObject *resultobj = 0;
8205 wxToolTip *arg1 = (wxToolTip *) 0 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 PyObject *swig_obj[1] ;
8209
8210 if (!args) SWIG_fail;
8211 swig_obj[0] = args;
8212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8213 if (!SWIG_IsOK(res1)) {
8214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8215 }
8216 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8217 {
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 delete arg1;
8220
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 resultobj = SWIG_Py_Void();
8225 return resultobj;
8226 fail:
8227 return NULL;
8228 }
8229
8230
8231 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8232 PyObject *resultobj = 0;
8233 wxToolTip *arg1 = (wxToolTip *) 0 ;
8234 wxString *arg2 = 0 ;
8235 void *argp1 = 0 ;
8236 int res1 = 0 ;
8237 bool temp2 = false ;
8238 PyObject * obj0 = 0 ;
8239 PyObject * obj1 = 0 ;
8240 char * kwnames[] = {
8241 (char *) "self",(char *) "tip", NULL
8242 };
8243
8244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8246 if (!SWIG_IsOK(res1)) {
8247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8248 }
8249 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8250 {
8251 arg2 = wxString_in_helper(obj1);
8252 if (arg2 == NULL) SWIG_fail;
8253 temp2 = true;
8254 }
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 (arg1)->SetTip((wxString const &)*arg2);
8258 wxPyEndAllowThreads(__tstate);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 resultobj = SWIG_Py_Void();
8262 {
8263 if (temp2)
8264 delete arg2;
8265 }
8266 return resultobj;
8267 fail:
8268 {
8269 if (temp2)
8270 delete arg2;
8271 }
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8277 PyObject *resultobj = 0;
8278 wxToolTip *arg1 = (wxToolTip *) 0 ;
8279 wxString result;
8280 void *argp1 = 0 ;
8281 int res1 = 0 ;
8282 PyObject *swig_obj[1] ;
8283
8284 if (!args) SWIG_fail;
8285 swig_obj[0] = args;
8286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8287 if (!SWIG_IsOK(res1)) {
8288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8289 }
8290 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 result = (arg1)->GetTip();
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 {
8298 #if wxUSE_UNICODE
8299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8300 #else
8301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8302 #endif
8303 }
8304 return resultobj;
8305 fail:
8306 return NULL;
8307 }
8308
8309
8310 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8311 PyObject *resultobj = 0;
8312 wxToolTip *arg1 = (wxToolTip *) 0 ;
8313 wxWindow *result = 0 ;
8314 void *argp1 = 0 ;
8315 int res1 = 0 ;
8316 PyObject *swig_obj[1] ;
8317
8318 if (!args) SWIG_fail;
8319 swig_obj[0] = args;
8320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8323 }
8324 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 result = (wxWindow *)(arg1)->GetWindow();
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 {
8332 resultobj = wxPyMake_wxObject(result, 0);
8333 }
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 bool arg1 ;
8343 bool val1 ;
8344 int ecode1 = 0 ;
8345 PyObject * obj0 = 0 ;
8346 char * kwnames[] = {
8347 (char *) "flag", NULL
8348 };
8349
8350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8351 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8352 if (!SWIG_IsOK(ecode1)) {
8353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8354 }
8355 arg1 = static_cast< bool >(val1);
8356 {
8357 PyThreadState* __tstate = wxPyBeginAllowThreads();
8358 wxToolTip::Enable(arg1);
8359 wxPyEndAllowThreads(__tstate);
8360 if (PyErr_Occurred()) SWIG_fail;
8361 }
8362 resultobj = SWIG_Py_Void();
8363 return resultobj;
8364 fail:
8365 return NULL;
8366 }
8367
8368
8369 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8370 PyObject *resultobj = 0;
8371 long arg1 ;
8372 long val1 ;
8373 int ecode1 = 0 ;
8374 PyObject * obj0 = 0 ;
8375 char * kwnames[] = {
8376 (char *) "milliseconds", NULL
8377 };
8378
8379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8380 ecode1 = SWIG_AsVal_long(obj0, &val1);
8381 if (!SWIG_IsOK(ecode1)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8383 }
8384 arg1 = static_cast< long >(val1);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 wxToolTip::SetDelay(arg1);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8399 PyObject *obj;
8400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8401 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8402 return SWIG_Py_Void();
8403 }
8404
8405 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8406 return SWIG_Python_InitShadowInstance(args);
8407 }
8408
8409 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj = 0;
8411 wxWindow *arg1 = (wxWindow *) 0 ;
8412 wxSize *arg2 = 0 ;
8413 wxCaret *result = 0 ;
8414 void *argp1 = 0 ;
8415 int res1 = 0 ;
8416 wxSize temp2 ;
8417 PyObject * obj0 = 0 ;
8418 PyObject * obj1 = 0 ;
8419 char * kwnames[] = {
8420 (char *) "window",(char *) "size", NULL
8421 };
8422
8423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8425 if (!SWIG_IsOK(res1)) {
8426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8427 }
8428 arg1 = reinterpret_cast< wxWindow * >(argp1);
8429 {
8430 arg2 = &temp2;
8431 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8432 }
8433 {
8434 if (!wxPyCheckForApp()) SWIG_fail;
8435 PyThreadState* __tstate = wxPyBeginAllowThreads();
8436 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8437 wxPyEndAllowThreads(__tstate);
8438 if (PyErr_Occurred()) SWIG_fail;
8439 }
8440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8448 PyObject *resultobj = 0;
8449 wxCaret *arg1 = (wxCaret *) 0 ;
8450 void *argp1 = 0 ;
8451 int res1 = 0 ;
8452 PyObject *swig_obj[1] ;
8453
8454 if (!args) SWIG_fail;
8455 swig_obj[0] = args;
8456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8457 if (!SWIG_IsOK(res1)) {
8458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8459 }
8460 arg1 = reinterpret_cast< wxCaret * >(argp1);
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 delete arg1;
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 resultobj = SWIG_Py_Void();
8469 return resultobj;
8470 fail:
8471 return NULL;
8472 }
8473
8474
8475 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8476 PyObject *resultobj = 0;
8477 wxCaret *arg1 = (wxCaret *) 0 ;
8478 void *argp1 = 0 ;
8479 int res1 = 0 ;
8480 PyObject *swig_obj[1] ;
8481
8482 if (!args) SWIG_fail;
8483 swig_obj[0] = args;
8484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8485 if (!SWIG_IsOK(res1)) {
8486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8487 }
8488 arg1 = reinterpret_cast< wxCaret * >(argp1);
8489 {
8490 PyThreadState* __tstate = wxPyBeginAllowThreads();
8491 wxCaret_Destroy(arg1);
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 resultobj = SWIG_Py_Void();
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxCaret *arg1 = (wxCaret *) 0 ;
8505 bool result;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8515 }
8516 arg1 = reinterpret_cast< wxCaret * >(argp1);
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (bool)(arg1)->IsOk();
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 {
8524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8525 }
8526 return resultobj;
8527 fail:
8528 return NULL;
8529 }
8530
8531
8532 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8533 PyObject *resultobj = 0;
8534 wxCaret *arg1 = (wxCaret *) 0 ;
8535 bool result;
8536 void *argp1 = 0 ;
8537 int res1 = 0 ;
8538 PyObject *swig_obj[1] ;
8539
8540 if (!args) SWIG_fail;
8541 swig_obj[0] = args;
8542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8543 if (!SWIG_IsOK(res1)) {
8544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8545 }
8546 arg1 = reinterpret_cast< wxCaret * >(argp1);
8547 {
8548 PyThreadState* __tstate = wxPyBeginAllowThreads();
8549 result = (bool)(arg1)->IsVisible();
8550 wxPyEndAllowThreads(__tstate);
8551 if (PyErr_Occurred()) SWIG_fail;
8552 }
8553 {
8554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8555 }
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8563 PyObject *resultobj = 0;
8564 wxCaret *arg1 = (wxCaret *) 0 ;
8565 wxPoint result;
8566 void *argp1 = 0 ;
8567 int res1 = 0 ;
8568 PyObject *swig_obj[1] ;
8569
8570 if (!args) SWIG_fail;
8571 swig_obj[0] = args;
8572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8573 if (!SWIG_IsOK(res1)) {
8574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8575 }
8576 arg1 = reinterpret_cast< wxCaret * >(argp1);
8577 {
8578 PyThreadState* __tstate = wxPyBeginAllowThreads();
8579 result = (arg1)->GetPosition();
8580 wxPyEndAllowThreads(__tstate);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8591 PyObject *resultobj = 0;
8592 wxCaret *arg1 = (wxCaret *) 0 ;
8593 int *arg2 = (int *) 0 ;
8594 int *arg3 = (int *) 0 ;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 int temp2 ;
8598 int res2 = SWIG_TMPOBJ ;
8599 int temp3 ;
8600 int res3 = SWIG_TMPOBJ ;
8601 PyObject *swig_obj[1] ;
8602
8603 arg2 = &temp2;
8604 arg3 = &temp3;
8605 if (!args) SWIG_fail;
8606 swig_obj[0] = args;
8607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8608 if (!SWIG_IsOK(res1)) {
8609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8610 }
8611 arg1 = reinterpret_cast< wxCaret * >(argp1);
8612 {
8613 PyThreadState* __tstate = wxPyBeginAllowThreads();
8614 (arg1)->GetPosition(arg2,arg3);
8615 wxPyEndAllowThreads(__tstate);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 resultobj = SWIG_Py_Void();
8619 if (SWIG_IsTmpObj(res2)) {
8620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8621 } else {
8622 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8624 }
8625 if (SWIG_IsTmpObj(res3)) {
8626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8627 } else {
8628 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8630 }
8631 return resultobj;
8632 fail:
8633 return NULL;
8634 }
8635
8636
8637 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8638 PyObject *resultobj = 0;
8639 wxCaret *arg1 = (wxCaret *) 0 ;
8640 wxSize result;
8641 void *argp1 = 0 ;
8642 int res1 = 0 ;
8643 PyObject *swig_obj[1] ;
8644
8645 if (!args) SWIG_fail;
8646 swig_obj[0] = args;
8647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8648 if (!SWIG_IsOK(res1)) {
8649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8650 }
8651 arg1 = reinterpret_cast< wxCaret * >(argp1);
8652 {
8653 PyThreadState* __tstate = wxPyBeginAllowThreads();
8654 result = (arg1)->GetSize();
8655 wxPyEndAllowThreads(__tstate);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8659 return resultobj;
8660 fail:
8661 return NULL;
8662 }
8663
8664
8665 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8666 PyObject *resultobj = 0;
8667 wxCaret *arg1 = (wxCaret *) 0 ;
8668 int *arg2 = (int *) 0 ;
8669 int *arg3 = (int *) 0 ;
8670 void *argp1 = 0 ;
8671 int res1 = 0 ;
8672 int temp2 ;
8673 int res2 = SWIG_TMPOBJ ;
8674 int temp3 ;
8675 int res3 = SWIG_TMPOBJ ;
8676 PyObject *swig_obj[1] ;
8677
8678 arg2 = &temp2;
8679 arg3 = &temp3;
8680 if (!args) SWIG_fail;
8681 swig_obj[0] = args;
8682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8683 if (!SWIG_IsOK(res1)) {
8684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8685 }
8686 arg1 = reinterpret_cast< wxCaret * >(argp1);
8687 {
8688 PyThreadState* __tstate = wxPyBeginAllowThreads();
8689 (arg1)->GetSize(arg2,arg3);
8690 wxPyEndAllowThreads(__tstate);
8691 if (PyErr_Occurred()) SWIG_fail;
8692 }
8693 resultobj = SWIG_Py_Void();
8694 if (SWIG_IsTmpObj(res2)) {
8695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8696 } else {
8697 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8699 }
8700 if (SWIG_IsTmpObj(res3)) {
8701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8702 } else {
8703 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8705 }
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8713 PyObject *resultobj = 0;
8714 wxCaret *arg1 = (wxCaret *) 0 ;
8715 wxWindow *result = 0 ;
8716 void *argp1 = 0 ;
8717 int res1 = 0 ;
8718 PyObject *swig_obj[1] ;
8719
8720 if (!args) SWIG_fail;
8721 swig_obj[0] = args;
8722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8723 if (!SWIG_IsOK(res1)) {
8724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8725 }
8726 arg1 = reinterpret_cast< wxCaret * >(argp1);
8727 {
8728 PyThreadState* __tstate = wxPyBeginAllowThreads();
8729 result = (wxWindow *)(arg1)->GetWindow();
8730 wxPyEndAllowThreads(__tstate);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 {
8734 resultobj = wxPyMake_wxObject(result, 0);
8735 }
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj = 0;
8744 wxCaret *arg1 = (wxCaret *) 0 ;
8745 int arg2 ;
8746 int arg3 ;
8747 void *argp1 = 0 ;
8748 int res1 = 0 ;
8749 int val2 ;
8750 int ecode2 = 0 ;
8751 int val3 ;
8752 int ecode3 = 0 ;
8753 PyObject * obj0 = 0 ;
8754 PyObject * obj1 = 0 ;
8755 PyObject * obj2 = 0 ;
8756 char * kwnames[] = {
8757 (char *) "self",(char *) "x",(char *) "y", NULL
8758 };
8759
8760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8762 if (!SWIG_IsOK(res1)) {
8763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8764 }
8765 arg1 = reinterpret_cast< wxCaret * >(argp1);
8766 ecode2 = SWIG_AsVal_int(obj1, &val2);
8767 if (!SWIG_IsOK(ecode2)) {
8768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8769 }
8770 arg2 = static_cast< int >(val2);
8771 ecode3 = SWIG_AsVal_int(obj2, &val3);
8772 if (!SWIG_IsOK(ecode3)) {
8773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8774 }
8775 arg3 = static_cast< int >(val3);
8776 {
8777 PyThreadState* __tstate = wxPyBeginAllowThreads();
8778 (arg1)->Move(arg2,arg3);
8779 wxPyEndAllowThreads(__tstate);
8780 if (PyErr_Occurred()) SWIG_fail;
8781 }
8782 resultobj = SWIG_Py_Void();
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj = 0;
8791 wxCaret *arg1 = (wxCaret *) 0 ;
8792 wxPoint *arg2 = 0 ;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 wxPoint temp2 ;
8796 PyObject * obj0 = 0 ;
8797 PyObject * obj1 = 0 ;
8798 char * kwnames[] = {
8799 (char *) "self",(char *) "pt", NULL
8800 };
8801
8802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8804 if (!SWIG_IsOK(res1)) {
8805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8806 }
8807 arg1 = reinterpret_cast< wxCaret * >(argp1);
8808 {
8809 arg2 = &temp2;
8810 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8811 }
8812 {
8813 PyThreadState* __tstate = wxPyBeginAllowThreads();
8814 (arg1)->Move((wxPoint const &)*arg2);
8815 wxPyEndAllowThreads(__tstate);
8816 if (PyErr_Occurred()) SWIG_fail;
8817 }
8818 resultobj = SWIG_Py_Void();
8819 return resultobj;
8820 fail:
8821 return NULL;
8822 }
8823
8824
8825 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8826 PyObject *resultobj = 0;
8827 wxCaret *arg1 = (wxCaret *) 0 ;
8828 int arg2 ;
8829 int arg3 ;
8830 void *argp1 = 0 ;
8831 int res1 = 0 ;
8832 int val2 ;
8833 int ecode2 = 0 ;
8834 int val3 ;
8835 int ecode3 = 0 ;
8836 PyObject * obj0 = 0 ;
8837 PyObject * obj1 = 0 ;
8838 PyObject * obj2 = 0 ;
8839 char * kwnames[] = {
8840 (char *) "self",(char *) "width",(char *) "height", NULL
8841 };
8842
8843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8845 if (!SWIG_IsOK(res1)) {
8846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8847 }
8848 arg1 = reinterpret_cast< wxCaret * >(argp1);
8849 ecode2 = SWIG_AsVal_int(obj1, &val2);
8850 if (!SWIG_IsOK(ecode2)) {
8851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8852 }
8853 arg2 = static_cast< int >(val2);
8854 ecode3 = SWIG_AsVal_int(obj2, &val3);
8855 if (!SWIG_IsOK(ecode3)) {
8856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8857 }
8858 arg3 = static_cast< int >(val3);
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 (arg1)->SetSize(arg2,arg3);
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 resultobj = SWIG_Py_Void();
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8873 PyObject *resultobj = 0;
8874 wxCaret *arg1 = (wxCaret *) 0 ;
8875 wxSize *arg2 = 0 ;
8876 void *argp1 = 0 ;
8877 int res1 = 0 ;
8878 wxSize temp2 ;
8879 PyObject * obj0 = 0 ;
8880 PyObject * obj1 = 0 ;
8881 char * kwnames[] = {
8882 (char *) "self",(char *) "size", NULL
8883 };
8884
8885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8889 }
8890 arg1 = reinterpret_cast< wxCaret * >(argp1);
8891 {
8892 arg2 = &temp2;
8893 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8894 }
8895 {
8896 PyThreadState* __tstate = wxPyBeginAllowThreads();
8897 (arg1)->SetSize((wxSize const &)*arg2);
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 resultobj = SWIG_Py_Void();
8902 return resultobj;
8903 fail:
8904 return NULL;
8905 }
8906
8907
8908 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8909 PyObject *resultobj = 0;
8910 wxCaret *arg1 = (wxCaret *) 0 ;
8911 int arg2 = (int) true ;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 int val2 ;
8915 int ecode2 = 0 ;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 char * kwnames[] = {
8919 (char *) "self",(char *) "show", NULL
8920 };
8921
8922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8924 if (!SWIG_IsOK(res1)) {
8925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8926 }
8927 arg1 = reinterpret_cast< wxCaret * >(argp1);
8928 if (obj1) {
8929 ecode2 = SWIG_AsVal_int(obj1, &val2);
8930 if (!SWIG_IsOK(ecode2)) {
8931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8932 }
8933 arg2 = static_cast< int >(val2);
8934 }
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 (arg1)->Show(arg2);
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 resultobj = SWIG_Py_Void();
8942 return resultobj;
8943 fail:
8944 return NULL;
8945 }
8946
8947
8948 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8949 PyObject *resultobj = 0;
8950 wxCaret *arg1 = (wxCaret *) 0 ;
8951 void *argp1 = 0 ;
8952 int res1 = 0 ;
8953 PyObject *swig_obj[1] ;
8954
8955 if (!args) SWIG_fail;
8956 swig_obj[0] = args;
8957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8958 if (!SWIG_IsOK(res1)) {
8959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8960 }
8961 arg1 = reinterpret_cast< wxCaret * >(argp1);
8962 {
8963 PyThreadState* __tstate = wxPyBeginAllowThreads();
8964 (arg1)->Hide();
8965 wxPyEndAllowThreads(__tstate);
8966 if (PyErr_Occurred()) SWIG_fail;
8967 }
8968 resultobj = SWIG_Py_Void();
8969 return resultobj;
8970 fail:
8971 return NULL;
8972 }
8973
8974
8975 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8976 PyObject *resultobj = 0;
8977 int result;
8978
8979 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8980 {
8981 PyThreadState* __tstate = wxPyBeginAllowThreads();
8982 result = (int)wxCaret::GetBlinkTime();
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 resultobj = SWIG_From_int(static_cast< int >(result));
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8994 PyObject *resultobj = 0;
8995 int arg1 ;
8996 int val1 ;
8997 int ecode1 = 0 ;
8998 PyObject * obj0 = 0 ;
8999 char * kwnames[] = {
9000 (char *) "milliseconds", NULL
9001 };
9002
9003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9004 ecode1 = SWIG_AsVal_int(obj0, &val1);
9005 if (!SWIG_IsOK(ecode1)) {
9006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9007 }
9008 arg1 = static_cast< int >(val1);
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 wxCaret::SetBlinkTime(arg1);
9012 wxPyEndAllowThreads(__tstate);
9013 if (PyErr_Occurred()) SWIG_fail;
9014 }
9015 resultobj = SWIG_Py_Void();
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *obj;
9024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9025 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9026 return SWIG_Py_Void();
9027 }
9028
9029 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030 return SWIG_Python_InitShadowInstance(args);
9031 }
9032
9033 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj = 0;
9035 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9036 wxBusyCursor *result = 0 ;
9037 void *argp1 = 0 ;
9038 int res1 = 0 ;
9039 PyObject * obj0 = 0 ;
9040 char * kwnames[] = {
9041 (char *) "cursor", NULL
9042 };
9043
9044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9045 if (obj0) {
9046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9047 if (!SWIG_IsOK(res1)) {
9048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9049 }
9050 arg1 = reinterpret_cast< wxCursor * >(argp1);
9051 }
9052 {
9053 if (!wxPyCheckForApp()) SWIG_fail;
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067 PyObject *resultobj = 0;
9068 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9069 void *argp1 = 0 ;
9070 int res1 = 0 ;
9071 PyObject *swig_obj[1] ;
9072
9073 if (!args) SWIG_fail;
9074 swig_obj[0] = args;
9075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9076 if (!SWIG_IsOK(res1)) {
9077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9078 }
9079 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9080 {
9081 PyThreadState* __tstate = wxPyBeginAllowThreads();
9082 delete arg1;
9083
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 resultobj = SWIG_Py_Void();
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *obj;
9096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9097 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9098 return SWIG_Py_Void();
9099 }
9100
9101 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 return SWIG_Python_InitShadowInstance(args);
9103 }
9104
9105 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9106 PyObject *resultobj = 0;
9107 wxWindow *arg1 = (wxWindow *) NULL ;
9108 wxWindowDisabler *result = 0 ;
9109 void *argp1 = 0 ;
9110 int res1 = 0 ;
9111 PyObject * obj0 = 0 ;
9112 char * kwnames[] = {
9113 (char *) "winToSkip", NULL
9114 };
9115
9116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9117 if (obj0) {
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9121 }
9122 arg1 = reinterpret_cast< wxWindow * >(argp1);
9123 }
9124 {
9125 if (!wxPyCheckForApp()) SWIG_fail;
9126 PyThreadState* __tstate = wxPyBeginAllowThreads();
9127 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9132 return resultobj;
9133 fail:
9134 return NULL;
9135 }
9136
9137
9138 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9139 PyObject *resultobj = 0;
9140 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9141 void *argp1 = 0 ;
9142 int res1 = 0 ;
9143 PyObject *swig_obj[1] ;
9144
9145 if (!args) SWIG_fail;
9146 swig_obj[0] = args;
9147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9150 }
9151 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 delete arg1;
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 resultobj = SWIG_Py_Void();
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9167 PyObject *obj;
9168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9169 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9170 return SWIG_Py_Void();
9171 }
9172
9173 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9174 return SWIG_Python_InitShadowInstance(args);
9175 }
9176
9177 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj = 0;
9179 wxString *arg1 = 0 ;
9180 wxWindow *arg2 = (wxWindow *) NULL ;
9181 wxBusyInfo *result = 0 ;
9182 bool temp1 = false ;
9183 void *argp2 = 0 ;
9184 int res2 = 0 ;
9185 PyObject * obj0 = 0 ;
9186 PyObject * obj1 = 0 ;
9187 char * kwnames[] = {
9188 (char *) "message",(char *) "parent", NULL
9189 };
9190
9191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9192 {
9193 arg1 = wxString_in_helper(obj0);
9194 if (arg1 == NULL) SWIG_fail;
9195 temp1 = true;
9196 }
9197 if (obj1) {
9198 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9199 if (!SWIG_IsOK(res2)) {
9200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9201 }
9202 arg2 = reinterpret_cast< wxWindow * >(argp2);
9203 }
9204 {
9205 if (!wxPyCheckForApp()) SWIG_fail;
9206 PyThreadState* __tstate = wxPyBeginAllowThreads();
9207 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9208 wxPyEndAllowThreads(__tstate);
9209 if (PyErr_Occurred()) SWIG_fail;
9210 }
9211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9212 {
9213 if (temp1)
9214 delete arg1;
9215 }
9216 return resultobj;
9217 fail:
9218 {
9219 if (temp1)
9220 delete arg1;
9221 }
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *resultobj = 0;
9228 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 PyObject *swig_obj[1] ;
9232
9233 if (!args) SWIG_fail;
9234 swig_obj[0] = args;
9235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9238 }
9239 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 delete arg1;
9243
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 resultobj = SWIG_Py_Void();
9248 return resultobj;
9249 fail:
9250 return NULL;
9251 }
9252
9253
9254 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 PyObject *obj;
9256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9257 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9258 return SWIG_Py_Void();
9259 }
9260
9261 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9262 return SWIG_Python_InitShadowInstance(args);
9263 }
9264
9265 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9266 PyObject *resultobj = 0;
9267 wxStopWatch *result = 0 ;
9268
9269 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (wxStopWatch *)new wxStopWatch();
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9284 PyObject *resultobj = 0;
9285 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9286 void *argp1 = 0 ;
9287 int res1 = 0 ;
9288 PyObject *swig_obj[1] ;
9289
9290 if (!args) SWIG_fail;
9291 swig_obj[0] = args;
9292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9293 if (!SWIG_IsOK(res1)) {
9294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9295 }
9296 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9297 {
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 delete arg1;
9300
9301 wxPyEndAllowThreads(__tstate);
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 resultobj = SWIG_Py_Void();
9305 return resultobj;
9306 fail:
9307 return NULL;
9308 }
9309
9310
9311 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9312 PyObject *resultobj = 0;
9313 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9314 long arg2 = (long) 0 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 long val2 ;
9318 int ecode2 = 0 ;
9319 PyObject * obj0 = 0 ;
9320 PyObject * obj1 = 0 ;
9321 char * kwnames[] = {
9322 (char *) "self",(char *) "t0", NULL
9323 };
9324
9325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9327 if (!SWIG_IsOK(res1)) {
9328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9329 }
9330 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9331 if (obj1) {
9332 ecode2 = SWIG_AsVal_long(obj1, &val2);
9333 if (!SWIG_IsOK(ecode2)) {
9334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9335 }
9336 arg2 = static_cast< long >(val2);
9337 }
9338 {
9339 PyThreadState* __tstate = wxPyBeginAllowThreads();
9340 (arg1)->Start(arg2);
9341 wxPyEndAllowThreads(__tstate);
9342 if (PyErr_Occurred()) SWIG_fail;
9343 }
9344 resultobj = SWIG_Py_Void();
9345 return resultobj;
9346 fail:
9347 return NULL;
9348 }
9349
9350
9351 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9352 PyObject *resultobj = 0;
9353 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9354 void *argp1 = 0 ;
9355 int res1 = 0 ;
9356 PyObject *swig_obj[1] ;
9357
9358 if (!args) SWIG_fail;
9359 swig_obj[0] = args;
9360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9361 if (!SWIG_IsOK(res1)) {
9362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9363 }
9364 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9365 {
9366 PyThreadState* __tstate = wxPyBeginAllowThreads();
9367 (arg1)->Pause();
9368 wxPyEndAllowThreads(__tstate);
9369 if (PyErr_Occurred()) SWIG_fail;
9370 }
9371 resultobj = SWIG_Py_Void();
9372 return resultobj;
9373 fail:
9374 return NULL;
9375 }
9376
9377
9378 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9379 PyObject *resultobj = 0;
9380 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9381 void *argp1 = 0 ;
9382 int res1 = 0 ;
9383 PyObject *swig_obj[1] ;
9384
9385 if (!args) SWIG_fail;
9386 swig_obj[0] = args;
9387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9388 if (!SWIG_IsOK(res1)) {
9389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9390 }
9391 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9392 {
9393 PyThreadState* __tstate = wxPyBeginAllowThreads();
9394 (arg1)->Resume();
9395 wxPyEndAllowThreads(__tstate);
9396 if (PyErr_Occurred()) SWIG_fail;
9397 }
9398 resultobj = SWIG_Py_Void();
9399 return resultobj;
9400 fail:
9401 return NULL;
9402 }
9403
9404
9405 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9406 PyObject *resultobj = 0;
9407 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9408 long result;
9409 void *argp1 = 0 ;
9410 int res1 = 0 ;
9411 PyObject *swig_obj[1] ;
9412
9413 if (!args) SWIG_fail;
9414 swig_obj[0] = args;
9415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9416 if (!SWIG_IsOK(res1)) {
9417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9418 }
9419 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9420 {
9421 PyThreadState* __tstate = wxPyBeginAllowThreads();
9422 result = (long)((wxStopWatch const *)arg1)->Time();
9423 wxPyEndAllowThreads(__tstate);
9424 if (PyErr_Occurred()) SWIG_fail;
9425 }
9426 resultobj = SWIG_From_long(static_cast< long >(result));
9427 return resultobj;
9428 fail:
9429 return NULL;
9430 }
9431
9432
9433 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9434 PyObject *obj;
9435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9436 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9437 return SWIG_Py_Void();
9438 }
9439
9440 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9441 return SWIG_Python_InitShadowInstance(args);
9442 }
9443
9444 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9445 PyObject *resultobj = 0;
9446 int arg1 = (int) 9 ;
9447 int arg2 = (int) wxID_FILE1 ;
9448 wxFileHistory *result = 0 ;
9449 int val1 ;
9450 int ecode1 = 0 ;
9451 int val2 ;
9452 int ecode2 = 0 ;
9453 PyObject * obj0 = 0 ;
9454 PyObject * obj1 = 0 ;
9455 char * kwnames[] = {
9456 (char *) "maxFiles",(char *) "idBase", NULL
9457 };
9458
9459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9460 if (obj0) {
9461 ecode1 = SWIG_AsVal_int(obj0, &val1);
9462 if (!SWIG_IsOK(ecode1)) {
9463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9464 }
9465 arg1 = static_cast< int >(val1);
9466 }
9467 if (obj1) {
9468 ecode2 = SWIG_AsVal_int(obj1, &val2);
9469 if (!SWIG_IsOK(ecode2)) {
9470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9471 }
9472 arg2 = static_cast< int >(val2);
9473 }
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9488 PyObject *resultobj = 0;
9489 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9490 void *argp1 = 0 ;
9491 int res1 = 0 ;
9492 PyObject *swig_obj[1] ;
9493
9494 if (!args) SWIG_fail;
9495 swig_obj[0] = args;
9496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9497 if (!SWIG_IsOK(res1)) {
9498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9499 }
9500 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9501 {
9502 PyThreadState* __tstate = wxPyBeginAllowThreads();
9503 delete arg1;
9504
9505 wxPyEndAllowThreads(__tstate);
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 resultobj = SWIG_Py_Void();
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9516 PyObject *resultobj = 0;
9517 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9518 wxString *arg2 = 0 ;
9519 void *argp1 = 0 ;
9520 int res1 = 0 ;
9521 bool temp2 = false ;
9522 PyObject * obj0 = 0 ;
9523 PyObject * obj1 = 0 ;
9524 char * kwnames[] = {
9525 (char *) "self",(char *) "file", NULL
9526 };
9527
9528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9530 if (!SWIG_IsOK(res1)) {
9531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9532 }
9533 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9534 {
9535 arg2 = wxString_in_helper(obj1);
9536 if (arg2 == NULL) SWIG_fail;
9537 temp2 = true;
9538 }
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 (arg1)->AddFileToHistory((wxString const &)*arg2);
9542 wxPyEndAllowThreads(__tstate);
9543 if (PyErr_Occurred()) SWIG_fail;
9544 }
9545 resultobj = SWIG_Py_Void();
9546 {
9547 if (temp2)
9548 delete arg2;
9549 }
9550 return resultobj;
9551 fail:
9552 {
9553 if (temp2)
9554 delete arg2;
9555 }
9556 return NULL;
9557 }
9558
9559
9560 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9561 PyObject *resultobj = 0;
9562 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9563 int arg2 ;
9564 void *argp1 = 0 ;
9565 int res1 = 0 ;
9566 int val2 ;
9567 int ecode2 = 0 ;
9568 PyObject * obj0 = 0 ;
9569 PyObject * obj1 = 0 ;
9570 char * kwnames[] = {
9571 (char *) "self",(char *) "i", NULL
9572 };
9573
9574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9576 if (!SWIG_IsOK(res1)) {
9577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9578 }
9579 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9580 ecode2 = SWIG_AsVal_int(obj1, &val2);
9581 if (!SWIG_IsOK(ecode2)) {
9582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9583 }
9584 arg2 = static_cast< int >(val2);
9585 {
9586 PyThreadState* __tstate = wxPyBeginAllowThreads();
9587 (arg1)->RemoveFileFromHistory(arg2);
9588 wxPyEndAllowThreads(__tstate);
9589 if (PyErr_Occurred()) SWIG_fail;
9590 }
9591 resultobj = SWIG_Py_Void();
9592 return resultobj;
9593 fail:
9594 return NULL;
9595 }
9596
9597
9598 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9599 PyObject *resultobj = 0;
9600 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9601 int result;
9602 void *argp1 = 0 ;
9603 int res1 = 0 ;
9604 PyObject *swig_obj[1] ;
9605
9606 if (!args) SWIG_fail;
9607 swig_obj[0] = args;
9608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9609 if (!SWIG_IsOK(res1)) {
9610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9611 }
9612 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 resultobj = SWIG_From_int(static_cast< int >(result));
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj = 0;
9628 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9629 wxMenu *arg2 = (wxMenu *) 0 ;
9630 void *argp1 = 0 ;
9631 int res1 = 0 ;
9632 void *argp2 = 0 ;
9633 int res2 = 0 ;
9634 PyObject * obj0 = 0 ;
9635 PyObject * obj1 = 0 ;
9636 char * kwnames[] = {
9637 (char *) "self",(char *) "menu", NULL
9638 };
9639
9640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9644 }
9645 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9646 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9647 if (!SWIG_IsOK(res2)) {
9648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9649 }
9650 arg2 = reinterpret_cast< wxMenu * >(argp2);
9651 {
9652 PyThreadState* __tstate = wxPyBeginAllowThreads();
9653 (arg1)->UseMenu(arg2);
9654 wxPyEndAllowThreads(__tstate);
9655 if (PyErr_Occurred()) SWIG_fail;
9656 }
9657 resultobj = SWIG_Py_Void();
9658 return resultobj;
9659 fail:
9660 return NULL;
9661 }
9662
9663
9664 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9665 PyObject *resultobj = 0;
9666 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9667 wxMenu *arg2 = (wxMenu *) 0 ;
9668 void *argp1 = 0 ;
9669 int res1 = 0 ;
9670 void *argp2 = 0 ;
9671 int res2 = 0 ;
9672 PyObject * obj0 = 0 ;
9673 PyObject * obj1 = 0 ;
9674 char * kwnames[] = {
9675 (char *) "self",(char *) "menu", NULL
9676 };
9677
9678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9680 if (!SWIG_IsOK(res1)) {
9681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9682 }
9683 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9684 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9685 if (!SWIG_IsOK(res2)) {
9686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9687 }
9688 arg2 = reinterpret_cast< wxMenu * >(argp2);
9689 {
9690 PyThreadState* __tstate = wxPyBeginAllowThreads();
9691 (arg1)->RemoveMenu(arg2);
9692 wxPyEndAllowThreads(__tstate);
9693 if (PyErr_Occurred()) SWIG_fail;
9694 }
9695 resultobj = SWIG_Py_Void();
9696 return resultobj;
9697 fail:
9698 return NULL;
9699 }
9700
9701
9702 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj = 0;
9704 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9705 wxConfigBase *arg2 = 0 ;
9706 void *argp1 = 0 ;
9707 int res1 = 0 ;
9708 void *argp2 = 0 ;
9709 int res2 = 0 ;
9710 PyObject * obj0 = 0 ;
9711 PyObject * obj1 = 0 ;
9712 char * kwnames[] = {
9713 (char *) "self",(char *) "config", NULL
9714 };
9715
9716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9718 if (!SWIG_IsOK(res1)) {
9719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9720 }
9721 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9723 if (!SWIG_IsOK(res2)) {
9724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9725 }
9726 if (!argp2) {
9727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9728 }
9729 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 (arg1)->Load(*arg2);
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 resultobj = SWIG_Py_Void();
9737 return resultobj;
9738 fail:
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9744 PyObject *resultobj = 0;
9745 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9746 wxConfigBase *arg2 = 0 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 void *argp2 = 0 ;
9750 int res2 = 0 ;
9751 PyObject * obj0 = 0 ;
9752 PyObject * obj1 = 0 ;
9753 char * kwnames[] = {
9754 (char *) "self",(char *) "config", NULL
9755 };
9756
9757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9759 if (!SWIG_IsOK(res1)) {
9760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9761 }
9762 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9764 if (!SWIG_IsOK(res2)) {
9765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9766 }
9767 if (!argp2) {
9768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9769 }
9770 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9771 {
9772 PyThreadState* __tstate = wxPyBeginAllowThreads();
9773 (arg1)->Save(*arg2);
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 resultobj = SWIG_Py_Void();
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9785 PyObject *resultobj = 0;
9786 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9787 void *argp1 = 0 ;
9788 int res1 = 0 ;
9789 PyObject *swig_obj[1] ;
9790
9791 if (!args) SWIG_fail;
9792 swig_obj[0] = args;
9793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9794 if (!SWIG_IsOK(res1)) {
9795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9796 }
9797 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9798 {
9799 PyThreadState* __tstate = wxPyBeginAllowThreads();
9800 (arg1)->AddFilesToMenu();
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 resultobj = SWIG_Py_Void();
9805 return resultobj;
9806 fail:
9807 return NULL;
9808 }
9809
9810
9811 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9812 PyObject *resultobj = 0;
9813 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9814 wxMenu *arg2 = (wxMenu *) 0 ;
9815 void *argp1 = 0 ;
9816 int res1 = 0 ;
9817 void *argp2 = 0 ;
9818 int res2 = 0 ;
9819 PyObject * obj0 = 0 ;
9820 PyObject * obj1 = 0 ;
9821 char * kwnames[] = {
9822 (char *) "self",(char *) "menu", NULL
9823 };
9824
9825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9829 }
9830 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9832 if (!SWIG_IsOK(res2)) {
9833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9834 }
9835 arg2 = reinterpret_cast< wxMenu * >(argp2);
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 (arg1)->AddFilesToMenu(arg2);
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 resultobj = SWIG_Py_Void();
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9850 PyObject *resultobj = 0;
9851 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9852 int arg2 ;
9853 wxString result;
9854 void *argp1 = 0 ;
9855 int res1 = 0 ;
9856 int val2 ;
9857 int ecode2 = 0 ;
9858 PyObject * obj0 = 0 ;
9859 PyObject * obj1 = 0 ;
9860 char * kwnames[] = {
9861 (char *) "self",(char *) "i", NULL
9862 };
9863
9864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9868 }
9869 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9870 ecode2 = SWIG_AsVal_int(obj1, &val2);
9871 if (!SWIG_IsOK(ecode2)) {
9872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9873 }
9874 arg2 = static_cast< int >(val2);
9875 {
9876 PyThreadState* __tstate = wxPyBeginAllowThreads();
9877 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9878 wxPyEndAllowThreads(__tstate);
9879 if (PyErr_Occurred()) SWIG_fail;
9880 }
9881 {
9882 #if wxUSE_UNICODE
9883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9884 #else
9885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9886 #endif
9887 }
9888 return resultobj;
9889 fail:
9890 return NULL;
9891 }
9892
9893
9894 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9895 PyObject *resultobj = 0;
9896 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9897 int result;
9898 void *argp1 = 0 ;
9899 int res1 = 0 ;
9900 PyObject *swig_obj[1] ;
9901
9902 if (!args) SWIG_fail;
9903 swig_obj[0] = args;
9904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9905 if (!SWIG_IsOK(res1)) {
9906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9907 }
9908 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = (int)((wxFileHistory const *)arg1)->GetCount();
9912 wxPyEndAllowThreads(__tstate);
9913 if (PyErr_Occurred()) SWIG_fail;
9914 }
9915 resultobj = SWIG_From_int(static_cast< int >(result));
9916 return resultobj;
9917 fail:
9918 return NULL;
9919 }
9920
9921
9922 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9923 PyObject *obj;
9924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9925 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9926 return SWIG_Py_Void();
9927 }
9928
9929 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 return SWIG_Python_InitShadowInstance(args);
9931 }
9932
9933 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9934 PyObject *resultobj = 0;
9935 wxString *arg1 = 0 ;
9936 wxString const &arg2_defvalue = wxPyEmptyString ;
9937 wxString *arg2 = (wxString *) &arg2_defvalue ;
9938 wxSingleInstanceChecker *result = 0 ;
9939 bool temp1 = false ;
9940 bool temp2 = false ;
9941 PyObject * obj0 = 0 ;
9942 PyObject * obj1 = 0 ;
9943 char * kwnames[] = {
9944 (char *) "name",(char *) "path", NULL
9945 };
9946
9947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9948 {
9949 arg1 = wxString_in_helper(obj0);
9950 if (arg1 == NULL) SWIG_fail;
9951 temp1 = true;
9952 }
9953 if (obj1) {
9954 {
9955 arg2 = wxString_in_helper(obj1);
9956 if (arg2 == NULL) SWIG_fail;
9957 temp2 = true;
9958 }
9959 }
9960 {
9961 PyThreadState* __tstate = wxPyBeginAllowThreads();
9962 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9963 wxPyEndAllowThreads(__tstate);
9964 if (PyErr_Occurred()) SWIG_fail;
9965 }
9966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9967 {
9968 if (temp1)
9969 delete arg1;
9970 }
9971 {
9972 if (temp2)
9973 delete arg2;
9974 }
9975 return resultobj;
9976 fail:
9977 {
9978 if (temp1)
9979 delete arg1;
9980 }
9981 {
9982 if (temp2)
9983 delete arg2;
9984 }
9985 return NULL;
9986 }
9987
9988
9989 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9990 PyObject *resultobj = 0;
9991 wxSingleInstanceChecker *result = 0 ;
9992
9993 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9994 {
9995 PyThreadState* __tstate = wxPyBeginAllowThreads();
9996 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9997 wxPyEndAllowThreads(__tstate);
9998 if (PyErr_Occurred()) SWIG_fail;
9999 }
10000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10001 return resultobj;
10002 fail:
10003 return NULL;
10004 }
10005
10006
10007 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10008 PyObject *resultobj = 0;
10009 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10010 void *argp1 = 0 ;
10011 int res1 = 0 ;
10012 PyObject *swig_obj[1] ;
10013
10014 if (!args) SWIG_fail;
10015 swig_obj[0] = args;
10016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10017 if (!SWIG_IsOK(res1)) {
10018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10019 }
10020 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10021 {
10022 PyThreadState* __tstate = wxPyBeginAllowThreads();
10023 delete arg1;
10024
10025 wxPyEndAllowThreads(__tstate);
10026 if (PyErr_Occurred()) SWIG_fail;
10027 }
10028 resultobj = SWIG_Py_Void();
10029 return resultobj;
10030 fail:
10031 return NULL;
10032 }
10033
10034
10035 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10036 PyObject *resultobj = 0;
10037 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10038 wxString *arg2 = 0 ;
10039 wxString const &arg3_defvalue = wxPyEmptyString ;
10040 wxString *arg3 = (wxString *) &arg3_defvalue ;
10041 bool result;
10042 void *argp1 = 0 ;
10043 int res1 = 0 ;
10044 bool temp2 = false ;
10045 bool temp3 = false ;
10046 PyObject * obj0 = 0 ;
10047 PyObject * obj1 = 0 ;
10048 PyObject * obj2 = 0 ;
10049 char * kwnames[] = {
10050 (char *) "self",(char *) "name",(char *) "path", NULL
10051 };
10052
10053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10055 if (!SWIG_IsOK(res1)) {
10056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10057 }
10058 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10059 {
10060 arg2 = wxString_in_helper(obj1);
10061 if (arg2 == NULL) SWIG_fail;
10062 temp2 = true;
10063 }
10064 if (obj2) {
10065 {
10066 arg3 = wxString_in_helper(obj2);
10067 if (arg3 == NULL) SWIG_fail;
10068 temp3 = true;
10069 }
10070 }
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10074 wxPyEndAllowThreads(__tstate);
10075 if (PyErr_Occurred()) SWIG_fail;
10076 }
10077 {
10078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10079 }
10080 {
10081 if (temp2)
10082 delete arg2;
10083 }
10084 {
10085 if (temp3)
10086 delete arg3;
10087 }
10088 return resultobj;
10089 fail:
10090 {
10091 if (temp2)
10092 delete arg2;
10093 }
10094 {
10095 if (temp3)
10096 delete arg3;
10097 }
10098 return NULL;
10099 }
10100
10101
10102 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10103 PyObject *resultobj = 0;
10104 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10105 bool result;
10106 void *argp1 = 0 ;
10107 int res1 = 0 ;
10108 PyObject *swig_obj[1] ;
10109
10110 if (!args) SWIG_fail;
10111 swig_obj[0] = args;
10112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10113 if (!SWIG_IsOK(res1)) {
10114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10115 }
10116 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 {
10124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10125 }
10126 return resultobj;
10127 fail:
10128 return NULL;
10129 }
10130
10131
10132 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10133 PyObject *obj;
10134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10135 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10136 return SWIG_Py_Void();
10137 }
10138
10139 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10140 return SWIG_Python_InitShadowInstance(args);
10141 }
10142
10143 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10144 PyObject *resultobj = 0;
10145 wxPlatformInfo *result = 0 ;
10146
10147 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10148 {
10149 PyThreadState* __tstate = wxPyBeginAllowThreads();
10150 result = (wxPlatformInfo *)new wxPlatformInfo();
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10155 return resultobj;
10156 fail:
10157 return NULL;
10158 }
10159
10160
10161 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10162 PyObject *resultobj = 0;
10163 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10164 wxPlatformInfo *arg2 = 0 ;
10165 bool result;
10166 void *argp1 = 0 ;
10167 int res1 = 0 ;
10168 void *argp2 = 0 ;
10169 int res2 = 0 ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 char * kwnames[] = {
10173 (char *) "self",(char *) "t", NULL
10174 };
10175
10176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10180 }
10181 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10182 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10183 if (!SWIG_IsOK(res2)) {
10184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10185 }
10186 if (!argp2) {
10187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10188 }
10189 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10190 {
10191 PyThreadState* __tstate = wxPyBeginAllowThreads();
10192 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 {
10197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10198 }
10199 return resultobj;
10200 fail:
10201 return NULL;
10202 }
10203
10204
10205 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10206 PyObject *resultobj = 0;
10207 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10208 wxPlatformInfo *arg2 = 0 ;
10209 bool result;
10210 void *argp1 = 0 ;
10211 int res1 = 0 ;
10212 void *argp2 = 0 ;
10213 int res2 = 0 ;
10214 PyObject * obj0 = 0 ;
10215 PyObject * obj1 = 0 ;
10216 char * kwnames[] = {
10217 (char *) "self",(char *) "t", NULL
10218 };
10219
10220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10222 if (!SWIG_IsOK(res1)) {
10223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10224 }
10225 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10226 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10227 if (!SWIG_IsOK(res2)) {
10228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10229 }
10230 if (!argp2) {
10231 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10232 }
10233 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10234 {
10235 PyThreadState* __tstate = wxPyBeginAllowThreads();
10236 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10237 wxPyEndAllowThreads(__tstate);
10238 if (PyErr_Occurred()) SWIG_fail;
10239 }
10240 {
10241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10242 }
10243 return resultobj;
10244 fail:
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10250 PyObject *resultobj = 0;
10251 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10252 int result;
10253 void *argp1 = 0 ;
10254 int res1 = 0 ;
10255 PyObject *swig_obj[1] ;
10256
10257 if (!args) SWIG_fail;
10258 swig_obj[0] = args;
10259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10260 if (!SWIG_IsOK(res1)) {
10261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10262 }
10263 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10264 {
10265 PyThreadState* __tstate = wxPyBeginAllowThreads();
10266 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10267 wxPyEndAllowThreads(__tstate);
10268 if (PyErr_Occurred()) SWIG_fail;
10269 }
10270 resultobj = SWIG_From_int(static_cast< int >(result));
10271 return resultobj;
10272 fail:
10273 return NULL;
10274 }
10275
10276
10277 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10278 PyObject *resultobj = 0;
10279 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10280 int result;
10281 void *argp1 = 0 ;
10282 int res1 = 0 ;
10283 PyObject *swig_obj[1] ;
10284
10285 if (!args) SWIG_fail;
10286 swig_obj[0] = args;
10287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10288 if (!SWIG_IsOK(res1)) {
10289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10290 }
10291 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10292 {
10293 PyThreadState* __tstate = wxPyBeginAllowThreads();
10294 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10295 wxPyEndAllowThreads(__tstate);
10296 if (PyErr_Occurred()) SWIG_fail;
10297 }
10298 resultobj = SWIG_From_int(static_cast< int >(result));
10299 return resultobj;
10300 fail:
10301 return NULL;
10302 }
10303
10304
10305 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10306 PyObject *resultobj = 0;
10307 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10308 int arg2 ;
10309 int arg3 ;
10310 bool result;
10311 void *argp1 = 0 ;
10312 int res1 = 0 ;
10313 int val2 ;
10314 int ecode2 = 0 ;
10315 int val3 ;
10316 int ecode3 = 0 ;
10317 PyObject * obj0 = 0 ;
10318 PyObject * obj1 = 0 ;
10319 PyObject * obj2 = 0 ;
10320 char * kwnames[] = {
10321 (char *) "self",(char *) "major",(char *) "minor", NULL
10322 };
10323
10324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10326 if (!SWIG_IsOK(res1)) {
10327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10328 }
10329 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10330 ecode2 = SWIG_AsVal_int(obj1, &val2);
10331 if (!SWIG_IsOK(ecode2)) {
10332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10333 }
10334 arg2 = static_cast< int >(val2);
10335 ecode3 = SWIG_AsVal_int(obj2, &val3);
10336 if (!SWIG_IsOK(ecode3)) {
10337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10338 }
10339 arg3 = static_cast< int >(val3);
10340 {
10341 PyThreadState* __tstate = wxPyBeginAllowThreads();
10342 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10343 wxPyEndAllowThreads(__tstate);
10344 if (PyErr_Occurred()) SWIG_fail;
10345 }
10346 {
10347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10348 }
10349 return resultobj;
10350 fail:
10351 return NULL;
10352 }
10353
10354
10355 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10356 PyObject *resultobj = 0;
10357 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10358 int result;
10359 void *argp1 = 0 ;
10360 int res1 = 0 ;
10361 PyObject *swig_obj[1] ;
10362
10363 if (!args) SWIG_fail;
10364 swig_obj[0] = args;
10365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10366 if (!SWIG_IsOK(res1)) {
10367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10368 }
10369 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10370 {
10371 PyThreadState* __tstate = wxPyBeginAllowThreads();
10372 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10373 wxPyEndAllowThreads(__tstate);
10374 if (PyErr_Occurred()) SWIG_fail;
10375 }
10376 resultobj = SWIG_From_int(static_cast< int >(result));
10377 return resultobj;
10378 fail:
10379 return NULL;
10380 }
10381
10382
10383 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10384 PyObject *resultobj = 0;
10385 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10386 int result;
10387 void *argp1 = 0 ;
10388 int res1 = 0 ;
10389 PyObject *swig_obj[1] ;
10390
10391 if (!args) SWIG_fail;
10392 swig_obj[0] = args;
10393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10394 if (!SWIG_IsOK(res1)) {
10395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10396 }
10397 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10398 {
10399 PyThreadState* __tstate = wxPyBeginAllowThreads();
10400 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10401 wxPyEndAllowThreads(__tstate);
10402 if (PyErr_Occurred()) SWIG_fail;
10403 }
10404 resultobj = SWIG_From_int(static_cast< int >(result));
10405 return resultobj;
10406 fail:
10407 return NULL;
10408 }
10409
10410
10411 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10412 PyObject *resultobj = 0;
10413 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10414 int arg2 ;
10415 int arg3 ;
10416 bool result;
10417 void *argp1 = 0 ;
10418 int res1 = 0 ;
10419 int val2 ;
10420 int ecode2 = 0 ;
10421 int val3 ;
10422 int ecode3 = 0 ;
10423 PyObject * obj0 = 0 ;
10424 PyObject * obj1 = 0 ;
10425 PyObject * obj2 = 0 ;
10426 char * kwnames[] = {
10427 (char *) "self",(char *) "major",(char *) "minor", NULL
10428 };
10429
10430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10432 if (!SWIG_IsOK(res1)) {
10433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10434 }
10435 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10436 ecode2 = SWIG_AsVal_int(obj1, &val2);
10437 if (!SWIG_IsOK(ecode2)) {
10438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10439 }
10440 arg2 = static_cast< int >(val2);
10441 ecode3 = SWIG_AsVal_int(obj2, &val3);
10442 if (!SWIG_IsOK(ecode3)) {
10443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10444 }
10445 arg3 = static_cast< int >(val3);
10446 {
10447 PyThreadState* __tstate = wxPyBeginAllowThreads();
10448 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10449 wxPyEndAllowThreads(__tstate);
10450 if (PyErr_Occurred()) SWIG_fail;
10451 }
10452 {
10453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10454 }
10455 return resultobj;
10456 fail:
10457 return NULL;
10458 }
10459
10460
10461 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 PyObject *resultobj = 0;
10463 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10464 bool result;
10465 void *argp1 = 0 ;
10466 int res1 = 0 ;
10467 PyObject *swig_obj[1] ;
10468
10469 if (!args) SWIG_fail;
10470 swig_obj[0] = args;
10471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10472 if (!SWIG_IsOK(res1)) {
10473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10474 }
10475 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10476 {
10477 PyThreadState* __tstate = wxPyBeginAllowThreads();
10478 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10479 wxPyEndAllowThreads(__tstate);
10480 if (PyErr_Occurred()) SWIG_fail;
10481 }
10482 {
10483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10484 }
10485 return resultobj;
10486 fail:
10487 return NULL;
10488 }
10489
10490
10491 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10492 PyObject *resultobj = 0;
10493 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10494 wxOperatingSystemId result;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 PyObject *swig_obj[1] ;
10498
10499 if (!args) SWIG_fail;
10500 swig_obj[0] = args;
10501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10502 if (!SWIG_IsOK(res1)) {
10503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10504 }
10505 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10509 wxPyEndAllowThreads(__tstate);
10510 if (PyErr_Occurred()) SWIG_fail;
10511 }
10512 resultobj = SWIG_From_int(static_cast< int >(result));
10513 return resultobj;
10514 fail:
10515 return NULL;
10516 }
10517
10518
10519 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10520 PyObject *resultobj = 0;
10521 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10522 wxPortId result;
10523 void *argp1 = 0 ;
10524 int res1 = 0 ;
10525 PyObject *swig_obj[1] ;
10526
10527 if (!args) SWIG_fail;
10528 swig_obj[0] = args;
10529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10530 if (!SWIG_IsOK(res1)) {
10531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10532 }
10533 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10534 {
10535 PyThreadState* __tstate = wxPyBeginAllowThreads();
10536 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10537 wxPyEndAllowThreads(__tstate);
10538 if (PyErr_Occurred()) SWIG_fail;
10539 }
10540 resultobj = SWIG_From_int(static_cast< int >(result));
10541 return resultobj;
10542 fail:
10543 return NULL;
10544 }
10545
10546
10547 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10548 PyObject *resultobj = 0;
10549 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10550 wxArchitecture result;
10551 void *argp1 = 0 ;
10552 int res1 = 0 ;
10553 PyObject *swig_obj[1] ;
10554
10555 if (!args) SWIG_fail;
10556 swig_obj[0] = args;
10557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10558 if (!SWIG_IsOK(res1)) {
10559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10560 }
10561 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10562 {
10563 PyThreadState* __tstate = wxPyBeginAllowThreads();
10564 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10565 wxPyEndAllowThreads(__tstate);
10566 if (PyErr_Occurred()) SWIG_fail;
10567 }
10568 resultobj = SWIG_From_int(static_cast< int >(result));
10569 return resultobj;
10570 fail:
10571 return NULL;
10572 }
10573
10574
10575 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10576 PyObject *resultobj = 0;
10577 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10578 wxEndianness result;
10579 void *argp1 = 0 ;
10580 int res1 = 0 ;
10581 PyObject *swig_obj[1] ;
10582
10583 if (!args) SWIG_fail;
10584 swig_obj[0] = args;
10585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10586 if (!SWIG_IsOK(res1)) {
10587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10588 }
10589 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10590 {
10591 PyThreadState* __tstate = wxPyBeginAllowThreads();
10592 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10593 wxPyEndAllowThreads(__tstate);
10594 if (PyErr_Occurred()) SWIG_fail;
10595 }
10596 resultobj = SWIG_From_int(static_cast< int >(result));
10597 return resultobj;
10598 fail:
10599 return NULL;
10600 }
10601
10602
10603 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10604 PyObject *resultobj = 0;
10605 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10606 wxString result;
10607 void *argp1 = 0 ;
10608 int res1 = 0 ;
10609 PyObject *swig_obj[1] ;
10610
10611 if (!args) SWIG_fail;
10612 swig_obj[0] = args;
10613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10614 if (!SWIG_IsOK(res1)) {
10615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10616 }
10617 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10621 wxPyEndAllowThreads(__tstate);
10622 if (PyErr_Occurred()) SWIG_fail;
10623 }
10624 {
10625 #if wxUSE_UNICODE
10626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10627 #else
10628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10629 #endif
10630 }
10631 return resultobj;
10632 fail:
10633 return NULL;
10634 }
10635
10636
10637 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10638 PyObject *resultobj = 0;
10639 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10640 wxString result;
10641 void *argp1 = 0 ;
10642 int res1 = 0 ;
10643 PyObject *swig_obj[1] ;
10644
10645 if (!args) SWIG_fail;
10646 swig_obj[0] = args;
10647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10648 if (!SWIG_IsOK(res1)) {
10649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10650 }
10651 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10652 {
10653 PyThreadState* __tstate = wxPyBeginAllowThreads();
10654 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10655 wxPyEndAllowThreads(__tstate);
10656 if (PyErr_Occurred()) SWIG_fail;
10657 }
10658 {
10659 #if wxUSE_UNICODE
10660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10661 #else
10662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10663 #endif
10664 }
10665 return resultobj;
10666 fail:
10667 return NULL;
10668 }
10669
10670
10671 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10672 PyObject *resultobj = 0;
10673 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10674 wxString result;
10675 void *argp1 = 0 ;
10676 int res1 = 0 ;
10677 PyObject *swig_obj[1] ;
10678
10679 if (!args) SWIG_fail;
10680 swig_obj[0] = args;
10681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10682 if (!SWIG_IsOK(res1)) {
10683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10684 }
10685 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 {
10693 #if wxUSE_UNICODE
10694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10695 #else
10696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10697 #endif
10698 }
10699 return resultobj;
10700 fail:
10701 return NULL;
10702 }
10703
10704
10705 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10706 PyObject *resultobj = 0;
10707 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10708 wxString result;
10709 void *argp1 = 0 ;
10710 int res1 = 0 ;
10711 PyObject *swig_obj[1] ;
10712
10713 if (!args) SWIG_fail;
10714 swig_obj[0] = args;
10715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10716 if (!SWIG_IsOK(res1)) {
10717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10718 }
10719 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10720 {
10721 PyThreadState* __tstate = wxPyBeginAllowThreads();
10722 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10723 wxPyEndAllowThreads(__tstate);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 {
10727 #if wxUSE_UNICODE
10728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10729 #else
10730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10731 #endif
10732 }
10733 return resultobj;
10734 fail:
10735 return NULL;
10736 }
10737
10738
10739 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10740 PyObject *resultobj = 0;
10741 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10742 wxString result;
10743 void *argp1 = 0 ;
10744 int res1 = 0 ;
10745 PyObject *swig_obj[1] ;
10746
10747 if (!args) SWIG_fail;
10748 swig_obj[0] = args;
10749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10750 if (!SWIG_IsOK(res1)) {
10751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10752 }
10753 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10754 {
10755 PyThreadState* __tstate = wxPyBeginAllowThreads();
10756 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 {
10761 #if wxUSE_UNICODE
10762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10763 #else
10764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10765 #endif
10766 }
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10774 PyObject *resultobj = 0;
10775 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10776 wxString result;
10777 void *argp1 = 0 ;
10778 int res1 = 0 ;
10779 PyObject *swig_obj[1] ;
10780
10781 if (!args) SWIG_fail;
10782 swig_obj[0] = args;
10783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10784 if (!SWIG_IsOK(res1)) {
10785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10786 }
10787 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10791 wxPyEndAllowThreads(__tstate);
10792 if (PyErr_Occurred()) SWIG_fail;
10793 }
10794 {
10795 #if wxUSE_UNICODE
10796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10797 #else
10798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10799 #endif
10800 }
10801 return resultobj;
10802 fail:
10803 return NULL;
10804 }
10805
10806
10807 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10808 PyObject *resultobj = 0;
10809 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10810 int arg2 ;
10811 int arg3 ;
10812 void *argp1 = 0 ;
10813 int res1 = 0 ;
10814 int val2 ;
10815 int ecode2 = 0 ;
10816 int val3 ;
10817 int ecode3 = 0 ;
10818 PyObject * obj0 = 0 ;
10819 PyObject * obj1 = 0 ;
10820 PyObject * obj2 = 0 ;
10821 char * kwnames[] = {
10822 (char *) "self",(char *) "major",(char *) "minor", NULL
10823 };
10824
10825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10827 if (!SWIG_IsOK(res1)) {
10828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10829 }
10830 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10831 ecode2 = SWIG_AsVal_int(obj1, &val2);
10832 if (!SWIG_IsOK(ecode2)) {
10833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10834 }
10835 arg2 = static_cast< int >(val2);
10836 ecode3 = SWIG_AsVal_int(obj2, &val3);
10837 if (!SWIG_IsOK(ecode3)) {
10838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10839 }
10840 arg3 = static_cast< int >(val3);
10841 {
10842 PyThreadState* __tstate = wxPyBeginAllowThreads();
10843 (arg1)->SetOSVersion(arg2,arg3);
10844 wxPyEndAllowThreads(__tstate);
10845 if (PyErr_Occurred()) SWIG_fail;
10846 }
10847 resultobj = SWIG_Py_Void();
10848 return resultobj;
10849 fail:
10850 return NULL;
10851 }
10852
10853
10854 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10855 PyObject *resultobj = 0;
10856 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10857 int arg2 ;
10858 int arg3 ;
10859 void *argp1 = 0 ;
10860 int res1 = 0 ;
10861 int val2 ;
10862 int ecode2 = 0 ;
10863 int val3 ;
10864 int ecode3 = 0 ;
10865 PyObject * obj0 = 0 ;
10866 PyObject * obj1 = 0 ;
10867 PyObject * obj2 = 0 ;
10868 char * kwnames[] = {
10869 (char *) "self",(char *) "major",(char *) "minor", NULL
10870 };
10871
10872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10874 if (!SWIG_IsOK(res1)) {
10875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10876 }
10877 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10878 ecode2 = SWIG_AsVal_int(obj1, &val2);
10879 if (!SWIG_IsOK(ecode2)) {
10880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10881 }
10882 arg2 = static_cast< int >(val2);
10883 ecode3 = SWIG_AsVal_int(obj2, &val3);
10884 if (!SWIG_IsOK(ecode3)) {
10885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10886 }
10887 arg3 = static_cast< int >(val3);
10888 {
10889 PyThreadState* __tstate = wxPyBeginAllowThreads();
10890 (arg1)->SetToolkitVersion(arg2,arg3);
10891 wxPyEndAllowThreads(__tstate);
10892 if (PyErr_Occurred()) SWIG_fail;
10893 }
10894 resultobj = SWIG_Py_Void();
10895 return resultobj;
10896 fail:
10897 return NULL;
10898 }
10899
10900
10901 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10902 PyObject *resultobj = 0;
10903 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10904 wxOperatingSystemId arg2 ;
10905 void *argp1 = 0 ;
10906 int res1 = 0 ;
10907 int val2 ;
10908 int ecode2 = 0 ;
10909 PyObject * obj0 = 0 ;
10910 PyObject * obj1 = 0 ;
10911 char * kwnames[] = {
10912 (char *) "self",(char *) "n", NULL
10913 };
10914
10915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10917 if (!SWIG_IsOK(res1)) {
10918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10919 }
10920 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10921 ecode2 = SWIG_AsVal_int(obj1, &val2);
10922 if (!SWIG_IsOK(ecode2)) {
10923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10924 }
10925 arg2 = static_cast< wxOperatingSystemId >(val2);
10926 {
10927 PyThreadState* __tstate = wxPyBeginAllowThreads();
10928 (arg1)->SetOperatingSystemId(arg2);
10929 wxPyEndAllowThreads(__tstate);
10930 if (PyErr_Occurred()) SWIG_fail;
10931 }
10932 resultobj = SWIG_Py_Void();
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj = 0;
10941 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10942 wxPortId arg2 ;
10943 void *argp1 = 0 ;
10944 int res1 = 0 ;
10945 int val2 ;
10946 int ecode2 = 0 ;
10947 PyObject * obj0 = 0 ;
10948 PyObject * obj1 = 0 ;
10949 char * kwnames[] = {
10950 (char *) "self",(char *) "n", NULL
10951 };
10952
10953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10955 if (!SWIG_IsOK(res1)) {
10956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10957 }
10958 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10959 ecode2 = SWIG_AsVal_int(obj1, &val2);
10960 if (!SWIG_IsOK(ecode2)) {
10961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10962 }
10963 arg2 = static_cast< wxPortId >(val2);
10964 {
10965 PyThreadState* __tstate = wxPyBeginAllowThreads();
10966 (arg1)->SetPortId(arg2);
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 resultobj = SWIG_Py_Void();
10971 return resultobj;
10972 fail:
10973 return NULL;
10974 }
10975
10976
10977 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10978 PyObject *resultobj = 0;
10979 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10980 wxArchitecture arg2 ;
10981 void *argp1 = 0 ;
10982 int res1 = 0 ;
10983 int val2 ;
10984 int ecode2 = 0 ;
10985 PyObject * obj0 = 0 ;
10986 PyObject * obj1 = 0 ;
10987 char * kwnames[] = {
10988 (char *) "self",(char *) "n", NULL
10989 };
10990
10991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10993 if (!SWIG_IsOK(res1)) {
10994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10995 }
10996 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10997 ecode2 = SWIG_AsVal_int(obj1, &val2);
10998 if (!SWIG_IsOK(ecode2)) {
10999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11000 }
11001 arg2 = static_cast< wxArchitecture >(val2);
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 (arg1)->SetArchitecture(arg2);
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 resultobj = SWIG_Py_Void();
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj = 0;
11017 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11018 wxEndianness arg2 ;
11019 void *argp1 = 0 ;
11020 int res1 = 0 ;
11021 int val2 ;
11022 int ecode2 = 0 ;
11023 PyObject * obj0 = 0 ;
11024 PyObject * obj1 = 0 ;
11025 char * kwnames[] = {
11026 (char *) "self",(char *) "n", NULL
11027 };
11028
11029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11031 if (!SWIG_IsOK(res1)) {
11032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11033 }
11034 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11035 ecode2 = SWIG_AsVal_int(obj1, &val2);
11036 if (!SWIG_IsOK(ecode2)) {
11037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11038 }
11039 arg2 = static_cast< wxEndianness >(val2);
11040 {
11041 PyThreadState* __tstate = wxPyBeginAllowThreads();
11042 (arg1)->SetEndianness(arg2);
11043 wxPyEndAllowThreads(__tstate);
11044 if (PyErr_Occurred()) SWIG_fail;
11045 }
11046 resultobj = SWIG_Py_Void();
11047 return resultobj;
11048 fail:
11049 return NULL;
11050 }
11051
11052
11053 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11054 PyObject *resultobj = 0;
11055 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11056 bool result;
11057 void *argp1 = 0 ;
11058 int res1 = 0 ;
11059 PyObject *swig_obj[1] ;
11060
11061 if (!args) SWIG_fail;
11062 swig_obj[0] = args;
11063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11066 }
11067 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11068 {
11069 PyThreadState* __tstate = wxPyBeginAllowThreads();
11070 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11071 wxPyEndAllowThreads(__tstate);
11072 if (PyErr_Occurred()) SWIG_fail;
11073 }
11074 {
11075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11076 }
11077 return resultobj;
11078 fail:
11079 return NULL;
11080 }
11081
11082
11083 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11084 PyObject *obj;
11085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11086 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11087 return SWIG_Py_Void();
11088 }
11089
11090 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11091 return SWIG_Python_InitShadowInstance(args);
11092 }
11093
11094 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11095 PyObject *resultobj = 0;
11096 wxWindow *arg1 = (wxWindow *) 0 ;
11097 wxDC *arg2 = 0 ;
11098 bool result;
11099 void *argp1 = 0 ;
11100 int res1 = 0 ;
11101 void *argp2 = 0 ;
11102 int res2 = 0 ;
11103 PyObject * obj0 = 0 ;
11104 PyObject * obj1 = 0 ;
11105 char * kwnames[] = {
11106 (char *) "window",(char *) "dc", NULL
11107 };
11108
11109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11111 if (!SWIG_IsOK(res1)) {
11112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11113 }
11114 arg1 = reinterpret_cast< wxWindow * >(argp1);
11115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11116 if (!SWIG_IsOK(res2)) {
11117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11118 }
11119 if (!argp2) {
11120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11121 }
11122 arg2 = reinterpret_cast< wxDC * >(argp2);
11123 {
11124 PyThreadState* __tstate = wxPyBeginAllowThreads();
11125 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11126 wxPyEndAllowThreads(__tstate);
11127 if (PyErr_Occurred()) SWIG_fail;
11128 }
11129 {
11130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11131 }
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11139 PyObject *resultobj = 0;
11140 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11141 void *argp1 = 0 ;
11142 int res1 = 0 ;
11143 PyObject *swig_obj[1] ;
11144
11145 if (!args) SWIG_fail;
11146 swig_obj[0] = args;
11147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11148 if (!SWIG_IsOK(res1)) {
11149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11150 }
11151 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11152 {
11153 PyThreadState* __tstate = wxPyBeginAllowThreads();
11154 delete arg1;
11155
11156 wxPyEndAllowThreads(__tstate);
11157 if (PyErr_Occurred()) SWIG_fail;
11158 }
11159 resultobj = SWIG_Py_Void();
11160 return resultobj;
11161 fail:
11162 return NULL;
11163 }
11164
11165
11166 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11167 PyObject *resultobj = 0;
11168 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11169 wxString result;
11170 void *argp1 = 0 ;
11171 int res1 = 0 ;
11172 PyObject *swig_obj[1] ;
11173
11174 if (!args) SWIG_fail;
11175 swig_obj[0] = args;
11176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11177 if (!SWIG_IsOK(res1)) {
11178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11179 }
11180 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11181 {
11182 PyThreadState* __tstate = wxPyBeginAllowThreads();
11183 result = (arg1)->GetTip();
11184 wxPyEndAllowThreads(__tstate);
11185 if (PyErr_Occurred()) SWIG_fail;
11186 }
11187 {
11188 #if wxUSE_UNICODE
11189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11190 #else
11191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11192 #endif
11193 }
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11201 PyObject *resultobj = 0;
11202 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11203 size_t result;
11204 void *argp1 = 0 ;
11205 int res1 = 0 ;
11206 PyObject *swig_obj[1] ;
11207
11208 if (!args) SWIG_fail;
11209 swig_obj[0] = args;
11210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11211 if (!SWIG_IsOK(res1)) {
11212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11213 }
11214 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11215 {
11216 PyThreadState* __tstate = wxPyBeginAllowThreads();
11217 result = (size_t)(arg1)->GetCurrentTip();
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11222 return resultobj;
11223 fail:
11224 return NULL;
11225 }
11226
11227
11228 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11229 PyObject *resultobj = 0;
11230 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11231 wxString *arg2 = 0 ;
11232 wxString result;
11233 void *argp1 = 0 ;
11234 int res1 = 0 ;
11235 bool temp2 = false ;
11236 PyObject * obj0 = 0 ;
11237 PyObject * obj1 = 0 ;
11238 char * kwnames[] = {
11239 (char *) "self",(char *) "tip", NULL
11240 };
11241
11242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11244 if (!SWIG_IsOK(res1)) {
11245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11246 }
11247 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11248 {
11249 arg2 = wxString_in_helper(obj1);
11250 if (arg2 == NULL) SWIG_fail;
11251 temp2 = true;
11252 }
11253 {
11254 PyThreadState* __tstate = wxPyBeginAllowThreads();
11255 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11256 wxPyEndAllowThreads(__tstate);
11257 if (PyErr_Occurred()) SWIG_fail;
11258 }
11259 {
11260 #if wxUSE_UNICODE
11261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11262 #else
11263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11264 #endif
11265 }
11266 {
11267 if (temp2)
11268 delete arg2;
11269 }
11270 return resultobj;
11271 fail:
11272 {
11273 if (temp2)
11274 delete arg2;
11275 }
11276 return NULL;
11277 }
11278
11279
11280 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11281 PyObject *obj;
11282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11283 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11284 return SWIG_Py_Void();
11285 }
11286
11287 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj = 0;
11289 size_t arg1 ;
11290 wxPyTipProvider *result = 0 ;
11291 size_t val1 ;
11292 int ecode1 = 0 ;
11293 PyObject * obj0 = 0 ;
11294 char * kwnames[] = {
11295 (char *) "currentTip", NULL
11296 };
11297
11298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11299 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11300 if (!SWIG_IsOK(ecode1)) {
11301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11302 }
11303 arg1 = static_cast< size_t >(val1);
11304 {
11305 PyThreadState* __tstate = wxPyBeginAllowThreads();
11306 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11307 wxPyEndAllowThreads(__tstate);
11308 if (PyErr_Occurred()) SWIG_fail;
11309 }
11310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11318 PyObject *resultobj = 0;
11319 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11320 PyObject *arg2 = (PyObject *) 0 ;
11321 PyObject *arg3 = (PyObject *) 0 ;
11322 void *argp1 = 0 ;
11323 int res1 = 0 ;
11324 PyObject * obj0 = 0 ;
11325 PyObject * obj1 = 0 ;
11326 PyObject * obj2 = 0 ;
11327 char * kwnames[] = {
11328 (char *) "self",(char *) "self",(char *) "_class", NULL
11329 };
11330
11331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11333 if (!SWIG_IsOK(res1)) {
11334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11335 }
11336 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11337 arg2 = obj1;
11338 arg3 = obj2;
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 (arg1)->_setCallbackInfo(arg2,arg3);
11342 wxPyEndAllowThreads(__tstate);
11343 if (PyErr_Occurred()) SWIG_fail;
11344 }
11345 resultobj = SWIG_Py_Void();
11346 return resultobj;
11347 fail:
11348 return NULL;
11349 }
11350
11351
11352 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11353 PyObject *obj;
11354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11355 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11356 return SWIG_Py_Void();
11357 }
11358
11359 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11360 return SWIG_Python_InitShadowInstance(args);
11361 }
11362
11363 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj = 0;
11365 wxWindow *arg1 = (wxWindow *) 0 ;
11366 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11367 bool arg3 = (bool) true ;
11368 bool result;
11369 void *argp1 = 0 ;
11370 int res1 = 0 ;
11371 void *argp2 = 0 ;
11372 int res2 = 0 ;
11373 bool val3 ;
11374 int ecode3 = 0 ;
11375 PyObject * obj0 = 0 ;
11376 PyObject * obj1 = 0 ;
11377 PyObject * obj2 = 0 ;
11378 char * kwnames[] = {
11379 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11380 };
11381
11382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11384 if (!SWIG_IsOK(res1)) {
11385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11386 }
11387 arg1 = reinterpret_cast< wxWindow * >(argp1);
11388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11389 if (!SWIG_IsOK(res2)) {
11390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11391 }
11392 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11393 if (obj2) {
11394 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11395 if (!SWIG_IsOK(ecode3)) {
11396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11397 }
11398 arg3 = static_cast< bool >(val3);
11399 }
11400 {
11401 if (!wxPyCheckForApp()) SWIG_fail;
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 result = (bool)wxShowTip(arg1,arg2,arg3);
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 {
11408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11409 }
11410 return resultobj;
11411 fail:
11412 return NULL;
11413 }
11414
11415
11416 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj = 0;
11418 wxString *arg1 = 0 ;
11419 size_t arg2 ;
11420 wxTipProvider *result = 0 ;
11421 bool temp1 = false ;
11422 size_t val2 ;
11423 int ecode2 = 0 ;
11424 PyObject * obj0 = 0 ;
11425 PyObject * obj1 = 0 ;
11426 char * kwnames[] = {
11427 (char *) "filename",(char *) "currentTip", NULL
11428 };
11429
11430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11431 {
11432 arg1 = wxString_in_helper(obj0);
11433 if (arg1 == NULL) SWIG_fail;
11434 temp1 = true;
11435 }
11436 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11437 if (!SWIG_IsOK(ecode2)) {
11438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11439 }
11440 arg2 = static_cast< size_t >(val2);
11441 {
11442 if (!wxPyCheckForApp()) SWIG_fail;
11443 PyThreadState* __tstate = wxPyBeginAllowThreads();
11444 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11445 wxPyEndAllowThreads(__tstate);
11446 if (PyErr_Occurred()) SWIG_fail;
11447 }
11448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11449 {
11450 if (temp1)
11451 delete arg1;
11452 }
11453 return resultobj;
11454 fail:
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return NULL;
11460 }
11461
11462
11463 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj = 0;
11465 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11466 int arg2 = (int) wxID_ANY ;
11467 wxPyTimer *result = 0 ;
11468 void *argp1 = 0 ;
11469 int res1 = 0 ;
11470 int val2 ;
11471 int ecode2 = 0 ;
11472 PyObject * obj0 = 0 ;
11473 PyObject * obj1 = 0 ;
11474 char * kwnames[] = {
11475 (char *) "owner",(char *) "id", NULL
11476 };
11477
11478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11479 if (obj0) {
11480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11481 if (!SWIG_IsOK(res1)) {
11482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11483 }
11484 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11485 }
11486 if (obj1) {
11487 ecode2 = SWIG_AsVal_int(obj1, &val2);
11488 if (!SWIG_IsOK(ecode2)) {
11489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11490 }
11491 arg2 = static_cast< int >(val2);
11492 }
11493 {
11494 if (!wxPyCheckForApp()) SWIG_fail;
11495 PyThreadState* __tstate = wxPyBeginAllowThreads();
11496 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11497 wxPyEndAllowThreads(__tstate);
11498 if (PyErr_Occurred()) SWIG_fail;
11499 }
11500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11501 return resultobj;
11502 fail:
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11508 PyObject *resultobj = 0;
11509 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11510 void *argp1 = 0 ;
11511 int res1 = 0 ;
11512 PyObject *swig_obj[1] ;
11513
11514 if (!args) SWIG_fail;
11515 swig_obj[0] = args;
11516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11517 if (!SWIG_IsOK(res1)) {
11518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11519 }
11520 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11521 {
11522 PyThreadState* __tstate = wxPyBeginAllowThreads();
11523 delete arg1;
11524
11525 wxPyEndAllowThreads(__tstate);
11526 if (PyErr_Occurred()) SWIG_fail;
11527 }
11528 resultobj = SWIG_Py_Void();
11529 return resultobj;
11530 fail:
11531 return NULL;
11532 }
11533
11534
11535 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11536 PyObject *resultobj = 0;
11537 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11538 PyObject *arg2 = (PyObject *) 0 ;
11539 PyObject *arg3 = (PyObject *) 0 ;
11540 int arg4 = (int) 0 ;
11541 void *argp1 = 0 ;
11542 int res1 = 0 ;
11543 int val4 ;
11544 int ecode4 = 0 ;
11545 PyObject * obj0 = 0 ;
11546 PyObject * obj1 = 0 ;
11547 PyObject * obj2 = 0 ;
11548 PyObject * obj3 = 0 ;
11549 char * kwnames[] = {
11550 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11551 };
11552
11553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11555 if (!SWIG_IsOK(res1)) {
11556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11557 }
11558 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11559 arg2 = obj1;
11560 arg3 = obj2;
11561 if (obj3) {
11562 ecode4 = SWIG_AsVal_int(obj3, &val4);
11563 if (!SWIG_IsOK(ecode4)) {
11564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11565 }
11566 arg4 = static_cast< int >(val4);
11567 }
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 resultobj = SWIG_Py_Void();
11575 return resultobj;
11576 fail:
11577 return NULL;
11578 }
11579
11580
11581 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11582 PyObject *resultobj = 0;
11583 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11584 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11585 int arg3 = (int) wxID_ANY ;
11586 void *argp1 = 0 ;
11587 int res1 = 0 ;
11588 void *argp2 = 0 ;
11589 int res2 = 0 ;
11590 int val3 ;
11591 int ecode3 = 0 ;
11592 PyObject * obj0 = 0 ;
11593 PyObject * obj1 = 0 ;
11594 PyObject * obj2 = 0 ;
11595 char * kwnames[] = {
11596 (char *) "self",(char *) "owner",(char *) "id", NULL
11597 };
11598
11599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11601 if (!SWIG_IsOK(res1)) {
11602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11603 }
11604 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11605 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11606 if (!SWIG_IsOK(res2)) {
11607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11608 }
11609 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11610 if (obj2) {
11611 ecode3 = SWIG_AsVal_int(obj2, &val3);
11612 if (!SWIG_IsOK(ecode3)) {
11613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11614 }
11615 arg3 = static_cast< int >(val3);
11616 }
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 (arg1)->SetOwner(arg2,arg3);
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 resultobj = SWIG_Py_Void();
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11631 PyObject *resultobj = 0;
11632 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11633 wxEvtHandler *result = 0 ;
11634 void *argp1 = 0 ;
11635 int res1 = 0 ;
11636 PyObject *swig_obj[1] ;
11637
11638 if (!args) SWIG_fail;
11639 swig_obj[0] = args;
11640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11641 if (!SWIG_IsOK(res1)) {
11642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11643 }
11644 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11645 {
11646 PyThreadState* __tstate = wxPyBeginAllowThreads();
11647 result = (wxEvtHandler *)(arg1)->GetOwner();
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 {
11652 resultobj = wxPyMake_wxObject(result, 0);
11653 }
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11661 PyObject *resultobj = 0;
11662 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11663 int arg2 = (int) -1 ;
11664 bool arg3 = (bool) false ;
11665 bool result;
11666 void *argp1 = 0 ;
11667 int res1 = 0 ;
11668 int val2 ;
11669 int ecode2 = 0 ;
11670 bool val3 ;
11671 int ecode3 = 0 ;
11672 PyObject * obj0 = 0 ;
11673 PyObject * obj1 = 0 ;
11674 PyObject * obj2 = 0 ;
11675 char * kwnames[] = {
11676 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11677 };
11678
11679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11681 if (!SWIG_IsOK(res1)) {
11682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11683 }
11684 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11685 if (obj1) {
11686 ecode2 = SWIG_AsVal_int(obj1, &val2);
11687 if (!SWIG_IsOK(ecode2)) {
11688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11689 }
11690 arg2 = static_cast< int >(val2);
11691 }
11692 if (obj2) {
11693 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11694 if (!SWIG_IsOK(ecode3)) {
11695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11696 }
11697 arg3 = static_cast< bool >(val3);
11698 }
11699 {
11700 PyThreadState* __tstate = wxPyBeginAllowThreads();
11701 result = (bool)(arg1)->Start(arg2,arg3);
11702 wxPyEndAllowThreads(__tstate);
11703 if (PyErr_Occurred()) SWIG_fail;
11704 }
11705 {
11706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11707 }
11708 return resultobj;
11709 fail:
11710 return NULL;
11711 }
11712
11713
11714 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11715 PyObject *resultobj = 0;
11716 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11717 void *argp1 = 0 ;
11718 int res1 = 0 ;
11719 PyObject *swig_obj[1] ;
11720
11721 if (!args) SWIG_fail;
11722 swig_obj[0] = args;
11723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11724 if (!SWIG_IsOK(res1)) {
11725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11726 }
11727 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11728 {
11729 PyThreadState* __tstate = wxPyBeginAllowThreads();
11730 (arg1)->Stop();
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 resultobj = SWIG_Py_Void();
11735 return resultobj;
11736 fail:
11737 return NULL;
11738 }
11739
11740
11741 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11742 PyObject *resultobj = 0;
11743 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11744 void *argp1 = 0 ;
11745 int res1 = 0 ;
11746 PyObject *swig_obj[1] ;
11747
11748 if (!args) SWIG_fail;
11749 swig_obj[0] = args;
11750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11751 if (!SWIG_IsOK(res1)) {
11752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11753 }
11754 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11755 {
11756 PyThreadState* __tstate = wxPyBeginAllowThreads();
11757 (arg1)->Notify();
11758 wxPyEndAllowThreads(__tstate);
11759 if (PyErr_Occurred()) SWIG_fail;
11760 }
11761 resultobj = SWIG_Py_Void();
11762 return resultobj;
11763 fail:
11764 return NULL;
11765 }
11766
11767
11768 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11769 PyObject *resultobj = 0;
11770 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11771 bool result;
11772 void *argp1 = 0 ;
11773 int res1 = 0 ;
11774 PyObject *swig_obj[1] ;
11775
11776 if (!args) SWIG_fail;
11777 swig_obj[0] = args;
11778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11779 if (!SWIG_IsOK(res1)) {
11780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11781 }
11782 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11786 wxPyEndAllowThreads(__tstate);
11787 if (PyErr_Occurred()) SWIG_fail;
11788 }
11789 {
11790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11791 }
11792 return resultobj;
11793 fail:
11794 return NULL;
11795 }
11796
11797
11798 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11799 PyObject *resultobj = 0;
11800 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11801 int result;
11802 void *argp1 = 0 ;
11803 int res1 = 0 ;
11804 PyObject *swig_obj[1] ;
11805
11806 if (!args) SWIG_fail;
11807 swig_obj[0] = args;
11808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11809 if (!SWIG_IsOK(res1)) {
11810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11811 }
11812 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11816 wxPyEndAllowThreads(__tstate);
11817 if (PyErr_Occurred()) SWIG_fail;
11818 }
11819 resultobj = SWIG_From_int(static_cast< int >(result));
11820 return resultobj;
11821 fail:
11822 return NULL;
11823 }
11824
11825
11826 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11827 PyObject *resultobj = 0;
11828 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11829 int result;
11830 void *argp1 = 0 ;
11831 int res1 = 0 ;
11832 PyObject *swig_obj[1] ;
11833
11834 if (!args) SWIG_fail;
11835 swig_obj[0] = args;
11836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11837 if (!SWIG_IsOK(res1)) {
11838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11839 }
11840 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11841 {
11842 PyThreadState* __tstate = wxPyBeginAllowThreads();
11843 result = (int)((wxPyTimer const *)arg1)->GetId();
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 resultobj = SWIG_From_int(static_cast< int >(result));
11848 return resultobj;
11849 fail:
11850 return NULL;
11851 }
11852
11853
11854 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11855 PyObject *resultobj = 0;
11856 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11857 bool result;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 PyObject *swig_obj[1] ;
11861
11862 if (!args) SWIG_fail;
11863 swig_obj[0] = args;
11864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11865 if (!SWIG_IsOK(res1)) {
11866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11867 }
11868 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11877 }
11878 return resultobj;
11879 fail:
11880 return NULL;
11881 }
11882
11883
11884 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11885 PyObject *obj;
11886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11887 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11888 return SWIG_Py_Void();
11889 }
11890
11891 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11892 return SWIG_Python_InitShadowInstance(args);
11893 }
11894
11895 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11896 PyObject *resultobj = 0;
11897 int arg1 = (int) 0 ;
11898 int arg2 = (int) 0 ;
11899 wxTimerEvent *result = 0 ;
11900 int val1 ;
11901 int ecode1 = 0 ;
11902 int val2 ;
11903 int ecode2 = 0 ;
11904 PyObject * obj0 = 0 ;
11905 PyObject * obj1 = 0 ;
11906 char * kwnames[] = {
11907 (char *) "timerid",(char *) "interval", NULL
11908 };
11909
11910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11911 if (obj0) {
11912 ecode1 = SWIG_AsVal_int(obj0, &val1);
11913 if (!SWIG_IsOK(ecode1)) {
11914 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11915 }
11916 arg1 = static_cast< int >(val1);
11917 }
11918 if (obj1) {
11919 ecode2 = SWIG_AsVal_int(obj1, &val2);
11920 if (!SWIG_IsOK(ecode2)) {
11921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11922 }
11923 arg2 = static_cast< int >(val2);
11924 }
11925 {
11926 PyThreadState* __tstate = wxPyBeginAllowThreads();
11927 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11928 wxPyEndAllowThreads(__tstate);
11929 if (PyErr_Occurred()) SWIG_fail;
11930 }
11931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11932 return resultobj;
11933 fail:
11934 return NULL;
11935 }
11936
11937
11938 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11939 PyObject *resultobj = 0;
11940 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11941 int result;
11942 void *argp1 = 0 ;
11943 int res1 = 0 ;
11944 PyObject *swig_obj[1] ;
11945
11946 if (!args) SWIG_fail;
11947 swig_obj[0] = args;
11948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11949 if (!SWIG_IsOK(res1)) {
11950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11951 }
11952 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11953 {
11954 PyThreadState* __tstate = wxPyBeginAllowThreads();
11955 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11956 wxPyEndAllowThreads(__tstate);
11957 if (PyErr_Occurred()) SWIG_fail;
11958 }
11959 resultobj = SWIG_From_int(static_cast< int >(result));
11960 return resultobj;
11961 fail:
11962 return NULL;
11963 }
11964
11965
11966 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11967 PyObject *obj;
11968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11969 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11970 return SWIG_Py_Void();
11971 }
11972
11973 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11974 return SWIG_Python_InitShadowInstance(args);
11975 }
11976
11977 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11978 PyObject *resultobj = 0;
11979 wxTimer *arg1 = 0 ;
11980 wxTimerRunner *result = 0 ;
11981 void *argp1 = 0 ;
11982 int res1 = 0 ;
11983
11984 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11986 if (!SWIG_IsOK(res1)) {
11987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11988 }
11989 if (!argp1) {
11990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11991 }
11992 arg1 = reinterpret_cast< wxTimer * >(argp1);
11993 {
11994 if (!wxPyCheckForApp()) SWIG_fail;
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12001 return resultobj;
12002 fail:
12003 return NULL;
12004 }
12005
12006
12007 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12008 PyObject *resultobj = 0;
12009 wxTimer *arg1 = 0 ;
12010 int arg2 ;
12011 bool arg3 = (bool) false ;
12012 wxTimerRunner *result = 0 ;
12013 void *argp1 = 0 ;
12014 int res1 = 0 ;
12015 int val2 ;
12016 int ecode2 = 0 ;
12017 bool val3 ;
12018 int ecode3 = 0 ;
12019
12020 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12022 if (!SWIG_IsOK(res1)) {
12023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12024 }
12025 if (!argp1) {
12026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12027 }
12028 arg1 = reinterpret_cast< wxTimer * >(argp1);
12029 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12030 if (!SWIG_IsOK(ecode2)) {
12031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12032 }
12033 arg2 = static_cast< int >(val2);
12034 if (swig_obj[2]) {
12035 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12036 if (!SWIG_IsOK(ecode3)) {
12037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12038 }
12039 arg3 = static_cast< bool >(val3);
12040 }
12041 {
12042 if (!wxPyCheckForApp()) SWIG_fail;
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12056 int argc;
12057 PyObject *argv[4];
12058
12059 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12060 --argc;
12061 if (argc == 1) {
12062 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12063 }
12064 if ((argc >= 2) && (argc <= 3)) {
12065 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12066 }
12067
12068 fail:
12069 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12070 return NULL;
12071 }
12072
12073
12074 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12075 PyObject *resultobj = 0;
12076 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12077 void *argp1 = 0 ;
12078 int res1 = 0 ;
12079 PyObject *swig_obj[1] ;
12080
12081 if (!args) SWIG_fail;
12082 swig_obj[0] = args;
12083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12084 if (!SWIG_IsOK(res1)) {
12085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12086 }
12087 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 delete arg1;
12091
12092 wxPyEndAllowThreads(__tstate);
12093 if (PyErr_Occurred()) SWIG_fail;
12094 }
12095 resultobj = SWIG_Py_Void();
12096 return resultobj;
12097 fail:
12098 return NULL;
12099 }
12100
12101
12102 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12103 PyObject *resultobj = 0;
12104 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12105 int arg2 ;
12106 bool arg3 = (bool) false ;
12107 void *argp1 = 0 ;
12108 int res1 = 0 ;
12109 int val2 ;
12110 int ecode2 = 0 ;
12111 bool val3 ;
12112 int ecode3 = 0 ;
12113 PyObject * obj0 = 0 ;
12114 PyObject * obj1 = 0 ;
12115 PyObject * obj2 = 0 ;
12116 char * kwnames[] = {
12117 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12118 };
12119
12120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12122 if (!SWIG_IsOK(res1)) {
12123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12124 }
12125 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12126 ecode2 = SWIG_AsVal_int(obj1, &val2);
12127 if (!SWIG_IsOK(ecode2)) {
12128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12129 }
12130 arg2 = static_cast< int >(val2);
12131 if (obj2) {
12132 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12133 if (!SWIG_IsOK(ecode3)) {
12134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12135 }
12136 arg3 = static_cast< bool >(val3);
12137 }
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 (arg1)->Start(arg2,arg3);
12141 wxPyEndAllowThreads(__tstate);
12142 if (PyErr_Occurred()) SWIG_fail;
12143 }
12144 resultobj = SWIG_Py_Void();
12145 return resultobj;
12146 fail:
12147 return NULL;
12148 }
12149
12150
12151 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152 PyObject *obj;
12153 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12154 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12155 return SWIG_Py_Void();
12156 }
12157
12158 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12159 return SWIG_Python_InitShadowInstance(args);
12160 }
12161
12162 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12163 PyObject *resultobj = 0;
12164 wxLog *result = 0 ;
12165
12166 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (wxLog *)new wxLog();
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12181 PyObject *resultobj = 0;
12182 wxLog *arg1 = (wxLog *) 0 ;
12183 void *argp1 = 0 ;
12184 int res1 = 0 ;
12185 PyObject *swig_obj[1] ;
12186
12187 if (!args) SWIG_fail;
12188 swig_obj[0] = args;
12189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12190 if (!SWIG_IsOK(res1)) {
12191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12192 }
12193 arg1 = reinterpret_cast< wxLog * >(argp1);
12194 {
12195 PyThreadState* __tstate = wxPyBeginAllowThreads();
12196 delete arg1;
12197
12198 wxPyEndAllowThreads(__tstate);
12199 if (PyErr_Occurred()) SWIG_fail;
12200 }
12201 resultobj = SWIG_Py_Void();
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12209 PyObject *resultobj = 0;
12210 bool result;
12211
12212 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12213 {
12214 PyThreadState* __tstate = wxPyBeginAllowThreads();
12215 result = (bool)wxLog::IsEnabled();
12216 wxPyEndAllowThreads(__tstate);
12217 if (PyErr_Occurred()) SWIG_fail;
12218 }
12219 {
12220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12221 }
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj = 0;
12230 bool arg1 = (bool) true ;
12231 bool result;
12232 bool val1 ;
12233 int ecode1 = 0 ;
12234 PyObject * obj0 = 0 ;
12235 char * kwnames[] = {
12236 (char *) "doIt", NULL
12237 };
12238
12239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12240 if (obj0) {
12241 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12242 if (!SWIG_IsOK(ecode1)) {
12243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12244 }
12245 arg1 = static_cast< bool >(val1);
12246 }
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 result = (bool)wxLog::EnableLogging(arg1);
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 {
12254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12255 }
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj = 0;
12264 wxLogLevel arg1 ;
12265 wxChar *arg2 = (wxChar *) 0 ;
12266 time_t arg3 ;
12267 unsigned long val1 ;
12268 int ecode1 = 0 ;
12269 void *argp2 = 0 ;
12270 int res2 = 0 ;
12271 unsigned int val3 ;
12272 int ecode3 = 0 ;
12273 PyObject * obj0 = 0 ;
12274 PyObject * obj1 = 0 ;
12275 PyObject * obj2 = 0 ;
12276 char * kwnames[] = {
12277 (char *) "level",(char *) "szString",(char *) "t", NULL
12278 };
12279
12280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12281 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12282 if (!SWIG_IsOK(ecode1)) {
12283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12284 }
12285 arg1 = static_cast< wxLogLevel >(val1);
12286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12287 if (!SWIG_IsOK(res2)) {
12288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12289 }
12290 arg2 = reinterpret_cast< wxChar * >(argp2);
12291 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12292 if (!SWIG_IsOK(ecode3)) {
12293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12294 }
12295 arg3 = static_cast< time_t >(val3);
12296 {
12297 PyThreadState* __tstate = wxPyBeginAllowThreads();
12298 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 resultobj = SWIG_Py_Void();
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12310 PyObject *resultobj = 0;
12311 wxLog *arg1 = (wxLog *) 0 ;
12312 void *argp1 = 0 ;
12313 int res1 = 0 ;
12314 PyObject *swig_obj[1] ;
12315
12316 if (!args) SWIG_fail;
12317 swig_obj[0] = args;
12318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12319 if (!SWIG_IsOK(res1)) {
12320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12321 }
12322 arg1 = reinterpret_cast< wxLog * >(argp1);
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 (arg1)->Flush();
12326 wxPyEndAllowThreads(__tstate);
12327 if (PyErr_Occurred()) SWIG_fail;
12328 }
12329 resultobj = SWIG_Py_Void();
12330 return resultobj;
12331 fail:
12332 return NULL;
12333 }
12334
12335
12336 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12337 PyObject *resultobj = 0;
12338
12339 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 wxLog::FlushActive();
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 resultobj = SWIG_Py_Void();
12347 return resultobj;
12348 fail:
12349 return NULL;
12350 }
12351
12352
12353 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12354 PyObject *resultobj = 0;
12355 wxLog *result = 0 ;
12356
12357 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12358 {
12359 PyThreadState* __tstate = wxPyBeginAllowThreads();
12360 result = (wxLog *)wxLog::GetActiveTarget();
12361 wxPyEndAllowThreads(__tstate);
12362 if (PyErr_Occurred()) SWIG_fail;
12363 }
12364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12372 PyObject *resultobj = 0;
12373 wxLog *arg1 = (wxLog *) 0 ;
12374 wxLog *result = 0 ;
12375 int res1 = 0 ;
12376 PyObject * obj0 = 0 ;
12377 char * kwnames[] = {
12378 (char *) "pLogger", NULL
12379 };
12380
12381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12382 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12383 if (!SWIG_IsOK(res1)) {
12384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12385 }
12386 {
12387 PyThreadState* __tstate = wxPyBeginAllowThreads();
12388 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12393 return resultobj;
12394 fail:
12395 return NULL;
12396 }
12397
12398
12399 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12400 PyObject *resultobj = 0;
12401
12402 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12403 {
12404 PyThreadState* __tstate = wxPyBeginAllowThreads();
12405 wxLog::Suspend();
12406 wxPyEndAllowThreads(__tstate);
12407 if (PyErr_Occurred()) SWIG_fail;
12408 }
12409 resultobj = SWIG_Py_Void();
12410 return resultobj;
12411 fail:
12412 return NULL;
12413 }
12414
12415
12416 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12417 PyObject *resultobj = 0;
12418
12419 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 wxLog::Resume();
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 resultobj = SWIG_Py_Void();
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj = 0;
12435 bool arg1 = (bool) true ;
12436 bool val1 ;
12437 int ecode1 = 0 ;
12438 PyObject * obj0 = 0 ;
12439 char * kwnames[] = {
12440 (char *) "bVerbose", NULL
12441 };
12442
12443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12444 if (obj0) {
12445 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12446 if (!SWIG_IsOK(ecode1)) {
12447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12448 }
12449 arg1 = static_cast< bool >(val1);
12450 }
12451 {
12452 PyThreadState* __tstate = wxPyBeginAllowThreads();
12453 wxLog::SetVerbose(arg1);
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 resultobj = SWIG_Py_Void();
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12465 PyObject *resultobj = 0;
12466 wxLogLevel arg1 ;
12467 unsigned long val1 ;
12468 int ecode1 = 0 ;
12469 PyObject * obj0 = 0 ;
12470 char * kwnames[] = {
12471 (char *) "logLevel", NULL
12472 };
12473
12474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12475 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12476 if (!SWIG_IsOK(ecode1)) {
12477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12478 }
12479 arg1 = static_cast< wxLogLevel >(val1);
12480 {
12481 PyThreadState* __tstate = wxPyBeginAllowThreads();
12482 wxLog::SetLogLevel(arg1);
12483 wxPyEndAllowThreads(__tstate);
12484 if (PyErr_Occurred()) SWIG_fail;
12485 }
12486 resultobj = SWIG_Py_Void();
12487 return resultobj;
12488 fail:
12489 return NULL;
12490 }
12491
12492
12493 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12494 PyObject *resultobj = 0;
12495
12496 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12497 {
12498 PyThreadState* __tstate = wxPyBeginAllowThreads();
12499 wxLog::DontCreateOnDemand();
12500 wxPyEndAllowThreads(__tstate);
12501 if (PyErr_Occurred()) SWIG_fail;
12502 }
12503 resultobj = SWIG_Py_Void();
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12511 PyObject *resultobj = 0;
12512 bool arg1 = (bool) true ;
12513 bool val1 ;
12514 int ecode1 = 0 ;
12515 PyObject * obj0 = 0 ;
12516 char * kwnames[] = {
12517 (char *) "bRepetCounting", NULL
12518 };
12519
12520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12521 if (obj0) {
12522 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12523 if (!SWIG_IsOK(ecode1)) {
12524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12525 }
12526 arg1 = static_cast< bool >(val1);
12527 }
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 wxLog::SetRepetitionCounting(arg1);
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 resultobj = SWIG_Py_Void();
12535 return resultobj;
12536 fail:
12537 return NULL;
12538 }
12539
12540
12541 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12542 PyObject *resultobj = 0;
12543 bool result;
12544
12545 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12546 {
12547 PyThreadState* __tstate = wxPyBeginAllowThreads();
12548 result = (bool)wxLog::GetRepetitionCounting();
12549 wxPyEndAllowThreads(__tstate);
12550 if (PyErr_Occurred()) SWIG_fail;
12551 }
12552 {
12553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12554 }
12555 return resultobj;
12556 fail:
12557 return NULL;
12558 }
12559
12560
12561 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12562 PyObject *resultobj = 0;
12563 wxTraceMask arg1 ;
12564 unsigned long val1 ;
12565 int ecode1 = 0 ;
12566 PyObject * obj0 = 0 ;
12567 char * kwnames[] = {
12568 (char *) "ulMask", NULL
12569 };
12570
12571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12572 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12573 if (!SWIG_IsOK(ecode1)) {
12574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12575 }
12576 arg1 = static_cast< wxTraceMask >(val1);
12577 {
12578 PyThreadState* __tstate = wxPyBeginAllowThreads();
12579 wxLog::SetTraceMask(arg1);
12580 wxPyEndAllowThreads(__tstate);
12581 if (PyErr_Occurred()) SWIG_fail;
12582 }
12583 resultobj = SWIG_Py_Void();
12584 return resultobj;
12585 fail:
12586 return NULL;
12587 }
12588
12589
12590 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12591 PyObject *resultobj = 0;
12592 wxString *arg1 = 0 ;
12593 bool temp1 = false ;
12594 PyObject * obj0 = 0 ;
12595 char * kwnames[] = {
12596 (char *) "str", NULL
12597 };
12598
12599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12600 {
12601 arg1 = wxString_in_helper(obj0);
12602 if (arg1 == NULL) SWIG_fail;
12603 temp1 = true;
12604 }
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 wxLog::AddTraceMask((wxString const &)*arg1);
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 resultobj = SWIG_Py_Void();
12612 {
12613 if (temp1)
12614 delete arg1;
12615 }
12616 return resultobj;
12617 fail:
12618 {
12619 if (temp1)
12620 delete arg1;
12621 }
12622 return NULL;
12623 }
12624
12625
12626 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj = 0;
12628 wxString *arg1 = 0 ;
12629 bool temp1 = false ;
12630 PyObject * obj0 = 0 ;
12631 char * kwnames[] = {
12632 (char *) "str", NULL
12633 };
12634
12635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12636 {
12637 arg1 = wxString_in_helper(obj0);
12638 if (arg1 == NULL) SWIG_fail;
12639 temp1 = true;
12640 }
12641 {
12642 PyThreadState* __tstate = wxPyBeginAllowThreads();
12643 wxLog::RemoveTraceMask((wxString const &)*arg1);
12644 wxPyEndAllowThreads(__tstate);
12645 if (PyErr_Occurred()) SWIG_fail;
12646 }
12647 resultobj = SWIG_Py_Void();
12648 {
12649 if (temp1)
12650 delete arg1;
12651 }
12652 return resultobj;
12653 fail:
12654 {
12655 if (temp1)
12656 delete arg1;
12657 }
12658 return NULL;
12659 }
12660
12661
12662 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12663 PyObject *resultobj = 0;
12664
12665 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 wxLog::ClearTraceMasks();
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 resultobj = SWIG_Py_Void();
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680 PyObject *resultobj = 0;
12681 wxArrayString *result = 0 ;
12682
12683 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 {
12687 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12688 result = (wxArrayString *) &_result_ref;
12689 }
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 {
12694 resultobj = wxArrayString2PyList_helper(*result);
12695 }
12696 return resultobj;
12697 fail:
12698 return NULL;
12699 }
12700
12701
12702 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12703 PyObject *resultobj = 0;
12704 wxChar *arg1 = (wxChar *) 0 ;
12705 void *argp1 = 0 ;
12706 int res1 = 0 ;
12707 PyObject * obj0 = 0 ;
12708 char * kwnames[] = {
12709 (char *) "ts", NULL
12710 };
12711
12712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12714 if (!SWIG_IsOK(res1)) {
12715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12716 }
12717 arg1 = reinterpret_cast< wxChar * >(argp1);
12718 {
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 wxLog::SetTimestamp((wxChar const *)arg1);
12721 wxPyEndAllowThreads(__tstate);
12722 if (PyErr_Occurred()) SWIG_fail;
12723 }
12724 resultobj = SWIG_Py_Void();
12725 return resultobj;
12726 fail:
12727 return NULL;
12728 }
12729
12730
12731 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12732 PyObject *resultobj = 0;
12733 bool result;
12734
12735 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (bool)wxLog::GetVerbose();
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 {
12743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12744 }
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 wxTraceMask result;
12754
12755 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12756 {
12757 PyThreadState* __tstate = wxPyBeginAllowThreads();
12758 result = (wxTraceMask)wxLog::GetTraceMask();
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12763 return resultobj;
12764 fail:
12765 return NULL;
12766 }
12767
12768
12769 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12770 PyObject *resultobj = 0;
12771 wxChar *arg1 = (wxChar *) 0 ;
12772 bool result;
12773 void *argp1 = 0 ;
12774 int res1 = 0 ;
12775 PyObject * obj0 = 0 ;
12776 char * kwnames[] = {
12777 (char *) "mask", NULL
12778 };
12779
12780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12782 if (!SWIG_IsOK(res1)) {
12783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12784 }
12785 arg1 = reinterpret_cast< wxChar * >(argp1);
12786 {
12787 PyThreadState* __tstate = wxPyBeginAllowThreads();
12788 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12789 wxPyEndAllowThreads(__tstate);
12790 if (PyErr_Occurred()) SWIG_fail;
12791 }
12792 {
12793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12794 }
12795 return resultobj;
12796 fail:
12797 return NULL;
12798 }
12799
12800
12801 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12802 PyObject *resultobj = 0;
12803 wxLogLevel result;
12804
12805 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = (wxLogLevel)wxLog::GetLogLevel();
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12820 PyObject *resultobj = 0;
12821 wxChar *result = 0 ;
12822
12823 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12824 {
12825 PyThreadState* __tstate = wxPyBeginAllowThreads();
12826 result = (wxChar *)wxLog::GetTimestamp();
12827 wxPyEndAllowThreads(__tstate);
12828 if (PyErr_Occurred()) SWIG_fail;
12829 }
12830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12831 return resultobj;
12832 fail:
12833 return NULL;
12834 }
12835
12836
12837 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12838 PyObject *resultobj = 0;
12839 wxString result;
12840
12841 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = wxLog_TimeStamp();
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 {
12849 #if wxUSE_UNICODE
12850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12851 #else
12852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12853 #endif
12854 }
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12862 PyObject *resultobj = 0;
12863 wxLog *arg1 = (wxLog *) 0 ;
12864 void *argp1 = 0 ;
12865 int res1 = 0 ;
12866 PyObject *swig_obj[1] ;
12867
12868 if (!args) SWIG_fail;
12869 swig_obj[0] = args;
12870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12871 if (!SWIG_IsOK(res1)) {
12872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12873 }
12874 arg1 = reinterpret_cast< wxLog * >(argp1);
12875 {
12876 PyThreadState* __tstate = wxPyBeginAllowThreads();
12877 wxLog_Destroy(arg1);
12878 wxPyEndAllowThreads(__tstate);
12879 if (PyErr_Occurred()) SWIG_fail;
12880 }
12881 resultobj = SWIG_Py_Void();
12882 return resultobj;
12883 fail:
12884 return NULL;
12885 }
12886
12887
12888 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12889 PyObject *obj;
12890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12891 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12892 return SWIG_Py_Void();
12893 }
12894
12895 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12896 return SWIG_Python_InitShadowInstance(args);
12897 }
12898
12899 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12900 PyObject *resultobj = 0;
12901 wxLogStderr *result = 0 ;
12902
12903 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12904 {
12905 PyThreadState* __tstate = wxPyBeginAllowThreads();
12906 result = (wxLogStderr *)new wxLogStderr();
12907 wxPyEndAllowThreads(__tstate);
12908 if (PyErr_Occurred()) SWIG_fail;
12909 }
12910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12911 return resultobj;
12912 fail:
12913 return NULL;
12914 }
12915
12916
12917 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12918 PyObject *obj;
12919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12920 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12921 return SWIG_Py_Void();
12922 }
12923
12924 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12925 return SWIG_Python_InitShadowInstance(args);
12926 }
12927
12928 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12929 PyObject *resultobj = 0;
12930 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12931 wxLogTextCtrl *result = 0 ;
12932 void *argp1 = 0 ;
12933 int res1 = 0 ;
12934 PyObject * obj0 = 0 ;
12935 char * kwnames[] = {
12936 (char *) "pTextCtrl", NULL
12937 };
12938
12939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12941 if (!SWIG_IsOK(res1)) {
12942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12943 }
12944 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12948 wxPyEndAllowThreads(__tstate);
12949 if (PyErr_Occurred()) SWIG_fail;
12950 }
12951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12952 return resultobj;
12953 fail:
12954 return NULL;
12955 }
12956
12957
12958 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12959 PyObject *obj;
12960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12961 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12962 return SWIG_Py_Void();
12963 }
12964
12965 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12966 return SWIG_Python_InitShadowInstance(args);
12967 }
12968
12969 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12970 PyObject *resultobj = 0;
12971 wxLogGui *result = 0 ;
12972
12973 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12974 {
12975 PyThreadState* __tstate = wxPyBeginAllowThreads();
12976 result = (wxLogGui *)new wxLogGui();
12977 wxPyEndAllowThreads(__tstate);
12978 if (PyErr_Occurred()) SWIG_fail;
12979 }
12980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12981 return resultobj;
12982 fail:
12983 return NULL;
12984 }
12985
12986
12987 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12988 PyObject *obj;
12989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12990 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12991 return SWIG_Py_Void();
12992 }
12993
12994 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12995 return SWIG_Python_InitShadowInstance(args);
12996 }
12997
12998 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12999 PyObject *resultobj = 0;
13000 wxFrame *arg1 = (wxFrame *) 0 ;
13001 wxString *arg2 = 0 ;
13002 bool arg3 = (bool) true ;
13003 bool arg4 = (bool) true ;
13004 wxLogWindow *result = 0 ;
13005 void *argp1 = 0 ;
13006 int res1 = 0 ;
13007 bool temp2 = false ;
13008 bool val3 ;
13009 int ecode3 = 0 ;
13010 bool val4 ;
13011 int ecode4 = 0 ;
13012 PyObject * obj0 = 0 ;
13013 PyObject * obj1 = 0 ;
13014 PyObject * obj2 = 0 ;
13015 PyObject * obj3 = 0 ;
13016 char * kwnames[] = {
13017 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13018 };
13019
13020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13022 if (!SWIG_IsOK(res1)) {
13023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13024 }
13025 arg1 = reinterpret_cast< wxFrame * >(argp1);
13026 {
13027 arg2 = wxString_in_helper(obj1);
13028 if (arg2 == NULL) SWIG_fail;
13029 temp2 = true;
13030 }
13031 if (obj2) {
13032 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13033 if (!SWIG_IsOK(ecode3)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13035 }
13036 arg3 = static_cast< bool >(val3);
13037 }
13038 if (obj3) {
13039 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13040 if (!SWIG_IsOK(ecode4)) {
13041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13042 }
13043 arg4 = static_cast< bool >(val4);
13044 }
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13052 {
13053 if (temp2)
13054 delete arg2;
13055 }
13056 return resultobj;
13057 fail:
13058 {
13059 if (temp2)
13060 delete arg2;
13061 }
13062 return NULL;
13063 }
13064
13065
13066 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13067 PyObject *resultobj = 0;
13068 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13069 bool arg2 = (bool) true ;
13070 void *argp1 = 0 ;
13071 int res1 = 0 ;
13072 bool val2 ;
13073 int ecode2 = 0 ;
13074 PyObject * obj0 = 0 ;
13075 PyObject * obj1 = 0 ;
13076 char * kwnames[] = {
13077 (char *) "self",(char *) "bShow", NULL
13078 };
13079
13080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13082 if (!SWIG_IsOK(res1)) {
13083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13084 }
13085 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13086 if (obj1) {
13087 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13088 if (!SWIG_IsOK(ecode2)) {
13089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13090 }
13091 arg2 = static_cast< bool >(val2);
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 (arg1)->Show(arg2);
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 resultobj = SWIG_Py_Void();
13100 return resultobj;
13101 fail:
13102 return NULL;
13103 }
13104
13105
13106 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13107 PyObject *resultobj = 0;
13108 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13109 wxFrame *result = 0 ;
13110 void *argp1 = 0 ;
13111 int res1 = 0 ;
13112 PyObject *swig_obj[1] ;
13113
13114 if (!args) SWIG_fail;
13115 swig_obj[0] = args;
13116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13117 if (!SWIG_IsOK(res1)) {
13118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13119 }
13120 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 {
13128 resultobj = wxPyMake_wxObject(result, (bool)0);
13129 }
13130 return resultobj;
13131 fail:
13132 return NULL;
13133 }
13134
13135
13136 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13137 PyObject *resultobj = 0;
13138 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13139 wxLog *result = 0 ;
13140 void *argp1 = 0 ;
13141 int res1 = 0 ;
13142 PyObject *swig_obj[1] ;
13143
13144 if (!args) SWIG_fail;
13145 swig_obj[0] = args;
13146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13147 if (!SWIG_IsOK(res1)) {
13148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13149 }
13150 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13154 wxPyEndAllowThreads(__tstate);
13155 if (PyErr_Occurred()) SWIG_fail;
13156 }
13157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13158 return resultobj;
13159 fail:
13160 return NULL;
13161 }
13162
13163
13164 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13165 PyObject *resultobj = 0;
13166 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13167 bool result;
13168 void *argp1 = 0 ;
13169 int res1 = 0 ;
13170 PyObject *swig_obj[1] ;
13171
13172 if (!args) SWIG_fail;
13173 swig_obj[0] = args;
13174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13175 if (!SWIG_IsOK(res1)) {
13176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13177 }
13178 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13179 {
13180 PyThreadState* __tstate = wxPyBeginAllowThreads();
13181 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13182 wxPyEndAllowThreads(__tstate);
13183 if (PyErr_Occurred()) SWIG_fail;
13184 }
13185 {
13186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13187 }
13188 return resultobj;
13189 fail:
13190 return NULL;
13191 }
13192
13193
13194 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13195 PyObject *resultobj = 0;
13196 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13197 bool arg2 ;
13198 void *argp1 = 0 ;
13199 int res1 = 0 ;
13200 bool val2 ;
13201 int ecode2 = 0 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 char * kwnames[] = {
13205 (char *) "self",(char *) "bDoPass", NULL
13206 };
13207
13208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13210 if (!SWIG_IsOK(res1)) {
13211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13212 }
13213 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13214 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13215 if (!SWIG_IsOK(ecode2)) {
13216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13217 }
13218 arg2 = static_cast< bool >(val2);
13219 {
13220 PyThreadState* __tstate = wxPyBeginAllowThreads();
13221 (arg1)->PassMessages(arg2);
13222 wxPyEndAllowThreads(__tstate);
13223 if (PyErr_Occurred()) SWIG_fail;
13224 }
13225 resultobj = SWIG_Py_Void();
13226 return resultobj;
13227 fail:
13228 return NULL;
13229 }
13230
13231
13232 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13233 PyObject *obj;
13234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13235 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13236 return SWIG_Py_Void();
13237 }
13238
13239 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13240 return SWIG_Python_InitShadowInstance(args);
13241 }
13242
13243 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13244 PyObject *resultobj = 0;
13245 wxLog *arg1 = (wxLog *) 0 ;
13246 wxLogChain *result = 0 ;
13247 void *argp1 = 0 ;
13248 int res1 = 0 ;
13249 PyObject * obj0 = 0 ;
13250 char * kwnames[] = {
13251 (char *) "logger", NULL
13252 };
13253
13254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13256 if (!SWIG_IsOK(res1)) {
13257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13258 }
13259 arg1 = reinterpret_cast< wxLog * >(argp1);
13260 {
13261 PyThreadState* __tstate = wxPyBeginAllowThreads();
13262 result = (wxLogChain *)new wxLogChain(arg1);
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13267 return resultobj;
13268 fail:
13269 return NULL;
13270 }
13271
13272
13273 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13274 PyObject *resultobj = 0;
13275 wxLogChain *arg1 = (wxLogChain *) 0 ;
13276 wxLog *arg2 = (wxLog *) 0 ;
13277 void *argp1 = 0 ;
13278 int res1 = 0 ;
13279 void *argp2 = 0 ;
13280 int res2 = 0 ;
13281 PyObject * obj0 = 0 ;
13282 PyObject * obj1 = 0 ;
13283 char * kwnames[] = {
13284 (char *) "self",(char *) "logger", NULL
13285 };
13286
13287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13289 if (!SWIG_IsOK(res1)) {
13290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13291 }
13292 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13294 if (!SWIG_IsOK(res2)) {
13295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13296 }
13297 arg2 = reinterpret_cast< wxLog * >(argp2);
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 (arg1)->SetLog(arg2);
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 resultobj = SWIG_Py_Void();
13305 return resultobj;
13306 fail:
13307 return NULL;
13308 }
13309
13310
13311 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13312 PyObject *resultobj = 0;
13313 wxLogChain *arg1 = (wxLogChain *) 0 ;
13314 bool arg2 ;
13315 void *argp1 = 0 ;
13316 int res1 = 0 ;
13317 bool val2 ;
13318 int ecode2 = 0 ;
13319 PyObject * obj0 = 0 ;
13320 PyObject * obj1 = 0 ;
13321 char * kwnames[] = {
13322 (char *) "self",(char *) "bDoPass", NULL
13323 };
13324
13325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13327 if (!SWIG_IsOK(res1)) {
13328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13329 }
13330 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13331 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13332 if (!SWIG_IsOK(ecode2)) {
13333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13334 }
13335 arg2 = static_cast< bool >(val2);
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 (arg1)->PassMessages(arg2);
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 resultobj = SWIG_Py_Void();
13343 return resultobj;
13344 fail:
13345 return NULL;
13346 }
13347
13348
13349 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13350 PyObject *resultobj = 0;
13351 wxLogChain *arg1 = (wxLogChain *) 0 ;
13352 bool result;
13353 void *argp1 = 0 ;
13354 int res1 = 0 ;
13355 PyObject *swig_obj[1] ;
13356
13357 if (!args) SWIG_fail;
13358 swig_obj[0] = args;
13359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13360 if (!SWIG_IsOK(res1)) {
13361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13362 }
13363 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13364 {
13365 PyThreadState* __tstate = wxPyBeginAllowThreads();
13366 result = (bool)(arg1)->IsPassingMessages();
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 {
13371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13372 }
13373 return resultobj;
13374 fail:
13375 return NULL;
13376 }
13377
13378
13379 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13380 PyObject *resultobj = 0;
13381 wxLogChain *arg1 = (wxLogChain *) 0 ;
13382 wxLog *result = 0 ;
13383 void *argp1 = 0 ;
13384 int res1 = 0 ;
13385 PyObject *swig_obj[1] ;
13386
13387 if (!args) SWIG_fail;
13388 swig_obj[0] = args;
13389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13390 if (!SWIG_IsOK(res1)) {
13391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13392 }
13393 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13394 {
13395 PyThreadState* __tstate = wxPyBeginAllowThreads();
13396 result = (wxLog *)(arg1)->GetOldLog();
13397 wxPyEndAllowThreads(__tstate);
13398 if (PyErr_Occurred()) SWIG_fail;
13399 }
13400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13401 return resultobj;
13402 fail:
13403 return NULL;
13404 }
13405
13406
13407 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13408 PyObject *obj;
13409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13410 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13411 return SWIG_Py_Void();
13412 }
13413
13414 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13415 return SWIG_Python_InitShadowInstance(args);
13416 }
13417
13418 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13419 PyObject *resultobj = 0;
13420 wxLogBuffer *result = 0 ;
13421
13422 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13423 {
13424 PyThreadState* __tstate = wxPyBeginAllowThreads();
13425 result = (wxLogBuffer *)new wxLogBuffer();
13426 wxPyEndAllowThreads(__tstate);
13427 if (PyErr_Occurred()) SWIG_fail;
13428 }
13429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13430 return resultobj;
13431 fail:
13432 return NULL;
13433 }
13434
13435
13436 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13437 PyObject *resultobj = 0;
13438 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13439 wxString *result = 0 ;
13440 void *argp1 = 0 ;
13441 int res1 = 0 ;
13442 PyObject *swig_obj[1] ;
13443
13444 if (!args) SWIG_fail;
13445 swig_obj[0] = args;
13446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13447 if (!SWIG_IsOK(res1)) {
13448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13449 }
13450 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 {
13454 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13455 result = (wxString *) &_result_ref;
13456 }
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 {
13461 #if wxUSE_UNICODE
13462 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13463 #else
13464 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13465 #endif
13466 }
13467 return resultobj;
13468 fail:
13469 return NULL;
13470 }
13471
13472
13473 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13474 PyObject *obj;
13475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13476 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13477 return SWIG_Py_Void();
13478 }
13479
13480 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13481 return SWIG_Python_InitShadowInstance(args);
13482 }
13483
13484 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13485 PyObject *resultobj = 0;
13486 unsigned long result;
13487
13488 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13489 {
13490 PyThreadState* __tstate = wxPyBeginAllowThreads();
13491 result = (unsigned long)wxSysErrorCode();
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13496 return resultobj;
13497 fail:
13498 return NULL;
13499 }
13500
13501
13502 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13503 PyObject *resultobj = 0;
13504 unsigned long arg1 = (unsigned long) 0 ;
13505 wxString result;
13506 unsigned long val1 ;
13507 int ecode1 = 0 ;
13508 PyObject * obj0 = 0 ;
13509 char * kwnames[] = {
13510 (char *) "nErrCode", NULL
13511 };
13512
13513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13514 if (obj0) {
13515 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13516 if (!SWIG_IsOK(ecode1)) {
13517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13518 }
13519 arg1 = static_cast< unsigned long >(val1);
13520 }
13521 {
13522 PyThreadState* __tstate = wxPyBeginAllowThreads();
13523 result = wxSysErrorMsg(arg1);
13524 wxPyEndAllowThreads(__tstate);
13525 if (PyErr_Occurred()) SWIG_fail;
13526 }
13527 {
13528 #if wxUSE_UNICODE
13529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13530 #else
13531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13532 #endif
13533 }
13534 return resultobj;
13535 fail:
13536 return NULL;
13537 }
13538
13539
13540 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13541 PyObject *resultobj = 0;
13542 wxString *arg1 = 0 ;
13543 bool temp1 = false ;
13544 PyObject * obj0 = 0 ;
13545 char * kwnames[] = {
13546 (char *) "msg", NULL
13547 };
13548
13549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13550 {
13551 arg1 = wxString_in_helper(obj0);
13552 if (arg1 == NULL) SWIG_fail;
13553 temp1 = true;
13554 }
13555 {
13556 PyThreadState* __tstate = wxPyBeginAllowThreads();
13557 wxPyLogFatalError((wxString const &)*arg1);
13558 wxPyEndAllowThreads(__tstate);
13559 if (PyErr_Occurred()) SWIG_fail;
13560 }
13561 resultobj = SWIG_Py_Void();
13562 {
13563 if (temp1)
13564 delete arg1;
13565 }
13566 return resultobj;
13567 fail:
13568 {
13569 if (temp1)
13570 delete arg1;
13571 }
13572 return NULL;
13573 }
13574
13575
13576 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13577 PyObject *resultobj = 0;
13578 wxString *arg1 = 0 ;
13579 bool temp1 = false ;
13580 PyObject * obj0 = 0 ;
13581 char * kwnames[] = {
13582 (char *) "msg", NULL
13583 };
13584
13585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13586 {
13587 arg1 = wxString_in_helper(obj0);
13588 if (arg1 == NULL) SWIG_fail;
13589 temp1 = true;
13590 }
13591 {
13592 PyThreadState* __tstate = wxPyBeginAllowThreads();
13593 wxPyLogError((wxString const &)*arg1);
13594 wxPyEndAllowThreads(__tstate);
13595 if (PyErr_Occurred()) SWIG_fail;
13596 }
13597 resultobj = SWIG_Py_Void();
13598 {
13599 if (temp1)
13600 delete arg1;
13601 }
13602 return resultobj;
13603 fail:
13604 {
13605 if (temp1)
13606 delete arg1;
13607 }
13608 return NULL;
13609 }
13610
13611
13612 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj = 0;
13614 wxString *arg1 = 0 ;
13615 bool temp1 = false ;
13616 PyObject * obj0 = 0 ;
13617 char * kwnames[] = {
13618 (char *) "msg", NULL
13619 };
13620
13621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13622 {
13623 arg1 = wxString_in_helper(obj0);
13624 if (arg1 == NULL) SWIG_fail;
13625 temp1 = true;
13626 }
13627 {
13628 PyThreadState* __tstate = wxPyBeginAllowThreads();
13629 wxPyLogWarning((wxString const &)*arg1);
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 resultobj = SWIG_Py_Void();
13634 {
13635 if (temp1)
13636 delete arg1;
13637 }
13638 return resultobj;
13639 fail:
13640 {
13641 if (temp1)
13642 delete arg1;
13643 }
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13649 PyObject *resultobj = 0;
13650 wxString *arg1 = 0 ;
13651 bool temp1 = false ;
13652 PyObject * obj0 = 0 ;
13653 char * kwnames[] = {
13654 (char *) "msg", NULL
13655 };
13656
13657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13658 {
13659 arg1 = wxString_in_helper(obj0);
13660 if (arg1 == NULL) SWIG_fail;
13661 temp1 = true;
13662 }
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 wxPyLogMessage((wxString const &)*arg1);
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 resultobj = SWIG_Py_Void();
13670 {
13671 if (temp1)
13672 delete arg1;
13673 }
13674 return resultobj;
13675 fail:
13676 {
13677 if (temp1)
13678 delete arg1;
13679 }
13680 return NULL;
13681 }
13682
13683
13684 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj = 0;
13686 wxString *arg1 = 0 ;
13687 bool temp1 = false ;
13688 PyObject * obj0 = 0 ;
13689 char * kwnames[] = {
13690 (char *) "msg", NULL
13691 };
13692
13693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13694 {
13695 arg1 = wxString_in_helper(obj0);
13696 if (arg1 == NULL) SWIG_fail;
13697 temp1 = true;
13698 }
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 wxPyLogInfo((wxString const &)*arg1);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 resultobj = SWIG_Py_Void();
13706 {
13707 if (temp1)
13708 delete arg1;
13709 }
13710 return resultobj;
13711 fail:
13712 {
13713 if (temp1)
13714 delete arg1;
13715 }
13716 return NULL;
13717 }
13718
13719
13720 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13721 PyObject *resultobj = 0;
13722 wxString *arg1 = 0 ;
13723 bool temp1 = false ;
13724 PyObject * obj0 = 0 ;
13725 char * kwnames[] = {
13726 (char *) "msg", NULL
13727 };
13728
13729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13730 {
13731 arg1 = wxString_in_helper(obj0);
13732 if (arg1 == NULL) SWIG_fail;
13733 temp1 = true;
13734 }
13735 {
13736 PyThreadState* __tstate = wxPyBeginAllowThreads();
13737 wxPyLogDebug((wxString const &)*arg1);
13738 wxPyEndAllowThreads(__tstate);
13739 if (PyErr_Occurred()) SWIG_fail;
13740 }
13741 resultobj = SWIG_Py_Void();
13742 {
13743 if (temp1)
13744 delete arg1;
13745 }
13746 return resultobj;
13747 fail:
13748 {
13749 if (temp1)
13750 delete arg1;
13751 }
13752 return NULL;
13753 }
13754
13755
13756 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13757 PyObject *resultobj = 0;
13758 wxString *arg1 = 0 ;
13759 bool temp1 = false ;
13760 PyObject * obj0 = 0 ;
13761 char * kwnames[] = {
13762 (char *) "msg", NULL
13763 };
13764
13765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13766 {
13767 arg1 = wxString_in_helper(obj0);
13768 if (arg1 == NULL) SWIG_fail;
13769 temp1 = true;
13770 }
13771 {
13772 PyThreadState* __tstate = wxPyBeginAllowThreads();
13773 wxPyLogVerbose((wxString const &)*arg1);
13774 wxPyEndAllowThreads(__tstate);
13775 if (PyErr_Occurred()) SWIG_fail;
13776 }
13777 resultobj = SWIG_Py_Void();
13778 {
13779 if (temp1)
13780 delete arg1;
13781 }
13782 return resultobj;
13783 fail:
13784 {
13785 if (temp1)
13786 delete arg1;
13787 }
13788 return NULL;
13789 }
13790
13791
13792 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13793 PyObject *resultobj = 0;
13794 wxString *arg1 = 0 ;
13795 bool temp1 = false ;
13796 PyObject * obj0 = 0 ;
13797 char * kwnames[] = {
13798 (char *) "msg", NULL
13799 };
13800
13801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13802 {
13803 arg1 = wxString_in_helper(obj0);
13804 if (arg1 == NULL) SWIG_fail;
13805 temp1 = true;
13806 }
13807 {
13808 PyThreadState* __tstate = wxPyBeginAllowThreads();
13809 wxPyLogStatus((wxString const &)*arg1);
13810 wxPyEndAllowThreads(__tstate);
13811 if (PyErr_Occurred()) SWIG_fail;
13812 }
13813 resultobj = SWIG_Py_Void();
13814 {
13815 if (temp1)
13816 delete arg1;
13817 }
13818 return resultobj;
13819 fail:
13820 {
13821 if (temp1)
13822 delete arg1;
13823 }
13824 return NULL;
13825 }
13826
13827
13828 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj = 0;
13830 wxFrame *arg1 = (wxFrame *) 0 ;
13831 wxString *arg2 = 0 ;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 bool temp2 = false ;
13835 PyObject * obj0 = 0 ;
13836 PyObject * obj1 = 0 ;
13837 char * kwnames[] = {
13838 (char *) "pFrame",(char *) "msg", NULL
13839 };
13840
13841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13843 if (!SWIG_IsOK(res1)) {
13844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13845 }
13846 arg1 = reinterpret_cast< wxFrame * >(argp1);
13847 {
13848 arg2 = wxString_in_helper(obj1);
13849 if (arg2 == NULL) SWIG_fail;
13850 temp2 = true;
13851 }
13852 {
13853 PyThreadState* __tstate = wxPyBeginAllowThreads();
13854 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13855 wxPyEndAllowThreads(__tstate);
13856 if (PyErr_Occurred()) SWIG_fail;
13857 }
13858 resultobj = SWIG_Py_Void();
13859 {
13860 if (temp2)
13861 delete arg2;
13862 }
13863 return resultobj;
13864 fail:
13865 {
13866 if (temp2)
13867 delete arg2;
13868 }
13869 return NULL;
13870 }
13871
13872
13873 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj = 0;
13875 wxString *arg1 = 0 ;
13876 bool temp1 = false ;
13877 PyObject * obj0 = 0 ;
13878 char * kwnames[] = {
13879 (char *) "msg", NULL
13880 };
13881
13882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13883 {
13884 arg1 = wxString_in_helper(obj0);
13885 if (arg1 == NULL) SWIG_fail;
13886 temp1 = true;
13887 }
13888 {
13889 PyThreadState* __tstate = wxPyBeginAllowThreads();
13890 wxPyLogSysError((wxString const &)*arg1);
13891 wxPyEndAllowThreads(__tstate);
13892 if (PyErr_Occurred()) SWIG_fail;
13893 }
13894 resultobj = SWIG_Py_Void();
13895 {
13896 if (temp1)
13897 delete arg1;
13898 }
13899 return resultobj;
13900 fail:
13901 {
13902 if (temp1)
13903 delete arg1;
13904 }
13905 return NULL;
13906 }
13907
13908
13909 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13910 PyObject *resultobj = 0;
13911 unsigned long arg1 ;
13912 wxString *arg2 = 0 ;
13913 unsigned long val1 ;
13914 int ecode1 = 0 ;
13915 bool temp2 = false ;
13916 PyObject * obj0 = 0 ;
13917 PyObject * obj1 = 0 ;
13918 char * kwnames[] = {
13919 (char *) "level",(char *) "msg", NULL
13920 };
13921
13922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13923 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13924 if (!SWIG_IsOK(ecode1)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13926 }
13927 arg1 = static_cast< unsigned long >(val1);
13928 {
13929 arg2 = wxString_in_helper(obj1);
13930 if (arg2 == NULL) SWIG_fail;
13931 temp2 = true;
13932 }
13933 {
13934 PyThreadState* __tstate = wxPyBeginAllowThreads();
13935 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13936 wxPyEndAllowThreads(__tstate);
13937 if (PyErr_Occurred()) SWIG_fail;
13938 }
13939 resultobj = SWIG_Py_Void();
13940 {
13941 if (temp2)
13942 delete arg2;
13943 }
13944 return resultobj;
13945 fail:
13946 {
13947 if (temp2)
13948 delete arg2;
13949 }
13950 return NULL;
13951 }
13952
13953
13954 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13955 PyObject *resultobj = 0;
13956 unsigned long arg1 ;
13957 wxString *arg2 = 0 ;
13958 unsigned long val1 ;
13959 int ecode1 = 0 ;
13960 bool temp2 = false ;
13961
13962 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13963 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13964 if (!SWIG_IsOK(ecode1)) {
13965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13966 }
13967 arg1 = static_cast< unsigned long >(val1);
13968 {
13969 arg2 = wxString_in_helper(swig_obj[1]);
13970 if (arg2 == NULL) SWIG_fail;
13971 temp2 = true;
13972 }
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 wxPyLogTrace(arg1,(wxString const &)*arg2);
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_Py_Void();
13980 {
13981 if (temp2)
13982 delete arg2;
13983 }
13984 return resultobj;
13985 fail:
13986 {
13987 if (temp2)
13988 delete arg2;
13989 }
13990 return NULL;
13991 }
13992
13993
13994 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13995 PyObject *resultobj = 0;
13996 wxString *arg1 = 0 ;
13997 wxString *arg2 = 0 ;
13998 bool temp1 = false ;
13999 bool temp2 = false ;
14000
14001 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14002 {
14003 arg1 = wxString_in_helper(swig_obj[0]);
14004 if (arg1 == NULL) SWIG_fail;
14005 temp1 = true;
14006 }
14007 {
14008 arg2 = wxString_in_helper(swig_obj[1]);
14009 if (arg2 == NULL) SWIG_fail;
14010 temp2 = true;
14011 }
14012 {
14013 PyThreadState* __tstate = wxPyBeginAllowThreads();
14014 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 resultobj = SWIG_Py_Void();
14019 {
14020 if (temp1)
14021 delete arg1;
14022 }
14023 {
14024 if (temp2)
14025 delete arg2;
14026 }
14027 return resultobj;
14028 fail:
14029 {
14030 if (temp1)
14031 delete arg1;
14032 }
14033 {
14034 if (temp2)
14035 delete arg2;
14036 }
14037 return NULL;
14038 }
14039
14040
14041 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14042 int argc;
14043 PyObject *argv[3];
14044
14045 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14046 --argc;
14047 if (argc == 2) {
14048 int _v = 0;
14049 {
14050 {
14051 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14052 }
14053 }
14054 if (!_v) goto check_1;
14055 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14056 }
14057 check_1:
14058
14059 if (argc == 2) {
14060 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14061 }
14062
14063 fail:
14064 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14065 return NULL;
14066 }
14067
14068
14069 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14070 PyObject *resultobj = 0;
14071 wxString *arg1 = 0 ;
14072 wxString *arg2 = 0 ;
14073 bool temp1 = false ;
14074 bool temp2 = false ;
14075 PyObject * obj0 = 0 ;
14076 PyObject * obj1 = 0 ;
14077 char * kwnames[] = {
14078 (char *) "title",(char *) "text", NULL
14079 };
14080
14081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14082 {
14083 arg1 = wxString_in_helper(obj0);
14084 if (arg1 == NULL) SWIG_fail;
14085 temp1 = true;
14086 }
14087 {
14088 arg2 = wxString_in_helper(obj1);
14089 if (arg2 == NULL) SWIG_fail;
14090 temp2 = true;
14091 }
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14095 wxPyEndAllowThreads(__tstate);
14096 if (PyErr_Occurred()) SWIG_fail;
14097 }
14098 resultobj = SWIG_Py_Void();
14099 {
14100 if (temp1)
14101 delete arg1;
14102 }
14103 {
14104 if (temp2)
14105 delete arg2;
14106 }
14107 return resultobj;
14108 fail:
14109 {
14110 if (temp1)
14111 delete arg1;
14112 }
14113 {
14114 if (temp2)
14115 delete arg2;
14116 }
14117 return NULL;
14118 }
14119
14120
14121 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14122 PyObject *resultobj = 0;
14123 wxLogNull *result = 0 ;
14124
14125 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 result = (wxLogNull *)new wxLogNull();
14129 wxPyEndAllowThreads(__tstate);
14130 if (PyErr_Occurred()) SWIG_fail;
14131 }
14132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14133 return resultobj;
14134 fail:
14135 return NULL;
14136 }
14137
14138
14139 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14140 PyObject *resultobj = 0;
14141 wxLogNull *arg1 = (wxLogNull *) 0 ;
14142 void *argp1 = 0 ;
14143 int res1 = 0 ;
14144 PyObject *swig_obj[1] ;
14145
14146 if (!args) SWIG_fail;
14147 swig_obj[0] = args;
14148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14149 if (!SWIG_IsOK(res1)) {
14150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14151 }
14152 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 delete arg1;
14156
14157 wxPyEndAllowThreads(__tstate);
14158 if (PyErr_Occurred()) SWIG_fail;
14159 }
14160 resultobj = SWIG_Py_Void();
14161 return resultobj;
14162 fail:
14163 return NULL;
14164 }
14165
14166
14167 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14168 PyObject *obj;
14169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14170 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14171 return SWIG_Py_Void();
14172 }
14173
14174 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14175 return SWIG_Python_InitShadowInstance(args);
14176 }
14177
14178 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14179 PyObject *resultobj = 0;
14180 wxPyLog *result = 0 ;
14181
14182 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14183 {
14184 PyThreadState* __tstate = wxPyBeginAllowThreads();
14185 result = (wxPyLog *)new wxPyLog();
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14190 return resultobj;
14191 fail:
14192 return NULL;
14193 }
14194
14195
14196 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14197 PyObject *resultobj = 0;
14198 wxPyLog *arg1 = (wxPyLog *) 0 ;
14199 PyObject *arg2 = (PyObject *) 0 ;
14200 PyObject *arg3 = (PyObject *) 0 ;
14201 void *argp1 = 0 ;
14202 int res1 = 0 ;
14203 PyObject * obj0 = 0 ;
14204 PyObject * obj1 = 0 ;
14205 PyObject * obj2 = 0 ;
14206 char * kwnames[] = {
14207 (char *) "self",(char *) "self",(char *) "_class", NULL
14208 };
14209
14210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14212 if (!SWIG_IsOK(res1)) {
14213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14214 }
14215 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14216 arg2 = obj1;
14217 arg3 = obj2;
14218 {
14219 PyThreadState* __tstate = wxPyBeginAllowThreads();
14220 (arg1)->_setCallbackInfo(arg2,arg3);
14221 wxPyEndAllowThreads(__tstate);
14222 if (PyErr_Occurred()) SWIG_fail;
14223 }
14224 resultobj = SWIG_Py_Void();
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14232 PyObject *obj;
14233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14234 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14235 return SWIG_Py_Void();
14236 }
14237
14238 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14239 return SWIG_Python_InitShadowInstance(args);
14240 }
14241
14242 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj = 0;
14244 int arg1 ;
14245 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14246 int arg3 = (int) wxKILL_NOCHILDREN ;
14247 wxKillError result;
14248 int val1 ;
14249 int ecode1 = 0 ;
14250 int val2 ;
14251 int ecode2 = 0 ;
14252 int val3 ;
14253 int ecode3 = 0 ;
14254 PyObject * obj0 = 0 ;
14255 PyObject * obj1 = 0 ;
14256 PyObject * obj2 = 0 ;
14257 char * kwnames[] = {
14258 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14259 };
14260
14261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14262 ecode1 = SWIG_AsVal_int(obj0, &val1);
14263 if (!SWIG_IsOK(ecode1)) {
14264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14265 }
14266 arg1 = static_cast< int >(val1);
14267 if (obj1) {
14268 ecode2 = SWIG_AsVal_int(obj1, &val2);
14269 if (!SWIG_IsOK(ecode2)) {
14270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14271 }
14272 arg2 = static_cast< wxSignal >(val2);
14273 }
14274 if (obj2) {
14275 ecode3 = SWIG_AsVal_int(obj2, &val3);
14276 if (!SWIG_IsOK(ecode3)) {
14277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14278 }
14279 arg3 = static_cast< int >(val3);
14280 }
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 resultobj = SWIG_From_int(static_cast< int >(result));
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14295 PyObject *resultobj = 0;
14296 int arg1 ;
14297 bool result;
14298 int val1 ;
14299 int ecode1 = 0 ;
14300 PyObject * obj0 = 0 ;
14301 char * kwnames[] = {
14302 (char *) "pid", NULL
14303 };
14304
14305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14306 ecode1 = SWIG_AsVal_int(obj0, &val1);
14307 if (!SWIG_IsOK(ecode1)) {
14308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14309 }
14310 arg1 = static_cast< int >(val1);
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 result = (bool)wxPyProcess::Exists(arg1);
14314 wxPyEndAllowThreads(__tstate);
14315 if (PyErr_Occurred()) SWIG_fail;
14316 }
14317 {
14318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14319 }
14320 return resultobj;
14321 fail:
14322 return NULL;
14323 }
14324
14325
14326 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14327 PyObject *resultobj = 0;
14328 wxString *arg1 = 0 ;
14329 int arg2 = (int) wxEXEC_ASYNC ;
14330 wxPyProcess *result = 0 ;
14331 bool temp1 = false ;
14332 int val2 ;
14333 int ecode2 = 0 ;
14334 PyObject * obj0 = 0 ;
14335 PyObject * obj1 = 0 ;
14336 char * kwnames[] = {
14337 (char *) "cmd",(char *) "flags", NULL
14338 };
14339
14340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14341 {
14342 arg1 = wxString_in_helper(obj0);
14343 if (arg1 == NULL) SWIG_fail;
14344 temp1 = true;
14345 }
14346 if (obj1) {
14347 ecode2 = SWIG_AsVal_int(obj1, &val2);
14348 if (!SWIG_IsOK(ecode2)) {
14349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14350 }
14351 arg2 = static_cast< int >(val2);
14352 }
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14356 wxPyEndAllowThreads(__tstate);
14357 if (PyErr_Occurred()) SWIG_fail;
14358 }
14359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14360 {
14361 if (temp1)
14362 delete arg1;
14363 }
14364 return resultobj;
14365 fail:
14366 {
14367 if (temp1)
14368 delete arg1;
14369 }
14370 return NULL;
14371 }
14372
14373
14374 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14375 PyObject *resultobj = 0;
14376 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14377 int arg2 = (int) -1 ;
14378 wxPyProcess *result = 0 ;
14379 void *argp1 = 0 ;
14380 int res1 = 0 ;
14381 int val2 ;
14382 int ecode2 = 0 ;
14383 PyObject * obj0 = 0 ;
14384 PyObject * obj1 = 0 ;
14385 char * kwnames[] = {
14386 (char *) "parent",(char *) "id", NULL
14387 };
14388
14389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14390 if (obj0) {
14391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14392 if (!SWIG_IsOK(res1)) {
14393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14394 }
14395 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14396 }
14397 if (obj1) {
14398 ecode2 = SWIG_AsVal_int(obj1, &val2);
14399 if (!SWIG_IsOK(ecode2)) {
14400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14401 }
14402 arg2 = static_cast< int >(val2);
14403 }
14404 {
14405 PyThreadState* __tstate = wxPyBeginAllowThreads();
14406 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14407 wxPyEndAllowThreads(__tstate);
14408 if (PyErr_Occurred()) SWIG_fail;
14409 }
14410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14411 return resultobj;
14412 fail:
14413 return NULL;
14414 }
14415
14416
14417 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14418 PyObject *resultobj = 0;
14419 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14420 void *argp1 = 0 ;
14421 int res1 = 0 ;
14422 PyObject *swig_obj[1] ;
14423
14424 if (!args) SWIG_fail;
14425 swig_obj[0] = args;
14426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14427 if (!SWIG_IsOK(res1)) {
14428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14429 }
14430 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14431 {
14432 PyThreadState* __tstate = wxPyBeginAllowThreads();
14433 delete arg1;
14434
14435 wxPyEndAllowThreads(__tstate);
14436 if (PyErr_Occurred()) SWIG_fail;
14437 }
14438 resultobj = SWIG_Py_Void();
14439 return resultobj;
14440 fail:
14441 return NULL;
14442 }
14443
14444
14445 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj = 0;
14447 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14448 PyObject *arg2 = (PyObject *) 0 ;
14449 PyObject *arg3 = (PyObject *) 0 ;
14450 void *argp1 = 0 ;
14451 int res1 = 0 ;
14452 PyObject * obj0 = 0 ;
14453 PyObject * obj1 = 0 ;
14454 PyObject * obj2 = 0 ;
14455 char * kwnames[] = {
14456 (char *) "self",(char *) "self",(char *) "_class", NULL
14457 };
14458
14459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14461 if (!SWIG_IsOK(res1)) {
14462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14463 }
14464 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14465 arg2 = obj1;
14466 arg3 = obj2;
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 (arg1)->_setCallbackInfo(arg2,arg3);
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 resultobj = SWIG_Py_Void();
14474 return resultobj;
14475 fail:
14476 return NULL;
14477 }
14478
14479
14480 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14481 PyObject *resultobj = 0;
14482 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14483 long result;
14484 void *argp1 = 0 ;
14485 int res1 = 0 ;
14486 PyObject *swig_obj[1] ;
14487
14488 if (!args) SWIG_fail;
14489 swig_obj[0] = args;
14490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14493 }
14494 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 result = (long)((wxPyProcess const *)arg1)->GetPid();
14498 wxPyEndAllowThreads(__tstate);
14499 if (PyErr_Occurred()) SWIG_fail;
14500 }
14501 resultobj = SWIG_From_long(static_cast< long >(result));
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14509 PyObject *resultobj = 0;
14510 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14511 int arg2 ;
14512 int arg3 ;
14513 void *argp1 = 0 ;
14514 int res1 = 0 ;
14515 int val2 ;
14516 int ecode2 = 0 ;
14517 int val3 ;
14518 int ecode3 = 0 ;
14519 PyObject * obj0 = 0 ;
14520 PyObject * obj1 = 0 ;
14521 PyObject * obj2 = 0 ;
14522 char * kwnames[] = {
14523 (char *) "self",(char *) "pid",(char *) "status", NULL
14524 };
14525
14526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14528 if (!SWIG_IsOK(res1)) {
14529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14530 }
14531 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14532 ecode2 = SWIG_AsVal_int(obj1, &val2);
14533 if (!SWIG_IsOK(ecode2)) {
14534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14535 }
14536 arg2 = static_cast< int >(val2);
14537 ecode3 = SWIG_AsVal_int(obj2, &val3);
14538 if (!SWIG_IsOK(ecode3)) {
14539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14540 }
14541 arg3 = static_cast< int >(val3);
14542 {
14543 PyThreadState* __tstate = wxPyBeginAllowThreads();
14544 (arg1)->OnTerminate(arg2,arg3);
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 resultobj = SWIG_Py_Void();
14549 return resultobj;
14550 fail:
14551 return NULL;
14552 }
14553
14554
14555 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14556 PyObject *resultobj = 0;
14557 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14558 void *argp1 = 0 ;
14559 int res1 = 0 ;
14560 PyObject *swig_obj[1] ;
14561
14562 if (!args) SWIG_fail;
14563 swig_obj[0] = args;
14564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14565 if (!SWIG_IsOK(res1)) {
14566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14567 }
14568 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 (arg1)->Redirect();
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 resultobj = SWIG_Py_Void();
14576 return resultobj;
14577 fail:
14578 return NULL;
14579 }
14580
14581
14582 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14583 PyObject *resultobj = 0;
14584 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14585 bool result;
14586 void *argp1 = 0 ;
14587 int res1 = 0 ;
14588 PyObject *swig_obj[1] ;
14589
14590 if (!args) SWIG_fail;
14591 swig_obj[0] = args;
14592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14593 if (!SWIG_IsOK(res1)) {
14594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14595 }
14596 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 result = (bool)(arg1)->IsRedirected();
14600 wxPyEndAllowThreads(__tstate);
14601 if (PyErr_Occurred()) SWIG_fail;
14602 }
14603 {
14604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14605 }
14606 return resultobj;
14607 fail:
14608 return NULL;
14609 }
14610
14611
14612 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14613 PyObject *resultobj = 0;
14614 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14615 void *argp1 = 0 ;
14616 int res1 = 0 ;
14617 PyObject *swig_obj[1] ;
14618
14619 if (!args) SWIG_fail;
14620 swig_obj[0] = args;
14621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14622 if (!SWIG_IsOK(res1)) {
14623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14624 }
14625 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 (arg1)->Detach();
14629 wxPyEndAllowThreads(__tstate);
14630 if (PyErr_Occurred()) SWIG_fail;
14631 }
14632 resultobj = SWIG_Py_Void();
14633 return resultobj;
14634 fail:
14635 return NULL;
14636 }
14637
14638
14639 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14640 PyObject *resultobj = 0;
14641 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14642 wxInputStream *result = 0 ;
14643 void *argp1 = 0 ;
14644 int res1 = 0 ;
14645 PyObject *swig_obj[1] ;
14646
14647 if (!args) SWIG_fail;
14648 swig_obj[0] = args;
14649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14650 if (!SWIG_IsOK(res1)) {
14651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14652 }
14653 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = (wxInputStream *)(arg1)->GetInputStream();
14657 wxPyEndAllowThreads(__tstate);
14658 if (PyErr_Occurred()) SWIG_fail;
14659 }
14660 {
14661 wxPyInputStream * _ptr = NULL;
14662
14663 if (result) {
14664 _ptr = new wxPyInputStream(result);
14665 }
14666 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14667 }
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14675 PyObject *resultobj = 0;
14676 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14677 wxInputStream *result = 0 ;
14678 void *argp1 = 0 ;
14679 int res1 = 0 ;
14680 PyObject *swig_obj[1] ;
14681
14682 if (!args) SWIG_fail;
14683 swig_obj[0] = args;
14684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14685 if (!SWIG_IsOK(res1)) {
14686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14687 }
14688 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 result = (wxInputStream *)(arg1)->GetErrorStream();
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 {
14696 wxPyInputStream * _ptr = NULL;
14697
14698 if (result) {
14699 _ptr = new wxPyInputStream(result);
14700 }
14701 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14702 }
14703 return resultobj;
14704 fail:
14705 return NULL;
14706 }
14707
14708
14709 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14710 PyObject *resultobj = 0;
14711 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14712 wxOutputStream *result = 0 ;
14713 void *argp1 = 0 ;
14714 int res1 = 0 ;
14715 PyObject *swig_obj[1] ;
14716
14717 if (!args) SWIG_fail;
14718 swig_obj[0] = args;
14719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14720 if (!SWIG_IsOK(res1)) {
14721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14722 }
14723 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (wxOutputStream *)(arg1)->GetOutputStream();
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14731 return resultobj;
14732 fail:
14733 return NULL;
14734 }
14735
14736
14737 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14738 PyObject *resultobj = 0;
14739 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14740 void *argp1 = 0 ;
14741 int res1 = 0 ;
14742 PyObject *swig_obj[1] ;
14743
14744 if (!args) SWIG_fail;
14745 swig_obj[0] = args;
14746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14747 if (!SWIG_IsOK(res1)) {
14748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14749 }
14750 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14751 {
14752 PyThreadState* __tstate = wxPyBeginAllowThreads();
14753 (arg1)->CloseOutput();
14754 wxPyEndAllowThreads(__tstate);
14755 if (PyErr_Occurred()) SWIG_fail;
14756 }
14757 resultobj = SWIG_Py_Void();
14758 return resultobj;
14759 fail:
14760 return NULL;
14761 }
14762
14763
14764 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14765 PyObject *resultobj = 0;
14766 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14767 bool result;
14768 void *argp1 = 0 ;
14769 int res1 = 0 ;
14770 PyObject *swig_obj[1] ;
14771
14772 if (!args) SWIG_fail;
14773 swig_obj[0] = args;
14774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14775 if (!SWIG_IsOK(res1)) {
14776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14777 }
14778 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14779 {
14780 PyThreadState* __tstate = wxPyBeginAllowThreads();
14781 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 {
14786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14787 }
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14795 PyObject *resultobj = 0;
14796 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14797 bool result;
14798 void *argp1 = 0 ;
14799 int res1 = 0 ;
14800 PyObject *swig_obj[1] ;
14801
14802 if (!args) SWIG_fail;
14803 swig_obj[0] = args;
14804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14805 if (!SWIG_IsOK(res1)) {
14806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14807 }
14808 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14809 {
14810 PyThreadState* __tstate = wxPyBeginAllowThreads();
14811 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14812 wxPyEndAllowThreads(__tstate);
14813 if (PyErr_Occurred()) SWIG_fail;
14814 }
14815 {
14816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14817 }
14818 return resultobj;
14819 fail:
14820 return NULL;
14821 }
14822
14823
14824 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14825 PyObject *resultobj = 0;
14826 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14827 bool result;
14828 void *argp1 = 0 ;
14829 int res1 = 0 ;
14830 PyObject *swig_obj[1] ;
14831
14832 if (!args) SWIG_fail;
14833 swig_obj[0] = args;
14834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14837 }
14838 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14839 {
14840 PyThreadState* __tstate = wxPyBeginAllowThreads();
14841 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 {
14846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14847 }
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14855 PyObject *obj;
14856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14857 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14858 return SWIG_Py_Void();
14859 }
14860
14861 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14862 return SWIG_Python_InitShadowInstance(args);
14863 }
14864
14865 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14866 PyObject *resultobj = 0;
14867 int arg1 = (int) 0 ;
14868 int arg2 = (int) 0 ;
14869 int arg3 = (int) 0 ;
14870 wxProcessEvent *result = 0 ;
14871 int val1 ;
14872 int ecode1 = 0 ;
14873 int val2 ;
14874 int ecode2 = 0 ;
14875 int val3 ;
14876 int ecode3 = 0 ;
14877 PyObject * obj0 = 0 ;
14878 PyObject * obj1 = 0 ;
14879 PyObject * obj2 = 0 ;
14880 char * kwnames[] = {
14881 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14882 };
14883
14884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14885 if (obj0) {
14886 ecode1 = SWIG_AsVal_int(obj0, &val1);
14887 if (!SWIG_IsOK(ecode1)) {
14888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14889 }
14890 arg1 = static_cast< int >(val1);
14891 }
14892 if (obj1) {
14893 ecode2 = SWIG_AsVal_int(obj1, &val2);
14894 if (!SWIG_IsOK(ecode2)) {
14895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14896 }
14897 arg2 = static_cast< int >(val2);
14898 }
14899 if (obj2) {
14900 ecode3 = SWIG_AsVal_int(obj2, &val3);
14901 if (!SWIG_IsOK(ecode3)) {
14902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14903 }
14904 arg3 = static_cast< int >(val3);
14905 }
14906 {
14907 PyThreadState* __tstate = wxPyBeginAllowThreads();
14908 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14909 wxPyEndAllowThreads(__tstate);
14910 if (PyErr_Occurred()) SWIG_fail;
14911 }
14912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14913 return resultobj;
14914 fail:
14915 return NULL;
14916 }
14917
14918
14919 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14920 PyObject *resultobj = 0;
14921 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14922 int result;
14923 void *argp1 = 0 ;
14924 int res1 = 0 ;
14925 PyObject *swig_obj[1] ;
14926
14927 if (!args) SWIG_fail;
14928 swig_obj[0] = args;
14929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14930 if (!SWIG_IsOK(res1)) {
14931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14932 }
14933 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 result = (int)(arg1)->GetPid();
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 resultobj = SWIG_From_int(static_cast< int >(result));
14941 return resultobj;
14942 fail:
14943 return NULL;
14944 }
14945
14946
14947 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14948 PyObject *resultobj = 0;
14949 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14950 int result;
14951 void *argp1 = 0 ;
14952 int res1 = 0 ;
14953 PyObject *swig_obj[1] ;
14954
14955 if (!args) SWIG_fail;
14956 swig_obj[0] = args;
14957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14958 if (!SWIG_IsOK(res1)) {
14959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14960 }
14961 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14962 {
14963 PyThreadState* __tstate = wxPyBeginAllowThreads();
14964 result = (int)(arg1)->GetExitCode();
14965 wxPyEndAllowThreads(__tstate);
14966 if (PyErr_Occurred()) SWIG_fail;
14967 }
14968 resultobj = SWIG_From_int(static_cast< int >(result));
14969 return resultobj;
14970 fail:
14971 return NULL;
14972 }
14973
14974
14975 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14976 PyObject *resultobj = 0;
14977 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14978 int arg2 ;
14979 void *argp1 = 0 ;
14980 int res1 = 0 ;
14981 int val2 ;
14982 int ecode2 = 0 ;
14983 PyObject *swig_obj[2] ;
14984
14985 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14987 if (!SWIG_IsOK(res1)) {
14988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14989 }
14990 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14991 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14992 if (!SWIG_IsOK(ecode2)) {
14993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14994 }
14995 arg2 = static_cast< int >(val2);
14996 if (arg1) (arg1)->m_pid = arg2;
14997
14998 resultobj = SWIG_Py_Void();
14999 return resultobj;
15000 fail:
15001 return NULL;
15002 }
15003
15004
15005 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15006 PyObject *resultobj = 0;
15007 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15008 int result;
15009 void *argp1 = 0 ;
15010 int res1 = 0 ;
15011 PyObject *swig_obj[1] ;
15012
15013 if (!args) SWIG_fail;
15014 swig_obj[0] = args;
15015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15016 if (!SWIG_IsOK(res1)) {
15017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15018 }
15019 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15020 result = (int) ((arg1)->m_pid);
15021 resultobj = SWIG_From_int(static_cast< int >(result));
15022 return resultobj;
15023 fail:
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15029 PyObject *resultobj = 0;
15030 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15031 int arg2 ;
15032 void *argp1 = 0 ;
15033 int res1 = 0 ;
15034 int val2 ;
15035 int ecode2 = 0 ;
15036 PyObject *swig_obj[2] ;
15037
15038 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15040 if (!SWIG_IsOK(res1)) {
15041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15042 }
15043 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15044 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15045 if (!SWIG_IsOK(ecode2)) {
15046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15047 }
15048 arg2 = static_cast< int >(val2);
15049 if (arg1) (arg1)->m_exitcode = arg2;
15050
15051 resultobj = SWIG_Py_Void();
15052 return resultobj;
15053 fail:
15054 return NULL;
15055 }
15056
15057
15058 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15059 PyObject *resultobj = 0;
15060 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15061 int result;
15062 void *argp1 = 0 ;
15063 int res1 = 0 ;
15064 PyObject *swig_obj[1] ;
15065
15066 if (!args) SWIG_fail;
15067 swig_obj[0] = args;
15068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15069 if (!SWIG_IsOK(res1)) {
15070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15071 }
15072 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15073 result = (int) ((arg1)->m_exitcode);
15074 resultobj = SWIG_From_int(static_cast< int >(result));
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15082 PyObject *obj;
15083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15084 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15085 return SWIG_Py_Void();
15086 }
15087
15088 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15089 return SWIG_Python_InitShadowInstance(args);
15090 }
15091
15092 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15093 PyObject *resultobj = 0;
15094 wxString *arg1 = 0 ;
15095 int arg2 = (int) wxEXEC_ASYNC ;
15096 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15097 long result;
15098 bool temp1 = false ;
15099 int val2 ;
15100 int ecode2 = 0 ;
15101 void *argp3 = 0 ;
15102 int res3 = 0 ;
15103 PyObject * obj0 = 0 ;
15104 PyObject * obj1 = 0 ;
15105 PyObject * obj2 = 0 ;
15106 char * kwnames[] = {
15107 (char *) "command",(char *) "flags",(char *) "process", NULL
15108 };
15109
15110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15111 {
15112 arg1 = wxString_in_helper(obj0);
15113 if (arg1 == NULL) SWIG_fail;
15114 temp1 = true;
15115 }
15116 if (obj1) {
15117 ecode2 = SWIG_AsVal_int(obj1, &val2);
15118 if (!SWIG_IsOK(ecode2)) {
15119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15120 }
15121 arg2 = static_cast< int >(val2);
15122 }
15123 if (obj2) {
15124 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15125 if (!SWIG_IsOK(res3)) {
15126 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15127 }
15128 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15129 }
15130 {
15131 if (!wxPyCheckForApp()) SWIG_fail;
15132 PyThreadState* __tstate = wxPyBeginAllowThreads();
15133 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15134 wxPyEndAllowThreads(__tstate);
15135 if (PyErr_Occurred()) SWIG_fail;
15136 }
15137 resultobj = SWIG_From_long(static_cast< long >(result));
15138 {
15139 if (temp1)
15140 delete arg1;
15141 }
15142 return resultobj;
15143 fail:
15144 {
15145 if (temp1)
15146 delete arg1;
15147 }
15148 return NULL;
15149 }
15150
15151
15152 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15153 PyObject *resultobj = 0;
15154 long arg1 ;
15155 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15156 wxKillError *arg3 = (wxKillError *) 0 ;
15157 int arg4 = (int) wxKILL_NOCHILDREN ;
15158 int result;
15159 long val1 ;
15160 int ecode1 = 0 ;
15161 int val2 ;
15162 int ecode2 = 0 ;
15163 wxKillError temp3 ;
15164 int val4 ;
15165 int ecode4 = 0 ;
15166 PyObject * obj0 = 0 ;
15167 PyObject * obj1 = 0 ;
15168 PyObject * obj2 = 0 ;
15169 char * kwnames[] = {
15170 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15171 };
15172
15173 {
15174 arg3 = &temp3;
15175 }
15176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15177 ecode1 = SWIG_AsVal_long(obj0, &val1);
15178 if (!SWIG_IsOK(ecode1)) {
15179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15180 }
15181 arg1 = static_cast< long >(val1);
15182 if (obj1) {
15183 ecode2 = SWIG_AsVal_int(obj1, &val2);
15184 if (!SWIG_IsOK(ecode2)) {
15185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15186 }
15187 arg2 = static_cast< wxSignal >(val2);
15188 }
15189 if (obj2) {
15190 ecode4 = SWIG_AsVal_int(obj2, &val4);
15191 if (!SWIG_IsOK(ecode4)) {
15192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15193 }
15194 arg4 = static_cast< int >(val4);
15195 }
15196 {
15197 PyThreadState* __tstate = wxPyBeginAllowThreads();
15198 result = (int)wxKill(arg1,arg2,arg3,arg4);
15199 wxPyEndAllowThreads(__tstate);
15200 if (PyErr_Occurred()) SWIG_fail;
15201 }
15202 resultobj = SWIG_From_int(static_cast< int >(result));
15203 {
15204 PyObject* o;
15205 o = PyInt_FromLong((long) (*arg3));
15206
15207
15208
15209 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15210
15211 }
15212 return resultobj;
15213 fail:
15214 return NULL;
15215 }
15216
15217
15218 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15219 PyObject *resultobj = 0;
15220 int arg1 = (int) wxJOYSTICK1 ;
15221 wxJoystick *result = 0 ;
15222 int val1 ;
15223 int ecode1 = 0 ;
15224 PyObject * obj0 = 0 ;
15225 char * kwnames[] = {
15226 (char *) "joystick", NULL
15227 };
15228
15229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15230 if (obj0) {
15231 ecode1 = SWIG_AsVal_int(obj0, &val1);
15232 if (!SWIG_IsOK(ecode1)) {
15233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15234 }
15235 arg1 = static_cast< int >(val1);
15236 }
15237 {
15238 if (!wxPyCheckForApp()) SWIG_fail;
15239 PyThreadState* __tstate = wxPyBeginAllowThreads();
15240 result = (wxJoystick *)new wxJoystick(arg1);
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15252 PyObject *resultobj = 0;
15253 wxJoystick *arg1 = (wxJoystick *) 0 ;
15254 void *argp1 = 0 ;
15255 int res1 = 0 ;
15256 PyObject *swig_obj[1] ;
15257
15258 if (!args) SWIG_fail;
15259 swig_obj[0] = args;
15260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15261 if (!SWIG_IsOK(res1)) {
15262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15263 }
15264 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 delete arg1;
15268
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 resultobj = SWIG_Py_Void();
15273 return resultobj;
15274 fail:
15275 return NULL;
15276 }
15277
15278
15279 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15280 PyObject *resultobj = 0;
15281 wxJoystick *arg1 = (wxJoystick *) 0 ;
15282 wxPoint result;
15283 void *argp1 = 0 ;
15284 int res1 = 0 ;
15285 PyObject *swig_obj[1] ;
15286
15287 if (!args) SWIG_fail;
15288 swig_obj[0] = args;
15289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15290 if (!SWIG_IsOK(res1)) {
15291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15292 }
15293 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 result = (arg1)->GetPosition();
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15308 PyObject *resultobj = 0;
15309 wxJoystick *arg1 = (wxJoystick *) 0 ;
15310 int result;
15311 void *argp1 = 0 ;
15312 int res1 = 0 ;
15313 PyObject *swig_obj[1] ;
15314
15315 if (!args) SWIG_fail;
15316 swig_obj[0] = args;
15317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15318 if (!SWIG_IsOK(res1)) {
15319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15320 }
15321 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15322 {
15323 PyThreadState* __tstate = wxPyBeginAllowThreads();
15324 result = (int)(arg1)->GetZPosition();
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 resultobj = SWIG_From_int(static_cast< int >(result));
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15336 PyObject *resultobj = 0;
15337 wxJoystick *arg1 = (wxJoystick *) 0 ;
15338 int result;
15339 void *argp1 = 0 ;
15340 int res1 = 0 ;
15341 PyObject *swig_obj[1] ;
15342
15343 if (!args) SWIG_fail;
15344 swig_obj[0] = args;
15345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15346 if (!SWIG_IsOK(res1)) {
15347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15348 }
15349 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = (int)(arg1)->GetButtonState();
15353 wxPyEndAllowThreads(__tstate);
15354 if (PyErr_Occurred()) SWIG_fail;
15355 }
15356 resultobj = SWIG_From_int(static_cast< int >(result));
15357 return resultobj;
15358 fail:
15359 return NULL;
15360 }
15361
15362
15363 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15364 PyObject *resultobj = 0;
15365 wxJoystick *arg1 = (wxJoystick *) 0 ;
15366 int result;
15367 void *argp1 = 0 ;
15368 int res1 = 0 ;
15369 PyObject *swig_obj[1] ;
15370
15371 if (!args) SWIG_fail;
15372 swig_obj[0] = args;
15373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15374 if (!SWIG_IsOK(res1)) {
15375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15376 }
15377 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 result = (int)(arg1)->GetPOVPosition();
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 resultobj = SWIG_From_int(static_cast< int >(result));
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15392 PyObject *resultobj = 0;
15393 wxJoystick *arg1 = (wxJoystick *) 0 ;
15394 int result;
15395 void *argp1 = 0 ;
15396 int res1 = 0 ;
15397 PyObject *swig_obj[1] ;
15398
15399 if (!args) SWIG_fail;
15400 swig_obj[0] = args;
15401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15402 if (!SWIG_IsOK(res1)) {
15403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15404 }
15405 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15406 {
15407 PyThreadState* __tstate = wxPyBeginAllowThreads();
15408 result = (int)(arg1)->GetPOVCTSPosition();
15409 wxPyEndAllowThreads(__tstate);
15410 if (PyErr_Occurred()) SWIG_fail;
15411 }
15412 resultobj = SWIG_From_int(static_cast< int >(result));
15413 return resultobj;
15414 fail:
15415 return NULL;
15416 }
15417
15418
15419 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15420 PyObject *resultobj = 0;
15421 wxJoystick *arg1 = (wxJoystick *) 0 ;
15422 int result;
15423 void *argp1 = 0 ;
15424 int res1 = 0 ;
15425 PyObject *swig_obj[1] ;
15426
15427 if (!args) SWIG_fail;
15428 swig_obj[0] = args;
15429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15430 if (!SWIG_IsOK(res1)) {
15431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15432 }
15433 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15434 {
15435 PyThreadState* __tstate = wxPyBeginAllowThreads();
15436 result = (int)(arg1)->GetRudderPosition();
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = SWIG_From_int(static_cast< int >(result));
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15448 PyObject *resultobj = 0;
15449 wxJoystick *arg1 = (wxJoystick *) 0 ;
15450 int result;
15451 void *argp1 = 0 ;
15452 int res1 = 0 ;
15453 PyObject *swig_obj[1] ;
15454
15455 if (!args) SWIG_fail;
15456 swig_obj[0] = args;
15457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15458 if (!SWIG_IsOK(res1)) {
15459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15460 }
15461 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 result = (int)(arg1)->GetUPosition();
15465 wxPyEndAllowThreads(__tstate);
15466 if (PyErr_Occurred()) SWIG_fail;
15467 }
15468 resultobj = SWIG_From_int(static_cast< int >(result));
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15476 PyObject *resultobj = 0;
15477 wxJoystick *arg1 = (wxJoystick *) 0 ;
15478 int result;
15479 void *argp1 = 0 ;
15480 int res1 = 0 ;
15481 PyObject *swig_obj[1] ;
15482
15483 if (!args) SWIG_fail;
15484 swig_obj[0] = args;
15485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15486 if (!SWIG_IsOK(res1)) {
15487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15488 }
15489 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 result = (int)(arg1)->GetVPosition();
15493 wxPyEndAllowThreads(__tstate);
15494 if (PyErr_Occurred()) SWIG_fail;
15495 }
15496 resultobj = SWIG_From_int(static_cast< int >(result));
15497 return resultobj;
15498 fail:
15499 return NULL;
15500 }
15501
15502
15503 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15504 PyObject *resultobj = 0;
15505 wxJoystick *arg1 = (wxJoystick *) 0 ;
15506 int result;
15507 void *argp1 = 0 ;
15508 int res1 = 0 ;
15509 PyObject *swig_obj[1] ;
15510
15511 if (!args) SWIG_fail;
15512 swig_obj[0] = args;
15513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15514 if (!SWIG_IsOK(res1)) {
15515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15516 }
15517 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15518 {
15519 PyThreadState* __tstate = wxPyBeginAllowThreads();
15520 result = (int)(arg1)->GetMovementThreshold();
15521 wxPyEndAllowThreads(__tstate);
15522 if (PyErr_Occurred()) SWIG_fail;
15523 }
15524 resultobj = SWIG_From_int(static_cast< int >(result));
15525 return resultobj;
15526 fail:
15527 return NULL;
15528 }
15529
15530
15531 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15532 PyObject *resultobj = 0;
15533 wxJoystick *arg1 = (wxJoystick *) 0 ;
15534 int arg2 ;
15535 void *argp1 = 0 ;
15536 int res1 = 0 ;
15537 int val2 ;
15538 int ecode2 = 0 ;
15539 PyObject * obj0 = 0 ;
15540 PyObject * obj1 = 0 ;
15541 char * kwnames[] = {
15542 (char *) "self",(char *) "threshold", NULL
15543 };
15544
15545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15547 if (!SWIG_IsOK(res1)) {
15548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15549 }
15550 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15551 ecode2 = SWIG_AsVal_int(obj1, &val2);
15552 if (!SWIG_IsOK(ecode2)) {
15553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15554 }
15555 arg2 = static_cast< int >(val2);
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 (arg1)->SetMovementThreshold(arg2);
15559 wxPyEndAllowThreads(__tstate);
15560 if (PyErr_Occurred()) SWIG_fail;
15561 }
15562 resultobj = SWIG_Py_Void();
15563 return resultobj;
15564 fail:
15565 return NULL;
15566 }
15567
15568
15569 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15570 PyObject *resultobj = 0;
15571 wxJoystick *arg1 = (wxJoystick *) 0 ;
15572 bool result;
15573 void *argp1 = 0 ;
15574 int res1 = 0 ;
15575 PyObject *swig_obj[1] ;
15576
15577 if (!args) SWIG_fail;
15578 swig_obj[0] = args;
15579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15580 if (!SWIG_IsOK(res1)) {
15581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15582 }
15583 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (bool)(arg1)->IsOk();
15587 wxPyEndAllowThreads(__tstate);
15588 if (PyErr_Occurred()) SWIG_fail;
15589 }
15590 {
15591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15592 }
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15600 PyObject *resultobj = 0;
15601 wxJoystick *arg1 = (wxJoystick *) 0 ;
15602 int result;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 PyObject *swig_obj[1] ;
15606
15607 if (!args) SWIG_fail;
15608 swig_obj[0] = args;
15609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15610 if (!SWIG_IsOK(res1)) {
15611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15612 }
15613 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 result = (int)(arg1)->GetNumberJoysticks();
15617 wxPyEndAllowThreads(__tstate);
15618 if (PyErr_Occurred()) SWIG_fail;
15619 }
15620 resultobj = SWIG_From_int(static_cast< int >(result));
15621 return resultobj;
15622 fail:
15623 return NULL;
15624 }
15625
15626
15627 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15628 PyObject *resultobj = 0;
15629 wxJoystick *arg1 = (wxJoystick *) 0 ;
15630 int result;
15631 void *argp1 = 0 ;
15632 int res1 = 0 ;
15633 PyObject *swig_obj[1] ;
15634
15635 if (!args) SWIG_fail;
15636 swig_obj[0] = args;
15637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15638 if (!SWIG_IsOK(res1)) {
15639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15640 }
15641 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15642 {
15643 PyThreadState* __tstate = wxPyBeginAllowThreads();
15644 result = (int)(arg1)->GetManufacturerId();
15645 wxPyEndAllowThreads(__tstate);
15646 if (PyErr_Occurred()) SWIG_fail;
15647 }
15648 resultobj = SWIG_From_int(static_cast< int >(result));
15649 return resultobj;
15650 fail:
15651 return NULL;
15652 }
15653
15654
15655 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15656 PyObject *resultobj = 0;
15657 wxJoystick *arg1 = (wxJoystick *) 0 ;
15658 int result;
15659 void *argp1 = 0 ;
15660 int res1 = 0 ;
15661 PyObject *swig_obj[1] ;
15662
15663 if (!args) SWIG_fail;
15664 swig_obj[0] = args;
15665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15666 if (!SWIG_IsOK(res1)) {
15667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15668 }
15669 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15670 {
15671 PyThreadState* __tstate = wxPyBeginAllowThreads();
15672 result = (int)(arg1)->GetProductId();
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 resultobj = SWIG_From_int(static_cast< int >(result));
15677 return resultobj;
15678 fail:
15679 return NULL;
15680 }
15681
15682
15683 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15684 PyObject *resultobj = 0;
15685 wxJoystick *arg1 = (wxJoystick *) 0 ;
15686 wxString result;
15687 void *argp1 = 0 ;
15688 int res1 = 0 ;
15689 PyObject *swig_obj[1] ;
15690
15691 if (!args) SWIG_fail;
15692 swig_obj[0] = args;
15693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15694 if (!SWIG_IsOK(res1)) {
15695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15696 }
15697 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15698 {
15699 PyThreadState* __tstate = wxPyBeginAllowThreads();
15700 result = (arg1)->GetProductName();
15701 wxPyEndAllowThreads(__tstate);
15702 if (PyErr_Occurred()) SWIG_fail;
15703 }
15704 {
15705 #if wxUSE_UNICODE
15706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15707 #else
15708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15709 #endif
15710 }
15711 return resultobj;
15712 fail:
15713 return NULL;
15714 }
15715
15716
15717 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15718 PyObject *resultobj = 0;
15719 wxJoystick *arg1 = (wxJoystick *) 0 ;
15720 int result;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 PyObject *swig_obj[1] ;
15724
15725 if (!args) SWIG_fail;
15726 swig_obj[0] = args;
15727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15728 if (!SWIG_IsOK(res1)) {
15729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15730 }
15731 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15732 {
15733 PyThreadState* __tstate = wxPyBeginAllowThreads();
15734 result = (int)(arg1)->GetXMin();
15735 wxPyEndAllowThreads(__tstate);
15736 if (PyErr_Occurred()) SWIG_fail;
15737 }
15738 resultobj = SWIG_From_int(static_cast< int >(result));
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15746 PyObject *resultobj = 0;
15747 wxJoystick *arg1 = (wxJoystick *) 0 ;
15748 int result;
15749 void *argp1 = 0 ;
15750 int res1 = 0 ;
15751 PyObject *swig_obj[1] ;
15752
15753 if (!args) SWIG_fail;
15754 swig_obj[0] = args;
15755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15756 if (!SWIG_IsOK(res1)) {
15757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15758 }
15759 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (int)(arg1)->GetYMin();
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 resultobj = SWIG_From_int(static_cast< int >(result));
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15774 PyObject *resultobj = 0;
15775 wxJoystick *arg1 = (wxJoystick *) 0 ;
15776 int result;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 PyObject *swig_obj[1] ;
15780
15781 if (!args) SWIG_fail;
15782 swig_obj[0] = args;
15783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15784 if (!SWIG_IsOK(res1)) {
15785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15786 }
15787 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (int)(arg1)->GetZMin();
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 resultobj = SWIG_From_int(static_cast< int >(result));
15795 return resultobj;
15796 fail:
15797 return NULL;
15798 }
15799
15800
15801 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15802 PyObject *resultobj = 0;
15803 wxJoystick *arg1 = (wxJoystick *) 0 ;
15804 int result;
15805 void *argp1 = 0 ;
15806 int res1 = 0 ;
15807 PyObject *swig_obj[1] ;
15808
15809 if (!args) SWIG_fail;
15810 swig_obj[0] = args;
15811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15814 }
15815 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (int)(arg1)->GetXMax();
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 resultobj = SWIG_From_int(static_cast< int >(result));
15823 return resultobj;
15824 fail:
15825 return NULL;
15826 }
15827
15828
15829 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15830 PyObject *resultobj = 0;
15831 wxJoystick *arg1 = (wxJoystick *) 0 ;
15832 int result;
15833 void *argp1 = 0 ;
15834 int res1 = 0 ;
15835 PyObject *swig_obj[1] ;
15836
15837 if (!args) SWIG_fail;
15838 swig_obj[0] = args;
15839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15840 if (!SWIG_IsOK(res1)) {
15841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15842 }
15843 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15844 {
15845 PyThreadState* __tstate = wxPyBeginAllowThreads();
15846 result = (int)(arg1)->GetYMax();
15847 wxPyEndAllowThreads(__tstate);
15848 if (PyErr_Occurred()) SWIG_fail;
15849 }
15850 resultobj = SWIG_From_int(static_cast< int >(result));
15851 return resultobj;
15852 fail:
15853 return NULL;
15854 }
15855
15856
15857 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15858 PyObject *resultobj = 0;
15859 wxJoystick *arg1 = (wxJoystick *) 0 ;
15860 int result;
15861 void *argp1 = 0 ;
15862 int res1 = 0 ;
15863 PyObject *swig_obj[1] ;
15864
15865 if (!args) SWIG_fail;
15866 swig_obj[0] = args;
15867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15868 if (!SWIG_IsOK(res1)) {
15869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15870 }
15871 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15872 {
15873 PyThreadState* __tstate = wxPyBeginAllowThreads();
15874 result = (int)(arg1)->GetZMax();
15875 wxPyEndAllowThreads(__tstate);
15876 if (PyErr_Occurred()) SWIG_fail;
15877 }
15878 resultobj = SWIG_From_int(static_cast< int >(result));
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15886 PyObject *resultobj = 0;
15887 wxJoystick *arg1 = (wxJoystick *) 0 ;
15888 int result;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject *swig_obj[1] ;
15892
15893 if (!args) SWIG_fail;
15894 swig_obj[0] = args;
15895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15896 if (!SWIG_IsOK(res1)) {
15897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15898 }
15899 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (int)(arg1)->GetNumberButtons();
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_From_int(static_cast< int >(result));
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15914 PyObject *resultobj = 0;
15915 wxJoystick *arg1 = (wxJoystick *) 0 ;
15916 int result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 PyObject *swig_obj[1] ;
15920
15921 if (!args) SWIG_fail;
15922 swig_obj[0] = args;
15923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15924 if (!SWIG_IsOK(res1)) {
15925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15926 }
15927 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 result = (int)(arg1)->GetNumberAxes();
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 resultobj = SWIG_From_int(static_cast< int >(result));
15935 return resultobj;
15936 fail:
15937 return NULL;
15938 }
15939
15940
15941 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15942 PyObject *resultobj = 0;
15943 wxJoystick *arg1 = (wxJoystick *) 0 ;
15944 int result;
15945 void *argp1 = 0 ;
15946 int res1 = 0 ;
15947 PyObject *swig_obj[1] ;
15948
15949 if (!args) SWIG_fail;
15950 swig_obj[0] = args;
15951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15952 if (!SWIG_IsOK(res1)) {
15953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15954 }
15955 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15956 {
15957 PyThreadState* __tstate = wxPyBeginAllowThreads();
15958 result = (int)(arg1)->GetMaxButtons();
15959 wxPyEndAllowThreads(__tstate);
15960 if (PyErr_Occurred()) SWIG_fail;
15961 }
15962 resultobj = SWIG_From_int(static_cast< int >(result));
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15970 PyObject *resultobj = 0;
15971 wxJoystick *arg1 = (wxJoystick *) 0 ;
15972 int result;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 PyObject *swig_obj[1] ;
15976
15977 if (!args) SWIG_fail;
15978 swig_obj[0] = args;
15979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15980 if (!SWIG_IsOK(res1)) {
15981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15982 }
15983 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15984 {
15985 PyThreadState* __tstate = wxPyBeginAllowThreads();
15986 result = (int)(arg1)->GetMaxAxes();
15987 wxPyEndAllowThreads(__tstate);
15988 if (PyErr_Occurred()) SWIG_fail;
15989 }
15990 resultobj = SWIG_From_int(static_cast< int >(result));
15991 return resultobj;
15992 fail:
15993 return NULL;
15994 }
15995
15996
15997 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15998 PyObject *resultobj = 0;
15999 wxJoystick *arg1 = (wxJoystick *) 0 ;
16000 int result;
16001 void *argp1 = 0 ;
16002 int res1 = 0 ;
16003 PyObject *swig_obj[1] ;
16004
16005 if (!args) SWIG_fail;
16006 swig_obj[0] = args;
16007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16008 if (!SWIG_IsOK(res1)) {
16009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16010 }
16011 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 result = (int)(arg1)->GetPollingMin();
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 resultobj = SWIG_From_int(static_cast< int >(result));
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16026 PyObject *resultobj = 0;
16027 wxJoystick *arg1 = (wxJoystick *) 0 ;
16028 int result;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 PyObject *swig_obj[1] ;
16032
16033 if (!args) SWIG_fail;
16034 swig_obj[0] = args;
16035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16036 if (!SWIG_IsOK(res1)) {
16037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16038 }
16039 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 result = (int)(arg1)->GetPollingMax();
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 resultobj = SWIG_From_int(static_cast< int >(result));
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16054 PyObject *resultobj = 0;
16055 wxJoystick *arg1 = (wxJoystick *) 0 ;
16056 int result;
16057 void *argp1 = 0 ;
16058 int res1 = 0 ;
16059 PyObject *swig_obj[1] ;
16060
16061 if (!args) SWIG_fail;
16062 swig_obj[0] = args;
16063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16064 if (!SWIG_IsOK(res1)) {
16065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16066 }
16067 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16068 {
16069 PyThreadState* __tstate = wxPyBeginAllowThreads();
16070 result = (int)(arg1)->GetRudderMin();
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 resultobj = SWIG_From_int(static_cast< int >(result));
16075 return resultobj;
16076 fail:
16077 return NULL;
16078 }
16079
16080
16081 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16082 PyObject *resultobj = 0;
16083 wxJoystick *arg1 = (wxJoystick *) 0 ;
16084 int result;
16085 void *argp1 = 0 ;
16086 int res1 = 0 ;
16087 PyObject *swig_obj[1] ;
16088
16089 if (!args) SWIG_fail;
16090 swig_obj[0] = args;
16091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16092 if (!SWIG_IsOK(res1)) {
16093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16094 }
16095 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 result = (int)(arg1)->GetRudderMax();
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 resultobj = SWIG_From_int(static_cast< int >(result));
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16110 PyObject *resultobj = 0;
16111 wxJoystick *arg1 = (wxJoystick *) 0 ;
16112 int result;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 PyObject *swig_obj[1] ;
16116
16117 if (!args) SWIG_fail;
16118 swig_obj[0] = args;
16119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16120 if (!SWIG_IsOK(res1)) {
16121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16122 }
16123 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 result = (int)(arg1)->GetUMin();
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 resultobj = SWIG_From_int(static_cast< int >(result));
16131 return resultobj;
16132 fail:
16133 return NULL;
16134 }
16135
16136
16137 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16138 PyObject *resultobj = 0;
16139 wxJoystick *arg1 = (wxJoystick *) 0 ;
16140 int result;
16141 void *argp1 = 0 ;
16142 int res1 = 0 ;
16143 PyObject *swig_obj[1] ;
16144
16145 if (!args) SWIG_fail;
16146 swig_obj[0] = args;
16147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16148 if (!SWIG_IsOK(res1)) {
16149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16150 }
16151 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16152 {
16153 PyThreadState* __tstate = wxPyBeginAllowThreads();
16154 result = (int)(arg1)->GetUMax();
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 resultobj = SWIG_From_int(static_cast< int >(result));
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16166 PyObject *resultobj = 0;
16167 wxJoystick *arg1 = (wxJoystick *) 0 ;
16168 int result;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 PyObject *swig_obj[1] ;
16172
16173 if (!args) SWIG_fail;
16174 swig_obj[0] = args;
16175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16178 }
16179 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16180 {
16181 PyThreadState* __tstate = wxPyBeginAllowThreads();
16182 result = (int)(arg1)->GetVMin();
16183 wxPyEndAllowThreads(__tstate);
16184 if (PyErr_Occurred()) SWIG_fail;
16185 }
16186 resultobj = SWIG_From_int(static_cast< int >(result));
16187 return resultobj;
16188 fail:
16189 return NULL;
16190 }
16191
16192
16193 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16194 PyObject *resultobj = 0;
16195 wxJoystick *arg1 = (wxJoystick *) 0 ;
16196 int result;
16197 void *argp1 = 0 ;
16198 int res1 = 0 ;
16199 PyObject *swig_obj[1] ;
16200
16201 if (!args) SWIG_fail;
16202 swig_obj[0] = args;
16203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16204 if (!SWIG_IsOK(res1)) {
16205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16206 }
16207 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16208 {
16209 PyThreadState* __tstate = wxPyBeginAllowThreads();
16210 result = (int)(arg1)->GetVMax();
16211 wxPyEndAllowThreads(__tstate);
16212 if (PyErr_Occurred()) SWIG_fail;
16213 }
16214 resultobj = SWIG_From_int(static_cast< int >(result));
16215 return resultobj;
16216 fail:
16217 return NULL;
16218 }
16219
16220
16221 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16222 PyObject *resultobj = 0;
16223 wxJoystick *arg1 = (wxJoystick *) 0 ;
16224 bool result;
16225 void *argp1 = 0 ;
16226 int res1 = 0 ;
16227 PyObject *swig_obj[1] ;
16228
16229 if (!args) SWIG_fail;
16230 swig_obj[0] = args;
16231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16232 if (!SWIG_IsOK(res1)) {
16233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16234 }
16235 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16236 {
16237 PyThreadState* __tstate = wxPyBeginAllowThreads();
16238 result = (bool)(arg1)->HasRudder();
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 {
16243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16244 }
16245 return resultobj;
16246 fail:
16247 return NULL;
16248 }
16249
16250
16251 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16252 PyObject *resultobj = 0;
16253 wxJoystick *arg1 = (wxJoystick *) 0 ;
16254 bool result;
16255 void *argp1 = 0 ;
16256 int res1 = 0 ;
16257 PyObject *swig_obj[1] ;
16258
16259 if (!args) SWIG_fail;
16260 swig_obj[0] = args;
16261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16262 if (!SWIG_IsOK(res1)) {
16263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16264 }
16265 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16266 {
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 result = (bool)(arg1)->HasZ();
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16274 }
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16282 PyObject *resultobj = 0;
16283 wxJoystick *arg1 = (wxJoystick *) 0 ;
16284 bool result;
16285 void *argp1 = 0 ;
16286 int res1 = 0 ;
16287 PyObject *swig_obj[1] ;
16288
16289 if (!args) SWIG_fail;
16290 swig_obj[0] = args;
16291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16292 if (!SWIG_IsOK(res1)) {
16293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16294 }
16295 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = (bool)(arg1)->HasU();
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 {
16303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16304 }
16305 return resultobj;
16306 fail:
16307 return NULL;
16308 }
16309
16310
16311 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16312 PyObject *resultobj = 0;
16313 wxJoystick *arg1 = (wxJoystick *) 0 ;
16314 bool result;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 PyObject *swig_obj[1] ;
16318
16319 if (!args) SWIG_fail;
16320 swig_obj[0] = args;
16321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16322 if (!SWIG_IsOK(res1)) {
16323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16324 }
16325 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16326 {
16327 PyThreadState* __tstate = wxPyBeginAllowThreads();
16328 result = (bool)(arg1)->HasV();
16329 wxPyEndAllowThreads(__tstate);
16330 if (PyErr_Occurred()) SWIG_fail;
16331 }
16332 {
16333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16334 }
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16342 PyObject *resultobj = 0;
16343 wxJoystick *arg1 = (wxJoystick *) 0 ;
16344 bool result;
16345 void *argp1 = 0 ;
16346 int res1 = 0 ;
16347 PyObject *swig_obj[1] ;
16348
16349 if (!args) SWIG_fail;
16350 swig_obj[0] = args;
16351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16352 if (!SWIG_IsOK(res1)) {
16353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16354 }
16355 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 result = (bool)(arg1)->HasPOV();
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 {
16363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16364 }
16365 return resultobj;
16366 fail:
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16372 PyObject *resultobj = 0;
16373 wxJoystick *arg1 = (wxJoystick *) 0 ;
16374 bool result;
16375 void *argp1 = 0 ;
16376 int res1 = 0 ;
16377 PyObject *swig_obj[1] ;
16378
16379 if (!args) SWIG_fail;
16380 swig_obj[0] = args;
16381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16384 }
16385 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16386 {
16387 PyThreadState* __tstate = wxPyBeginAllowThreads();
16388 result = (bool)(arg1)->HasPOV4Dir();
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 {
16393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16394 }
16395 return resultobj;
16396 fail:
16397 return NULL;
16398 }
16399
16400
16401 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16402 PyObject *resultobj = 0;
16403 wxJoystick *arg1 = (wxJoystick *) 0 ;
16404 bool result;
16405 void *argp1 = 0 ;
16406 int res1 = 0 ;
16407 PyObject *swig_obj[1] ;
16408
16409 if (!args) SWIG_fail;
16410 swig_obj[0] = args;
16411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16412 if (!SWIG_IsOK(res1)) {
16413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16414 }
16415 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16416 {
16417 PyThreadState* __tstate = wxPyBeginAllowThreads();
16418 result = (bool)(arg1)->HasPOVCTS();
16419 wxPyEndAllowThreads(__tstate);
16420 if (PyErr_Occurred()) SWIG_fail;
16421 }
16422 {
16423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16424 }
16425 return resultobj;
16426 fail:
16427 return NULL;
16428 }
16429
16430
16431 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16432 PyObject *resultobj = 0;
16433 wxJoystick *arg1 = (wxJoystick *) 0 ;
16434 wxWindow *arg2 = (wxWindow *) 0 ;
16435 int arg3 = (int) 0 ;
16436 bool result;
16437 void *argp1 = 0 ;
16438 int res1 = 0 ;
16439 void *argp2 = 0 ;
16440 int res2 = 0 ;
16441 int val3 ;
16442 int ecode3 = 0 ;
16443 PyObject * obj0 = 0 ;
16444 PyObject * obj1 = 0 ;
16445 PyObject * obj2 = 0 ;
16446 char * kwnames[] = {
16447 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16448 };
16449
16450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16452 if (!SWIG_IsOK(res1)) {
16453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16454 }
16455 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16457 if (!SWIG_IsOK(res2)) {
16458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16459 }
16460 arg2 = reinterpret_cast< wxWindow * >(argp2);
16461 if (obj2) {
16462 ecode3 = SWIG_AsVal_int(obj2, &val3);
16463 if (!SWIG_IsOK(ecode3)) {
16464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16465 }
16466 arg3 = static_cast< int >(val3);
16467 }
16468 {
16469 PyThreadState* __tstate = wxPyBeginAllowThreads();
16470 result = (bool)(arg1)->SetCapture(arg2,arg3);
16471 wxPyEndAllowThreads(__tstate);
16472 if (PyErr_Occurred()) SWIG_fail;
16473 }
16474 {
16475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16476 }
16477 return resultobj;
16478 fail:
16479 return NULL;
16480 }
16481
16482
16483 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16484 PyObject *resultobj = 0;
16485 wxJoystick *arg1 = (wxJoystick *) 0 ;
16486 bool result;
16487 void *argp1 = 0 ;
16488 int res1 = 0 ;
16489 PyObject *swig_obj[1] ;
16490
16491 if (!args) SWIG_fail;
16492 swig_obj[0] = args;
16493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16494 if (!SWIG_IsOK(res1)) {
16495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16496 }
16497 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 result = (bool)(arg1)->ReleaseCapture();
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 {
16505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16506 }
16507 return resultobj;
16508 fail:
16509 return NULL;
16510 }
16511
16512
16513 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16514 PyObject *obj;
16515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16516 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16517 return SWIG_Py_Void();
16518 }
16519
16520 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16521 return SWIG_Python_InitShadowInstance(args);
16522 }
16523
16524 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16525 PyObject *resultobj = 0;
16526 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16527 int arg2 = (int) 0 ;
16528 int arg3 = (int) wxJOYSTICK1 ;
16529 int arg4 = (int) 0 ;
16530 wxJoystickEvent *result = 0 ;
16531 int val1 ;
16532 int ecode1 = 0 ;
16533 int val2 ;
16534 int ecode2 = 0 ;
16535 int val3 ;
16536 int ecode3 = 0 ;
16537 int val4 ;
16538 int ecode4 = 0 ;
16539 PyObject * obj0 = 0 ;
16540 PyObject * obj1 = 0 ;
16541 PyObject * obj2 = 0 ;
16542 PyObject * obj3 = 0 ;
16543 char * kwnames[] = {
16544 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16545 };
16546
16547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16548 if (obj0) {
16549 ecode1 = SWIG_AsVal_int(obj0, &val1);
16550 if (!SWIG_IsOK(ecode1)) {
16551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16552 }
16553 arg1 = static_cast< wxEventType >(val1);
16554 }
16555 if (obj1) {
16556 ecode2 = SWIG_AsVal_int(obj1, &val2);
16557 if (!SWIG_IsOK(ecode2)) {
16558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16559 }
16560 arg2 = static_cast< int >(val2);
16561 }
16562 if (obj2) {
16563 ecode3 = SWIG_AsVal_int(obj2, &val3);
16564 if (!SWIG_IsOK(ecode3)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16566 }
16567 arg3 = static_cast< int >(val3);
16568 }
16569 if (obj3) {
16570 ecode4 = SWIG_AsVal_int(obj3, &val4);
16571 if (!SWIG_IsOK(ecode4)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16573 }
16574 arg4 = static_cast< int >(val4);
16575 }
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16590 PyObject *resultobj = 0;
16591 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16592 wxPoint result;
16593 void *argp1 = 0 ;
16594 int res1 = 0 ;
16595 PyObject *swig_obj[1] ;
16596
16597 if (!args) SWIG_fail;
16598 swig_obj[0] = args;
16599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16600 if (!SWIG_IsOK(res1)) {
16601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16602 }
16603 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16604 {
16605 PyThreadState* __tstate = wxPyBeginAllowThreads();
16606 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16618 PyObject *resultobj = 0;
16619 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16620 int result;
16621 void *argp1 = 0 ;
16622 int res1 = 0 ;
16623 PyObject *swig_obj[1] ;
16624
16625 if (!args) SWIG_fail;
16626 swig_obj[0] = args;
16627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16630 }
16631 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_From_int(static_cast< int >(result));
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16646 PyObject *resultobj = 0;
16647 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16648 int result;
16649 void *argp1 = 0 ;
16650 int res1 = 0 ;
16651 PyObject *swig_obj[1] ;
16652
16653 if (!args) SWIG_fail;
16654 swig_obj[0] = args;
16655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16658 }
16659 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 resultobj = SWIG_From_int(static_cast< int >(result));
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16674 PyObject *resultobj = 0;
16675 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16676 int result;
16677 void *argp1 = 0 ;
16678 int res1 = 0 ;
16679 PyObject *swig_obj[1] ;
16680
16681 if (!args) SWIG_fail;
16682 swig_obj[0] = args;
16683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16684 if (!SWIG_IsOK(res1)) {
16685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16686 }
16687 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16688 {
16689 PyThreadState* __tstate = wxPyBeginAllowThreads();
16690 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16691 wxPyEndAllowThreads(__tstate);
16692 if (PyErr_Occurred()) SWIG_fail;
16693 }
16694 resultobj = SWIG_From_int(static_cast< int >(result));
16695 return resultobj;
16696 fail:
16697 return NULL;
16698 }
16699
16700
16701 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16702 PyObject *resultobj = 0;
16703 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16704 int result;
16705 void *argp1 = 0 ;
16706 int res1 = 0 ;
16707 PyObject *swig_obj[1] ;
16708
16709 if (!args) SWIG_fail;
16710 swig_obj[0] = args;
16711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16712 if (!SWIG_IsOK(res1)) {
16713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16714 }
16715 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16716 {
16717 PyThreadState* __tstate = wxPyBeginAllowThreads();
16718 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 resultobj = SWIG_From_int(static_cast< int >(result));
16723 return resultobj;
16724 fail:
16725 return NULL;
16726 }
16727
16728
16729 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16730 PyObject *resultobj = 0;
16731 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16732 int arg2 ;
16733 void *argp1 = 0 ;
16734 int res1 = 0 ;
16735 int val2 ;
16736 int ecode2 = 0 ;
16737 PyObject * obj0 = 0 ;
16738 PyObject * obj1 = 0 ;
16739 char * kwnames[] = {
16740 (char *) "self",(char *) "stick", NULL
16741 };
16742
16743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16745 if (!SWIG_IsOK(res1)) {
16746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16747 }
16748 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16749 ecode2 = SWIG_AsVal_int(obj1, &val2);
16750 if (!SWIG_IsOK(ecode2)) {
16751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16752 }
16753 arg2 = static_cast< int >(val2);
16754 {
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 (arg1)->SetJoystick(arg2);
16757 wxPyEndAllowThreads(__tstate);
16758 if (PyErr_Occurred()) SWIG_fail;
16759 }
16760 resultobj = SWIG_Py_Void();
16761 return resultobj;
16762 fail:
16763 return NULL;
16764 }
16765
16766
16767 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16768 PyObject *resultobj = 0;
16769 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16770 int arg2 ;
16771 void *argp1 = 0 ;
16772 int res1 = 0 ;
16773 int val2 ;
16774 int ecode2 = 0 ;
16775 PyObject * obj0 = 0 ;
16776 PyObject * obj1 = 0 ;
16777 char * kwnames[] = {
16778 (char *) "self",(char *) "state", NULL
16779 };
16780
16781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16783 if (!SWIG_IsOK(res1)) {
16784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16785 }
16786 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16787 ecode2 = SWIG_AsVal_int(obj1, &val2);
16788 if (!SWIG_IsOK(ecode2)) {
16789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16790 }
16791 arg2 = static_cast< int >(val2);
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 (arg1)->SetButtonState(arg2);
16795 wxPyEndAllowThreads(__tstate);
16796 if (PyErr_Occurred()) SWIG_fail;
16797 }
16798 resultobj = SWIG_Py_Void();
16799 return resultobj;
16800 fail:
16801 return NULL;
16802 }
16803
16804
16805 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj = 0;
16807 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16808 int arg2 ;
16809 void *argp1 = 0 ;
16810 int res1 = 0 ;
16811 int val2 ;
16812 int ecode2 = 0 ;
16813 PyObject * obj0 = 0 ;
16814 PyObject * obj1 = 0 ;
16815 char * kwnames[] = {
16816 (char *) "self",(char *) "change", NULL
16817 };
16818
16819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16821 if (!SWIG_IsOK(res1)) {
16822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16823 }
16824 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16825 ecode2 = SWIG_AsVal_int(obj1, &val2);
16826 if (!SWIG_IsOK(ecode2)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16828 }
16829 arg2 = static_cast< int >(val2);
16830 {
16831 PyThreadState* __tstate = wxPyBeginAllowThreads();
16832 (arg1)->SetButtonChange(arg2);
16833 wxPyEndAllowThreads(__tstate);
16834 if (PyErr_Occurred()) SWIG_fail;
16835 }
16836 resultobj = SWIG_Py_Void();
16837 return resultobj;
16838 fail:
16839 return NULL;
16840 }
16841
16842
16843 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16844 PyObject *resultobj = 0;
16845 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16846 wxPoint *arg2 = 0 ;
16847 void *argp1 = 0 ;
16848 int res1 = 0 ;
16849 wxPoint temp2 ;
16850 PyObject * obj0 = 0 ;
16851 PyObject * obj1 = 0 ;
16852 char * kwnames[] = {
16853 (char *) "self",(char *) "pos", NULL
16854 };
16855
16856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16858 if (!SWIG_IsOK(res1)) {
16859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16860 }
16861 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16862 {
16863 arg2 = &temp2;
16864 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16865 }
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 (arg1)->SetPosition((wxPoint const &)*arg2);
16869 wxPyEndAllowThreads(__tstate);
16870 if (PyErr_Occurred()) SWIG_fail;
16871 }
16872 resultobj = SWIG_Py_Void();
16873 return resultobj;
16874 fail:
16875 return NULL;
16876 }
16877
16878
16879 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16880 PyObject *resultobj = 0;
16881 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16882 int arg2 ;
16883 void *argp1 = 0 ;
16884 int res1 = 0 ;
16885 int val2 ;
16886 int ecode2 = 0 ;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 char * kwnames[] = {
16890 (char *) "self",(char *) "zPos", NULL
16891 };
16892
16893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16895 if (!SWIG_IsOK(res1)) {
16896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16897 }
16898 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16899 ecode2 = SWIG_AsVal_int(obj1, &val2);
16900 if (!SWIG_IsOK(ecode2)) {
16901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16902 }
16903 arg2 = static_cast< int >(val2);
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 (arg1)->SetZPosition(arg2);
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 resultobj = SWIG_Py_Void();
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16918 PyObject *resultobj = 0;
16919 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16920 bool result;
16921 void *argp1 = 0 ;
16922 int res1 = 0 ;
16923 PyObject *swig_obj[1] ;
16924
16925 if (!args) SWIG_fail;
16926 swig_obj[0] = args;
16927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16928 if (!SWIG_IsOK(res1)) {
16929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16930 }
16931 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16932 {
16933 PyThreadState* __tstate = wxPyBeginAllowThreads();
16934 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16935 wxPyEndAllowThreads(__tstate);
16936 if (PyErr_Occurred()) SWIG_fail;
16937 }
16938 {
16939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16940 }
16941 return resultobj;
16942 fail:
16943 return NULL;
16944 }
16945
16946
16947 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16948 PyObject *resultobj = 0;
16949 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16950 bool result;
16951 void *argp1 = 0 ;
16952 int res1 = 0 ;
16953 PyObject *swig_obj[1] ;
16954
16955 if (!args) SWIG_fail;
16956 swig_obj[0] = args;
16957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16958 if (!SWIG_IsOK(res1)) {
16959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16960 }
16961 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16962 {
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 {
16969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16970 }
16971 return resultobj;
16972 fail:
16973 return NULL;
16974 }
16975
16976
16977 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16978 PyObject *resultobj = 0;
16979 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16980 bool result;
16981 void *argp1 = 0 ;
16982 int res1 = 0 ;
16983 PyObject *swig_obj[1] ;
16984
16985 if (!args) SWIG_fail;
16986 swig_obj[0] = args;
16987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16988 if (!SWIG_IsOK(res1)) {
16989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16990 }
16991 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16992 {
16993 PyThreadState* __tstate = wxPyBeginAllowThreads();
16994 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16995 wxPyEndAllowThreads(__tstate);
16996 if (PyErr_Occurred()) SWIG_fail;
16997 }
16998 {
16999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17000 }
17001 return resultobj;
17002 fail:
17003 return NULL;
17004 }
17005
17006
17007 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj = 0;
17009 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17010 int arg2 = (int) wxJOY_BUTTON_ANY ;
17011 bool result;
17012 void *argp1 = 0 ;
17013 int res1 = 0 ;
17014 int val2 ;
17015 int ecode2 = 0 ;
17016 PyObject * obj0 = 0 ;
17017 PyObject * obj1 = 0 ;
17018 char * kwnames[] = {
17019 (char *) "self",(char *) "but", NULL
17020 };
17021
17022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17024 if (!SWIG_IsOK(res1)) {
17025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17026 }
17027 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17028 if (obj1) {
17029 ecode2 = SWIG_AsVal_int(obj1, &val2);
17030 if (!SWIG_IsOK(ecode2)) {
17031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17032 }
17033 arg2 = static_cast< int >(val2);
17034 }
17035 {
17036 PyThreadState* __tstate = wxPyBeginAllowThreads();
17037 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17038 wxPyEndAllowThreads(__tstate);
17039 if (PyErr_Occurred()) SWIG_fail;
17040 }
17041 {
17042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17043 }
17044 return resultobj;
17045 fail:
17046 return NULL;
17047 }
17048
17049
17050 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17051 PyObject *resultobj = 0;
17052 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17053 int arg2 = (int) wxJOY_BUTTON_ANY ;
17054 bool result;
17055 void *argp1 = 0 ;
17056 int res1 = 0 ;
17057 int val2 ;
17058 int ecode2 = 0 ;
17059 PyObject * obj0 = 0 ;
17060 PyObject * obj1 = 0 ;
17061 char * kwnames[] = {
17062 (char *) "self",(char *) "but", NULL
17063 };
17064
17065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17067 if (!SWIG_IsOK(res1)) {
17068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17069 }
17070 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17071 if (obj1) {
17072 ecode2 = SWIG_AsVal_int(obj1, &val2);
17073 if (!SWIG_IsOK(ecode2)) {
17074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17075 }
17076 arg2 = static_cast< int >(val2);
17077 }
17078 {
17079 PyThreadState* __tstate = wxPyBeginAllowThreads();
17080 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17081 wxPyEndAllowThreads(__tstate);
17082 if (PyErr_Occurred()) SWIG_fail;
17083 }
17084 {
17085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17086 }
17087 return resultobj;
17088 fail:
17089 return NULL;
17090 }
17091
17092
17093 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17094 PyObject *resultobj = 0;
17095 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17096 int arg2 = (int) wxJOY_BUTTON_ANY ;
17097 bool result;
17098 void *argp1 = 0 ;
17099 int res1 = 0 ;
17100 int val2 ;
17101 int ecode2 = 0 ;
17102 PyObject * obj0 = 0 ;
17103 PyObject * obj1 = 0 ;
17104 char * kwnames[] = {
17105 (char *) "self",(char *) "but", NULL
17106 };
17107
17108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17110 if (!SWIG_IsOK(res1)) {
17111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17112 }
17113 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17114 if (obj1) {
17115 ecode2 = SWIG_AsVal_int(obj1, &val2);
17116 if (!SWIG_IsOK(ecode2)) {
17117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17118 }
17119 arg2 = static_cast< int >(val2);
17120 }
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 {
17128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17129 }
17130 return resultobj;
17131 fail:
17132 return NULL;
17133 }
17134
17135
17136 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17137 PyObject *obj;
17138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17139 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17140 return SWIG_Py_Void();
17141 }
17142
17143 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17144 return SWIG_Python_InitShadowInstance(args);
17145 }
17146
17147 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17148 PyObject *resultobj = 0;
17149 wxString const &arg1_defvalue = wxPyEmptyString ;
17150 wxString *arg1 = (wxString *) &arg1_defvalue ;
17151 wxSound *result = 0 ;
17152 bool temp1 = false ;
17153 PyObject * obj0 = 0 ;
17154 char * kwnames[] = {
17155 (char *) "fileName", NULL
17156 };
17157
17158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17159 if (obj0) {
17160 {
17161 arg1 = wxString_in_helper(obj0);
17162 if (arg1 == NULL) SWIG_fail;
17163 temp1 = true;
17164 }
17165 }
17166 {
17167 if (!wxPyCheckForApp()) SWIG_fail;
17168 PyThreadState* __tstate = wxPyBeginAllowThreads();
17169 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17174 {
17175 if (temp1)
17176 delete arg1;
17177 }
17178 return resultobj;
17179 fail:
17180 {
17181 if (temp1)
17182 delete arg1;
17183 }
17184 return NULL;
17185 }
17186
17187
17188 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17189 PyObject *resultobj = 0;
17190 PyObject *arg1 = (PyObject *) 0 ;
17191 wxSound *result = 0 ;
17192 PyObject * obj0 = 0 ;
17193 char * kwnames[] = {
17194 (char *) "data", NULL
17195 };
17196
17197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17198 arg1 = obj0;
17199 {
17200 if (!wxPyCheckForApp()) SWIG_fail;
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 result = (wxSound *)new_wxSound(arg1);
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17207 return resultobj;
17208 fail:
17209 return NULL;
17210 }
17211
17212
17213 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17214 PyObject *resultobj = 0;
17215 wxSound *arg1 = (wxSound *) 0 ;
17216 void *argp1 = 0 ;
17217 int res1 = 0 ;
17218 PyObject *swig_obj[1] ;
17219
17220 if (!args) SWIG_fail;
17221 swig_obj[0] = args;
17222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17223 if (!SWIG_IsOK(res1)) {
17224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17225 }
17226 arg1 = reinterpret_cast< wxSound * >(argp1);
17227 {
17228 PyThreadState* __tstate = wxPyBeginAllowThreads();
17229 delete arg1;
17230
17231 wxPyEndAllowThreads(__tstate);
17232 if (PyErr_Occurred()) SWIG_fail;
17233 }
17234 resultobj = SWIG_Py_Void();
17235 return resultobj;
17236 fail:
17237 return NULL;
17238 }
17239
17240
17241 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17242 PyObject *resultobj = 0;
17243 wxSound *arg1 = (wxSound *) 0 ;
17244 wxString *arg2 = 0 ;
17245 bool result;
17246 void *argp1 = 0 ;
17247 int res1 = 0 ;
17248 bool temp2 = false ;
17249 PyObject * obj0 = 0 ;
17250 PyObject * obj1 = 0 ;
17251 char * kwnames[] = {
17252 (char *) "self",(char *) "fileName", NULL
17253 };
17254
17255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17257 if (!SWIG_IsOK(res1)) {
17258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17259 }
17260 arg1 = reinterpret_cast< wxSound * >(argp1);
17261 {
17262 arg2 = wxString_in_helper(obj1);
17263 if (arg2 == NULL) SWIG_fail;
17264 temp2 = true;
17265 }
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (bool)(arg1)->Create((wxString const &)*arg2);
17269 wxPyEndAllowThreads(__tstate);
17270 if (PyErr_Occurred()) SWIG_fail;
17271 }
17272 {
17273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17274 }
17275 {
17276 if (temp2)
17277 delete arg2;
17278 }
17279 return resultobj;
17280 fail:
17281 {
17282 if (temp2)
17283 delete arg2;
17284 }
17285 return NULL;
17286 }
17287
17288
17289 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17290 PyObject *resultobj = 0;
17291 wxSound *arg1 = (wxSound *) 0 ;
17292 PyObject *arg2 = (PyObject *) 0 ;
17293 bool result;
17294 void *argp1 = 0 ;
17295 int res1 = 0 ;
17296 PyObject * obj0 = 0 ;
17297 PyObject * obj1 = 0 ;
17298 char * kwnames[] = {
17299 (char *) "self",(char *) "data", NULL
17300 };
17301
17302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17304 if (!SWIG_IsOK(res1)) {
17305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17306 }
17307 arg1 = reinterpret_cast< wxSound * >(argp1);
17308 arg2 = obj1;
17309 {
17310 PyThreadState* __tstate = wxPyBeginAllowThreads();
17311 result = (bool)wxSound_CreateFromData(arg1,arg2);
17312 wxPyEndAllowThreads(__tstate);
17313 if (PyErr_Occurred()) SWIG_fail;
17314 }
17315 {
17316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17317 }
17318 return resultobj;
17319 fail:
17320 return NULL;
17321 }
17322
17323
17324 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17325 PyObject *resultobj = 0;
17326 wxSound *arg1 = (wxSound *) 0 ;
17327 bool result;
17328 void *argp1 = 0 ;
17329 int res1 = 0 ;
17330 PyObject *swig_obj[1] ;
17331
17332 if (!args) SWIG_fail;
17333 swig_obj[0] = args;
17334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17335 if (!SWIG_IsOK(res1)) {
17336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17337 }
17338 arg1 = reinterpret_cast< wxSound * >(argp1);
17339 {
17340 PyThreadState* __tstate = wxPyBeginAllowThreads();
17341 result = (bool)(arg1)->IsOk();
17342 wxPyEndAllowThreads(__tstate);
17343 if (PyErr_Occurred()) SWIG_fail;
17344 }
17345 {
17346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17347 }
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17355 PyObject *resultobj = 0;
17356 wxSound *arg1 = (wxSound *) 0 ;
17357 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17358 bool result;
17359 void *argp1 = 0 ;
17360 int res1 = 0 ;
17361 unsigned int val2 ;
17362 int ecode2 = 0 ;
17363 PyObject * obj0 = 0 ;
17364 PyObject * obj1 = 0 ;
17365 char * kwnames[] = {
17366 (char *) "self",(char *) "flags", NULL
17367 };
17368
17369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17371 if (!SWIG_IsOK(res1)) {
17372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17373 }
17374 arg1 = reinterpret_cast< wxSound * >(argp1);
17375 if (obj1) {
17376 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17377 if (!SWIG_IsOK(ecode2)) {
17378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17379 }
17380 arg2 = static_cast< unsigned int >(val2);
17381 }
17382 {
17383 if (!wxPyCheckForApp()) SWIG_fail;
17384 PyThreadState* __tstate = wxPyBeginAllowThreads();
17385 result = (bool)((wxSound const *)arg1)->Play(arg2);
17386 wxPyEndAllowThreads(__tstate);
17387 if (PyErr_Occurred()) SWIG_fail;
17388 }
17389 {
17390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17391 }
17392 return resultobj;
17393 fail:
17394 return NULL;
17395 }
17396
17397
17398 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17399 PyObject *resultobj = 0;
17400 wxString *arg1 = 0 ;
17401 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17402 bool result;
17403 bool temp1 = false ;
17404 unsigned int val2 ;
17405 int ecode2 = 0 ;
17406 PyObject * obj0 = 0 ;
17407 PyObject * obj1 = 0 ;
17408 char * kwnames[] = {
17409 (char *) "filename",(char *) "flags", NULL
17410 };
17411
17412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17413 {
17414 arg1 = wxString_in_helper(obj0);
17415 if (arg1 == NULL) SWIG_fail;
17416 temp1 = true;
17417 }
17418 if (obj1) {
17419 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17420 if (!SWIG_IsOK(ecode2)) {
17421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17422 }
17423 arg2 = static_cast< unsigned int >(val2);
17424 }
17425 {
17426 if (!wxPyCheckForApp()) SWIG_fail;
17427 PyThreadState* __tstate = wxPyBeginAllowThreads();
17428 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17429 wxPyEndAllowThreads(__tstate);
17430 if (PyErr_Occurred()) SWIG_fail;
17431 }
17432 {
17433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17434 }
17435 {
17436 if (temp1)
17437 delete arg1;
17438 }
17439 return resultobj;
17440 fail:
17441 {
17442 if (temp1)
17443 delete arg1;
17444 }
17445 return NULL;
17446 }
17447
17448
17449 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17450 PyObject *resultobj = 0;
17451
17452 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17453 {
17454 if (!wxPyCheckForApp()) SWIG_fail;
17455 PyThreadState* __tstate = wxPyBeginAllowThreads();
17456 wxSound::Stop();
17457 wxPyEndAllowThreads(__tstate);
17458 if (PyErr_Occurred()) SWIG_fail;
17459 }
17460 resultobj = SWIG_Py_Void();
17461 return resultobj;
17462 fail:
17463 return NULL;
17464 }
17465
17466
17467 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 PyObject *obj;
17469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17470 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17471 return SWIG_Py_Void();
17472 }
17473
17474 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17475 return SWIG_Python_InitShadowInstance(args);
17476 }
17477
17478 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17479 PyObject *resultobj = 0;
17480 wxString *arg1 = 0 ;
17481 wxString *arg2 = 0 ;
17482 wxString *arg3 = 0 ;
17483 wxString *arg4 = 0 ;
17484 wxFileTypeInfo *result = 0 ;
17485 bool temp1 = false ;
17486 bool temp2 = false ;
17487 bool temp3 = false ;
17488 bool temp4 = false ;
17489 PyObject * obj0 = 0 ;
17490 PyObject * obj1 = 0 ;
17491 PyObject * obj2 = 0 ;
17492 PyObject * obj3 = 0 ;
17493 char * kwnames[] = {
17494 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17495 };
17496
17497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17498 {
17499 arg1 = wxString_in_helper(obj0);
17500 if (arg1 == NULL) SWIG_fail;
17501 temp1 = true;
17502 }
17503 {
17504 arg2 = wxString_in_helper(obj1);
17505 if (arg2 == NULL) SWIG_fail;
17506 temp2 = true;
17507 }
17508 {
17509 arg3 = wxString_in_helper(obj2);
17510 if (arg3 == NULL) SWIG_fail;
17511 temp3 = true;
17512 }
17513 {
17514 arg4 = wxString_in_helper(obj3);
17515 if (arg4 == NULL) SWIG_fail;
17516 temp4 = true;
17517 }
17518 {
17519 PyThreadState* __tstate = wxPyBeginAllowThreads();
17520 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17521 wxPyEndAllowThreads(__tstate);
17522 if (PyErr_Occurred()) SWIG_fail;
17523 }
17524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17525 {
17526 if (temp1)
17527 delete arg1;
17528 }
17529 {
17530 if (temp2)
17531 delete arg2;
17532 }
17533 {
17534 if (temp3)
17535 delete arg3;
17536 }
17537 {
17538 if (temp4)
17539 delete arg4;
17540 }
17541 return resultobj;
17542 fail:
17543 {
17544 if (temp1)
17545 delete arg1;
17546 }
17547 {
17548 if (temp2)
17549 delete arg2;
17550 }
17551 {
17552 if (temp3)
17553 delete arg3;
17554 }
17555 {
17556 if (temp4)
17557 delete arg4;
17558 }
17559 return NULL;
17560 }
17561
17562
17563 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17564 PyObject *resultobj = 0;
17565 wxArrayString *arg1 = 0 ;
17566 wxFileTypeInfo *result = 0 ;
17567 bool temp1 = false ;
17568 PyObject * obj0 = 0 ;
17569 char * kwnames[] = {
17570 (char *) "sArray", NULL
17571 };
17572
17573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17574 {
17575 if (! PySequence_Check(obj0)) {
17576 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17577 SWIG_fail;
17578 }
17579 arg1 = new wxArrayString;
17580 temp1 = true;
17581 int i, len=PySequence_Length(obj0);
17582 for (i=0; i<len; i++) {
17583 PyObject* item = PySequence_GetItem(obj0, i);
17584 wxString* s = wxString_in_helper(item);
17585 if (PyErr_Occurred()) SWIG_fail;
17586 arg1->Add(*s);
17587 delete s;
17588 Py_DECREF(item);
17589 }
17590 }
17591 {
17592 PyThreadState* __tstate = wxPyBeginAllowThreads();
17593 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17598 {
17599 if (temp1) delete arg1;
17600 }
17601 return resultobj;
17602 fail:
17603 {
17604 if (temp1) delete arg1;
17605 }
17606 return NULL;
17607 }
17608
17609
17610 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17611 PyObject *resultobj = 0;
17612 wxFileTypeInfo *result = 0 ;
17613
17614 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17615 {
17616 PyThreadState* __tstate = wxPyBeginAllowThreads();
17617 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17618 wxPyEndAllowThreads(__tstate);
17619 if (PyErr_Occurred()) SWIG_fail;
17620 }
17621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17622 return resultobj;
17623 fail:
17624 return NULL;
17625 }
17626
17627
17628 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17629 PyObject *resultobj = 0;
17630 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17631 bool result;
17632 void *argp1 = 0 ;
17633 int res1 = 0 ;
17634 PyObject *swig_obj[1] ;
17635
17636 if (!args) SWIG_fail;
17637 swig_obj[0] = args;
17638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17639 if (!SWIG_IsOK(res1)) {
17640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17641 }
17642 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 {
17650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17651 }
17652 return resultobj;
17653 fail:
17654 return NULL;
17655 }
17656
17657
17658 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17659 PyObject *resultobj = 0;
17660 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17661 wxString *arg2 = 0 ;
17662 int arg3 = (int) 0 ;
17663 void *argp1 = 0 ;
17664 int res1 = 0 ;
17665 bool temp2 = false ;
17666 int val3 ;
17667 int ecode3 = 0 ;
17668 PyObject * obj0 = 0 ;
17669 PyObject * obj1 = 0 ;
17670 PyObject * obj2 = 0 ;
17671 char * kwnames[] = {
17672 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17673 };
17674
17675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17677 if (!SWIG_IsOK(res1)) {
17678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17679 }
17680 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17681 {
17682 arg2 = wxString_in_helper(obj1);
17683 if (arg2 == NULL) SWIG_fail;
17684 temp2 = true;
17685 }
17686 if (obj2) {
17687 ecode3 = SWIG_AsVal_int(obj2, &val3);
17688 if (!SWIG_IsOK(ecode3)) {
17689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17690 }
17691 arg3 = static_cast< int >(val3);
17692 }
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17696 wxPyEndAllowThreads(__tstate);
17697 if (PyErr_Occurred()) SWIG_fail;
17698 }
17699 resultobj = SWIG_Py_Void();
17700 {
17701 if (temp2)
17702 delete arg2;
17703 }
17704 return resultobj;
17705 fail:
17706 {
17707 if (temp2)
17708 delete arg2;
17709 }
17710 return NULL;
17711 }
17712
17713
17714 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj = 0;
17716 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17717 wxString *arg2 = 0 ;
17718 void *argp1 = 0 ;
17719 int res1 = 0 ;
17720 bool temp2 = false ;
17721 PyObject * obj0 = 0 ;
17722 PyObject * obj1 = 0 ;
17723 char * kwnames[] = {
17724 (char *) "self",(char *) "shortDesc", NULL
17725 };
17726
17727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17729 if (!SWIG_IsOK(res1)) {
17730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17731 }
17732 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17733 {
17734 arg2 = wxString_in_helper(obj1);
17735 if (arg2 == NULL) SWIG_fail;
17736 temp2 = true;
17737 }
17738 {
17739 PyThreadState* __tstate = wxPyBeginAllowThreads();
17740 (arg1)->SetShortDesc((wxString const &)*arg2);
17741 wxPyEndAllowThreads(__tstate);
17742 if (PyErr_Occurred()) SWIG_fail;
17743 }
17744 resultobj = SWIG_Py_Void();
17745 {
17746 if (temp2)
17747 delete arg2;
17748 }
17749 return resultobj;
17750 fail:
17751 {
17752 if (temp2)
17753 delete arg2;
17754 }
17755 return NULL;
17756 }
17757
17758
17759 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17760 PyObject *resultobj = 0;
17761 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17762 wxString *result = 0 ;
17763 void *argp1 = 0 ;
17764 int res1 = 0 ;
17765 PyObject *swig_obj[1] ;
17766
17767 if (!args) SWIG_fail;
17768 swig_obj[0] = args;
17769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17770 if (!SWIG_IsOK(res1)) {
17771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17772 }
17773 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17774 {
17775 PyThreadState* __tstate = wxPyBeginAllowThreads();
17776 {
17777 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17778 result = (wxString *) &_result_ref;
17779 }
17780 wxPyEndAllowThreads(__tstate);
17781 if (PyErr_Occurred()) SWIG_fail;
17782 }
17783 {
17784 #if wxUSE_UNICODE
17785 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17786 #else
17787 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17788 #endif
17789 }
17790 return resultobj;
17791 fail:
17792 return NULL;
17793 }
17794
17795
17796 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17797 PyObject *resultobj = 0;
17798 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17799 wxString *result = 0 ;
17800 void *argp1 = 0 ;
17801 int res1 = 0 ;
17802 PyObject *swig_obj[1] ;
17803
17804 if (!args) SWIG_fail;
17805 swig_obj[0] = args;
17806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17807 if (!SWIG_IsOK(res1)) {
17808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17809 }
17810 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 {
17814 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17815 result = (wxString *) &_result_ref;
17816 }
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 #if wxUSE_UNICODE
17822 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17823 #else
17824 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17825 #endif
17826 }
17827 return resultobj;
17828 fail:
17829 return NULL;
17830 }
17831
17832
17833 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17834 PyObject *resultobj = 0;
17835 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17836 wxString *result = 0 ;
17837 void *argp1 = 0 ;
17838 int res1 = 0 ;
17839 PyObject *swig_obj[1] ;
17840
17841 if (!args) SWIG_fail;
17842 swig_obj[0] = args;
17843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17844 if (!SWIG_IsOK(res1)) {
17845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17846 }
17847 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17848 {
17849 PyThreadState* __tstate = wxPyBeginAllowThreads();
17850 {
17851 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17852 result = (wxString *) &_result_ref;
17853 }
17854 wxPyEndAllowThreads(__tstate);
17855 if (PyErr_Occurred()) SWIG_fail;
17856 }
17857 {
17858 #if wxUSE_UNICODE
17859 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17860 #else
17861 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17862 #endif
17863 }
17864 return resultobj;
17865 fail:
17866 return NULL;
17867 }
17868
17869
17870 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17871 PyObject *resultobj = 0;
17872 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17873 wxString *result = 0 ;
17874 void *argp1 = 0 ;
17875 int res1 = 0 ;
17876 PyObject *swig_obj[1] ;
17877
17878 if (!args) SWIG_fail;
17879 swig_obj[0] = args;
17880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17881 if (!SWIG_IsOK(res1)) {
17882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17883 }
17884 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17885 {
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 {
17888 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17889 result = (wxString *) &_result_ref;
17890 }
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 {
17895 #if wxUSE_UNICODE
17896 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17897 #else
17898 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17899 #endif
17900 }
17901 return resultobj;
17902 fail:
17903 return NULL;
17904 }
17905
17906
17907 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17908 PyObject *resultobj = 0;
17909 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17910 wxString *result = 0 ;
17911 void *argp1 = 0 ;
17912 int res1 = 0 ;
17913 PyObject *swig_obj[1] ;
17914
17915 if (!args) SWIG_fail;
17916 swig_obj[0] = args;
17917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17918 if (!SWIG_IsOK(res1)) {
17919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17920 }
17921 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17922 {
17923 PyThreadState* __tstate = wxPyBeginAllowThreads();
17924 {
17925 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17926 result = (wxString *) &_result_ref;
17927 }
17928 wxPyEndAllowThreads(__tstate);
17929 if (PyErr_Occurred()) SWIG_fail;
17930 }
17931 {
17932 #if wxUSE_UNICODE
17933 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17934 #else
17935 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17936 #endif
17937 }
17938 return resultobj;
17939 fail:
17940 return NULL;
17941 }
17942
17943
17944 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17945 PyObject *resultobj = 0;
17946 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17947 wxArrayString *result = 0 ;
17948 void *argp1 = 0 ;
17949 int res1 = 0 ;
17950 PyObject *swig_obj[1] ;
17951
17952 if (!args) SWIG_fail;
17953 swig_obj[0] = args;
17954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17955 if (!SWIG_IsOK(res1)) {
17956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17957 }
17958 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17959 {
17960 PyThreadState* __tstate = wxPyBeginAllowThreads();
17961 {
17962 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17963 result = (wxArrayString *) &_result_ref;
17964 }
17965 wxPyEndAllowThreads(__tstate);
17966 if (PyErr_Occurred()) SWIG_fail;
17967 }
17968 {
17969 resultobj = wxArrayString2PyList_helper(*result);
17970 }
17971 return resultobj;
17972 fail:
17973 return NULL;
17974 }
17975
17976
17977 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17978 PyObject *resultobj = 0;
17979 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17980 size_t result;
17981 void *argp1 = 0 ;
17982 int res1 = 0 ;
17983 PyObject *swig_obj[1] ;
17984
17985 if (!args) SWIG_fail;
17986 swig_obj[0] = args;
17987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17988 if (!SWIG_IsOK(res1)) {
17989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17990 }
17991 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17992 {
17993 PyThreadState* __tstate = wxPyBeginAllowThreads();
17994 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17995 wxPyEndAllowThreads(__tstate);
17996 if (PyErr_Occurred()) SWIG_fail;
17997 }
17998 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17999 return resultobj;
18000 fail:
18001 return NULL;
18002 }
18003
18004
18005 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18006 PyObject *resultobj = 0;
18007 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18008 wxString *result = 0 ;
18009 void *argp1 = 0 ;
18010 int res1 = 0 ;
18011 PyObject *swig_obj[1] ;
18012
18013 if (!args) SWIG_fail;
18014 swig_obj[0] = args;
18015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18016 if (!SWIG_IsOK(res1)) {
18017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18018 }
18019 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 {
18023 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18024 result = (wxString *) &_result_ref;
18025 }
18026 wxPyEndAllowThreads(__tstate);
18027 if (PyErr_Occurred()) SWIG_fail;
18028 }
18029 {
18030 #if wxUSE_UNICODE
18031 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18032 #else
18033 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18034 #endif
18035 }
18036 return resultobj;
18037 fail:
18038 return NULL;
18039 }
18040
18041
18042 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18043 PyObject *resultobj = 0;
18044 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18045 int result;
18046 void *argp1 = 0 ;
18047 int res1 = 0 ;
18048 PyObject *swig_obj[1] ;
18049
18050 if (!args) SWIG_fail;
18051 swig_obj[0] = args;
18052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18053 if (!SWIG_IsOK(res1)) {
18054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18055 }
18056 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18057 {
18058 PyThreadState* __tstate = wxPyBeginAllowThreads();
18059 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18060 wxPyEndAllowThreads(__tstate);
18061 if (PyErr_Occurred()) SWIG_fail;
18062 }
18063 resultobj = SWIG_From_int(static_cast< int >(result));
18064 return resultobj;
18065 fail:
18066 return NULL;
18067 }
18068
18069
18070 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18071 PyObject *obj;
18072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18073 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18074 return SWIG_Py_Void();
18075 }
18076
18077 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18078 return SWIG_Python_InitShadowInstance(args);
18079 }
18080
18081 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj = 0;
18083 wxFileTypeInfo *arg1 = 0 ;
18084 wxFileType *result = 0 ;
18085 void *argp1 = 0 ;
18086 int res1 = 0 ;
18087 PyObject * obj0 = 0 ;
18088 char * kwnames[] = {
18089 (char *) "ftInfo", NULL
18090 };
18091
18092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18093 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18094 if (!SWIG_IsOK(res1)) {
18095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18096 }
18097 if (!argp1) {
18098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18099 }
18100 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18115 PyObject *resultobj = 0;
18116 wxFileType *arg1 = (wxFileType *) 0 ;
18117 void *argp1 = 0 ;
18118 int res1 = 0 ;
18119 PyObject *swig_obj[1] ;
18120
18121 if (!args) SWIG_fail;
18122 swig_obj[0] = args;
18123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18124 if (!SWIG_IsOK(res1)) {
18125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18126 }
18127 arg1 = reinterpret_cast< wxFileType * >(argp1);
18128 {
18129 PyThreadState* __tstate = wxPyBeginAllowThreads();
18130 delete arg1;
18131
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 resultobj = SWIG_Py_Void();
18136 return resultobj;
18137 fail:
18138 return NULL;
18139 }
18140
18141
18142 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18143 PyObject *resultobj = 0;
18144 wxFileType *arg1 = (wxFileType *) 0 ;
18145 PyObject *result = 0 ;
18146 void *argp1 = 0 ;
18147 int res1 = 0 ;
18148 PyObject *swig_obj[1] ;
18149
18150 if (!args) SWIG_fail;
18151 swig_obj[0] = args;
18152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18153 if (!SWIG_IsOK(res1)) {
18154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18155 }
18156 arg1 = reinterpret_cast< wxFileType * >(argp1);
18157 {
18158 PyThreadState* __tstate = wxPyBeginAllowThreads();
18159 result = (PyObject *)wxFileType_GetMimeType(arg1);
18160 wxPyEndAllowThreads(__tstate);
18161 if (PyErr_Occurred()) SWIG_fail;
18162 }
18163 resultobj = result;
18164 return resultobj;
18165 fail:
18166 return NULL;
18167 }
18168
18169
18170 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18171 PyObject *resultobj = 0;
18172 wxFileType *arg1 = (wxFileType *) 0 ;
18173 PyObject *result = 0 ;
18174 void *argp1 = 0 ;
18175 int res1 = 0 ;
18176 PyObject *swig_obj[1] ;
18177
18178 if (!args) SWIG_fail;
18179 swig_obj[0] = args;
18180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18181 if (!SWIG_IsOK(res1)) {
18182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18183 }
18184 arg1 = reinterpret_cast< wxFileType * >(argp1);
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 resultobj = result;
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *resultobj = 0;
18200 wxFileType *arg1 = (wxFileType *) 0 ;
18201 PyObject *result = 0 ;
18202 void *argp1 = 0 ;
18203 int res1 = 0 ;
18204 PyObject *swig_obj[1] ;
18205
18206 if (!args) SWIG_fail;
18207 swig_obj[0] = args;
18208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18209 if (!SWIG_IsOK(res1)) {
18210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18211 }
18212 arg1 = reinterpret_cast< wxFileType * >(argp1);
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 result = (PyObject *)wxFileType_GetExtensions(arg1);
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 resultobj = result;
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18227 PyObject *resultobj = 0;
18228 wxFileType *arg1 = (wxFileType *) 0 ;
18229 wxIcon *result = 0 ;
18230 void *argp1 = 0 ;
18231 int res1 = 0 ;
18232 PyObject *swig_obj[1] ;
18233
18234 if (!args) SWIG_fail;
18235 swig_obj[0] = args;
18236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18237 if (!SWIG_IsOK(res1)) {
18238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18239 }
18240 arg1 = reinterpret_cast< wxFileType * >(argp1);
18241 {
18242 PyThreadState* __tstate = wxPyBeginAllowThreads();
18243 result = (wxIcon *)wxFileType_GetIcon(arg1);
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18255 PyObject *resultobj = 0;
18256 wxFileType *arg1 = (wxFileType *) 0 ;
18257 PyObject *result = 0 ;
18258 void *argp1 = 0 ;
18259 int res1 = 0 ;
18260 PyObject *swig_obj[1] ;
18261
18262 if (!args) SWIG_fail;
18263 swig_obj[0] = args;
18264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18265 if (!SWIG_IsOK(res1)) {
18266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18267 }
18268 arg1 = reinterpret_cast< wxFileType * >(argp1);
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 resultobj = result;
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18283 PyObject *resultobj = 0;
18284 wxFileType *arg1 = (wxFileType *) 0 ;
18285 PyObject *result = 0 ;
18286 void *argp1 = 0 ;
18287 int res1 = 0 ;
18288 PyObject *swig_obj[1] ;
18289
18290 if (!args) SWIG_fail;
18291 swig_obj[0] = args;
18292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18295 }
18296 arg1 = reinterpret_cast< wxFileType * >(argp1);
18297 {
18298 PyThreadState* __tstate = wxPyBeginAllowThreads();
18299 result = (PyObject *)wxFileType_GetDescription(arg1);
18300 wxPyEndAllowThreads(__tstate);
18301 if (PyErr_Occurred()) SWIG_fail;
18302 }
18303 resultobj = result;
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18311 PyObject *resultobj = 0;
18312 wxFileType *arg1 = (wxFileType *) 0 ;
18313 wxString *arg2 = 0 ;
18314 wxString const &arg3_defvalue = wxPyEmptyString ;
18315 wxString *arg3 = (wxString *) &arg3_defvalue ;
18316 PyObject *result = 0 ;
18317 void *argp1 = 0 ;
18318 int res1 = 0 ;
18319 bool temp2 = false ;
18320 bool temp3 = false ;
18321 PyObject * obj0 = 0 ;
18322 PyObject * obj1 = 0 ;
18323 PyObject * obj2 = 0 ;
18324 char * kwnames[] = {
18325 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18326 };
18327
18328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18330 if (!SWIG_IsOK(res1)) {
18331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18332 }
18333 arg1 = reinterpret_cast< wxFileType * >(argp1);
18334 {
18335 arg2 = wxString_in_helper(obj1);
18336 if (arg2 == NULL) SWIG_fail;
18337 temp2 = true;
18338 }
18339 if (obj2) {
18340 {
18341 arg3 = wxString_in_helper(obj2);
18342 if (arg3 == NULL) SWIG_fail;
18343 temp3 = true;
18344 }
18345 }
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 resultobj = result;
18353 {
18354 if (temp2)
18355 delete arg2;
18356 }
18357 {
18358 if (temp3)
18359 delete arg3;
18360 }
18361 return resultobj;
18362 fail:
18363 {
18364 if (temp2)
18365 delete arg2;
18366 }
18367 {
18368 if (temp3)
18369 delete arg3;
18370 }
18371 return NULL;
18372 }
18373
18374
18375 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj = 0;
18377 wxFileType *arg1 = (wxFileType *) 0 ;
18378 wxString *arg2 = 0 ;
18379 wxString const &arg3_defvalue = wxPyEmptyString ;
18380 wxString *arg3 = (wxString *) &arg3_defvalue ;
18381 PyObject *result = 0 ;
18382 void *argp1 = 0 ;
18383 int res1 = 0 ;
18384 bool temp2 = false ;
18385 bool temp3 = false ;
18386 PyObject * obj0 = 0 ;
18387 PyObject * obj1 = 0 ;
18388 PyObject * obj2 = 0 ;
18389 char * kwnames[] = {
18390 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18391 };
18392
18393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18395 if (!SWIG_IsOK(res1)) {
18396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18397 }
18398 arg1 = reinterpret_cast< wxFileType * >(argp1);
18399 {
18400 arg2 = wxString_in_helper(obj1);
18401 if (arg2 == NULL) SWIG_fail;
18402 temp2 = true;
18403 }
18404 if (obj2) {
18405 {
18406 arg3 = wxString_in_helper(obj2);
18407 if (arg3 == NULL) SWIG_fail;
18408 temp3 = true;
18409 }
18410 }
18411 {
18412 PyThreadState* __tstate = wxPyBeginAllowThreads();
18413 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18414 wxPyEndAllowThreads(__tstate);
18415 if (PyErr_Occurred()) SWIG_fail;
18416 }
18417 resultobj = result;
18418 {
18419 if (temp2)
18420 delete arg2;
18421 }
18422 {
18423 if (temp3)
18424 delete arg3;
18425 }
18426 return resultobj;
18427 fail:
18428 {
18429 if (temp2)
18430 delete arg2;
18431 }
18432 {
18433 if (temp3)
18434 delete arg3;
18435 }
18436 return NULL;
18437 }
18438
18439
18440 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18441 PyObject *resultobj = 0;
18442 wxFileType *arg1 = (wxFileType *) 0 ;
18443 wxString *arg2 = 0 ;
18444 wxString const &arg3_defvalue = wxPyEmptyString ;
18445 wxString *arg3 = (wxString *) &arg3_defvalue ;
18446 PyObject *result = 0 ;
18447 void *argp1 = 0 ;
18448 int res1 = 0 ;
18449 bool temp2 = false ;
18450 bool temp3 = false ;
18451 PyObject * obj0 = 0 ;
18452 PyObject * obj1 = 0 ;
18453 PyObject * obj2 = 0 ;
18454 char * kwnames[] = {
18455 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18456 };
18457
18458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18460 if (!SWIG_IsOK(res1)) {
18461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18462 }
18463 arg1 = reinterpret_cast< wxFileType * >(argp1);
18464 {
18465 arg2 = wxString_in_helper(obj1);
18466 if (arg2 == NULL) SWIG_fail;
18467 temp2 = true;
18468 }
18469 if (obj2) {
18470 {
18471 arg3 = wxString_in_helper(obj2);
18472 if (arg3 == NULL) SWIG_fail;
18473 temp3 = true;
18474 }
18475 }
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18479 wxPyEndAllowThreads(__tstate);
18480 if (PyErr_Occurred()) SWIG_fail;
18481 }
18482 resultobj = result;
18483 {
18484 if (temp2)
18485 delete arg2;
18486 }
18487 {
18488 if (temp3)
18489 delete arg3;
18490 }
18491 return resultobj;
18492 fail:
18493 {
18494 if (temp2)
18495 delete arg2;
18496 }
18497 {
18498 if (temp3)
18499 delete arg3;
18500 }
18501 return NULL;
18502 }
18503
18504
18505 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18506 PyObject *resultobj = 0;
18507 wxFileType *arg1 = (wxFileType *) 0 ;
18508 wxString *arg2 = 0 ;
18509 wxString *arg3 = 0 ;
18510 bool arg4 = (bool) true ;
18511 bool result;
18512 void *argp1 = 0 ;
18513 int res1 = 0 ;
18514 bool temp2 = false ;
18515 bool temp3 = false ;
18516 bool val4 ;
18517 int ecode4 = 0 ;
18518 PyObject * obj0 = 0 ;
18519 PyObject * obj1 = 0 ;
18520 PyObject * obj2 = 0 ;
18521 PyObject * obj3 = 0 ;
18522 char * kwnames[] = {
18523 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18524 };
18525
18526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18528 if (!SWIG_IsOK(res1)) {
18529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18530 }
18531 arg1 = reinterpret_cast< wxFileType * >(argp1);
18532 {
18533 arg2 = wxString_in_helper(obj1);
18534 if (arg2 == NULL) SWIG_fail;
18535 temp2 = true;
18536 }
18537 {
18538 arg3 = wxString_in_helper(obj2);
18539 if (arg3 == NULL) SWIG_fail;
18540 temp3 = true;
18541 }
18542 if (obj3) {
18543 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18544 if (!SWIG_IsOK(ecode4)) {
18545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18546 }
18547 arg4 = static_cast< bool >(val4);
18548 }
18549 {
18550 PyThreadState* __tstate = wxPyBeginAllowThreads();
18551 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 {
18556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18557 }
18558 {
18559 if (temp2)
18560 delete arg2;
18561 }
18562 {
18563 if (temp3)
18564 delete arg3;
18565 }
18566 return resultobj;
18567 fail:
18568 {
18569 if (temp2)
18570 delete arg2;
18571 }
18572 {
18573 if (temp3)
18574 delete arg3;
18575 }
18576 return NULL;
18577 }
18578
18579
18580 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18581 PyObject *resultobj = 0;
18582 wxFileType *arg1 = (wxFileType *) 0 ;
18583 wxString const &arg2_defvalue = wxPyEmptyString ;
18584 wxString *arg2 = (wxString *) &arg2_defvalue ;
18585 int arg3 = (int) 0 ;
18586 bool result;
18587 void *argp1 = 0 ;
18588 int res1 = 0 ;
18589 bool temp2 = false ;
18590 int val3 ;
18591 int ecode3 = 0 ;
18592 PyObject * obj0 = 0 ;
18593 PyObject * obj1 = 0 ;
18594 PyObject * obj2 = 0 ;
18595 char * kwnames[] = {
18596 (char *) "self",(char *) "cmd",(char *) "index", NULL
18597 };
18598
18599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18601 if (!SWIG_IsOK(res1)) {
18602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18603 }
18604 arg1 = reinterpret_cast< wxFileType * >(argp1);
18605 if (obj1) {
18606 {
18607 arg2 = wxString_in_helper(obj1);
18608 if (arg2 == NULL) SWIG_fail;
18609 temp2 = true;
18610 }
18611 }
18612 if (obj2) {
18613 ecode3 = SWIG_AsVal_int(obj2, &val3);
18614 if (!SWIG_IsOK(ecode3)) {
18615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18616 }
18617 arg3 = static_cast< int >(val3);
18618 }
18619 {
18620 PyThreadState* __tstate = wxPyBeginAllowThreads();
18621 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18622 wxPyEndAllowThreads(__tstate);
18623 if (PyErr_Occurred()) SWIG_fail;
18624 }
18625 {
18626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18627 }
18628 {
18629 if (temp2)
18630 delete arg2;
18631 }
18632 return resultobj;
18633 fail:
18634 {
18635 if (temp2)
18636 delete arg2;
18637 }
18638 return NULL;
18639 }
18640
18641
18642 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18643 PyObject *resultobj = 0;
18644 wxFileType *arg1 = (wxFileType *) 0 ;
18645 bool result;
18646 void *argp1 = 0 ;
18647 int res1 = 0 ;
18648 PyObject *swig_obj[1] ;
18649
18650 if (!args) SWIG_fail;
18651 swig_obj[0] = args;
18652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18653 if (!SWIG_IsOK(res1)) {
18654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18655 }
18656 arg1 = reinterpret_cast< wxFileType * >(argp1);
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 result = (bool)(arg1)->Unassociate();
18660 wxPyEndAllowThreads(__tstate);
18661 if (PyErr_Occurred()) SWIG_fail;
18662 }
18663 {
18664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18665 }
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj = 0;
18674 wxString *arg1 = 0 ;
18675 wxString *arg2 = 0 ;
18676 wxString const &arg3_defvalue = wxPyEmptyString ;
18677 wxString *arg3 = (wxString *) &arg3_defvalue ;
18678 wxString result;
18679 bool temp1 = false ;
18680 bool temp2 = false ;
18681 bool temp3 = false ;
18682 PyObject * obj0 = 0 ;
18683 PyObject * obj1 = 0 ;
18684 PyObject * obj2 = 0 ;
18685 char * kwnames[] = {
18686 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18687 };
18688
18689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18690 {
18691 arg1 = wxString_in_helper(obj0);
18692 if (arg1 == NULL) SWIG_fail;
18693 temp1 = true;
18694 }
18695 {
18696 arg2 = wxString_in_helper(obj1);
18697 if (arg2 == NULL) SWIG_fail;
18698 temp2 = true;
18699 }
18700 if (obj2) {
18701 {
18702 arg3 = wxString_in_helper(obj2);
18703 if (arg3 == NULL) SWIG_fail;
18704 temp3 = true;
18705 }
18706 }
18707 {
18708 PyThreadState* __tstate = wxPyBeginAllowThreads();
18709 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18710 wxPyEndAllowThreads(__tstate);
18711 if (PyErr_Occurred()) SWIG_fail;
18712 }
18713 {
18714 #if wxUSE_UNICODE
18715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18716 #else
18717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18718 #endif
18719 }
18720 {
18721 if (temp1)
18722 delete arg1;
18723 }
18724 {
18725 if (temp2)
18726 delete arg2;
18727 }
18728 {
18729 if (temp3)
18730 delete arg3;
18731 }
18732 return resultobj;
18733 fail:
18734 {
18735 if (temp1)
18736 delete arg1;
18737 }
18738 {
18739 if (temp2)
18740 delete arg2;
18741 }
18742 {
18743 if (temp3)
18744 delete arg3;
18745 }
18746 return NULL;
18747 }
18748
18749
18750 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18751 PyObject *obj;
18752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18753 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18754 return SWIG_Py_Void();
18755 }
18756
18757 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18758 return SWIG_Python_InitShadowInstance(args);
18759 }
18760
18761 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18762 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18763 return 1;
18764 }
18765
18766
18767 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18768 PyObject *pyobj = 0;
18769
18770 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18771 return pyobj;
18772 }
18773
18774
18775 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18776 PyObject *resultobj = 0;
18777 wxString *arg1 = 0 ;
18778 wxString *arg2 = 0 ;
18779 bool result;
18780 bool temp1 = false ;
18781 bool temp2 = false ;
18782 PyObject * obj0 = 0 ;
18783 PyObject * obj1 = 0 ;
18784 char * kwnames[] = {
18785 (char *) "mimeType",(char *) "wildcard", NULL
18786 };
18787
18788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18789 {
18790 arg1 = wxString_in_helper(obj0);
18791 if (arg1 == NULL) SWIG_fail;
18792 temp1 = true;
18793 }
18794 {
18795 arg2 = wxString_in_helper(obj1);
18796 if (arg2 == NULL) SWIG_fail;
18797 temp2 = true;
18798 }
18799 {
18800 PyThreadState* __tstate = wxPyBeginAllowThreads();
18801 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18802 wxPyEndAllowThreads(__tstate);
18803 if (PyErr_Occurred()) SWIG_fail;
18804 }
18805 {
18806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18807 }
18808 {
18809 if (temp1)
18810 delete arg1;
18811 }
18812 {
18813 if (temp2)
18814 delete arg2;
18815 }
18816 return resultobj;
18817 fail:
18818 {
18819 if (temp1)
18820 delete arg1;
18821 }
18822 {
18823 if (temp2)
18824 delete arg2;
18825 }
18826 return NULL;
18827 }
18828
18829
18830 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18831 PyObject *resultobj = 0;
18832 wxMimeTypesManager *result = 0 ;
18833
18834 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18835 {
18836 PyThreadState* __tstate = wxPyBeginAllowThreads();
18837 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18838 wxPyEndAllowThreads(__tstate);
18839 if (PyErr_Occurred()) SWIG_fail;
18840 }
18841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18849 PyObject *resultobj = 0;
18850 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18851 int arg2 = (int) wxMAILCAP_ALL ;
18852 wxString const &arg3_defvalue = wxPyEmptyString ;
18853 wxString *arg3 = (wxString *) &arg3_defvalue ;
18854 void *argp1 = 0 ;
18855 int res1 = 0 ;
18856 int val2 ;
18857 int ecode2 = 0 ;
18858 bool temp3 = false ;
18859 PyObject * obj0 = 0 ;
18860 PyObject * obj1 = 0 ;
18861 PyObject * obj2 = 0 ;
18862 char * kwnames[] = {
18863 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18864 };
18865
18866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18868 if (!SWIG_IsOK(res1)) {
18869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18870 }
18871 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18872 if (obj1) {
18873 ecode2 = SWIG_AsVal_int(obj1, &val2);
18874 if (!SWIG_IsOK(ecode2)) {
18875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18876 }
18877 arg2 = static_cast< int >(val2);
18878 }
18879 if (obj2) {
18880 {
18881 arg3 = wxString_in_helper(obj2);
18882 if (arg3 == NULL) SWIG_fail;
18883 temp3 = true;
18884 }
18885 }
18886 {
18887 PyThreadState* __tstate = wxPyBeginAllowThreads();
18888 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18889 wxPyEndAllowThreads(__tstate);
18890 if (PyErr_Occurred()) SWIG_fail;
18891 }
18892 resultobj = SWIG_Py_Void();
18893 {
18894 if (temp3)
18895 delete arg3;
18896 }
18897 return resultobj;
18898 fail:
18899 {
18900 if (temp3)
18901 delete arg3;
18902 }
18903 return NULL;
18904 }
18905
18906
18907 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18908 PyObject *resultobj = 0;
18909 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18910 void *argp1 = 0 ;
18911 int res1 = 0 ;
18912 PyObject *swig_obj[1] ;
18913
18914 if (!args) SWIG_fail;
18915 swig_obj[0] = args;
18916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18917 if (!SWIG_IsOK(res1)) {
18918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18919 }
18920 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18921 {
18922 PyThreadState* __tstate = wxPyBeginAllowThreads();
18923 (arg1)->ClearData();
18924 wxPyEndAllowThreads(__tstate);
18925 if (PyErr_Occurred()) SWIG_fail;
18926 }
18927 resultobj = SWIG_Py_Void();
18928 return resultobj;
18929 fail:
18930 return NULL;
18931 }
18932
18933
18934 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18935 PyObject *resultobj = 0;
18936 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18937 wxString *arg2 = 0 ;
18938 wxFileType *result = 0 ;
18939 void *argp1 = 0 ;
18940 int res1 = 0 ;
18941 bool temp2 = false ;
18942 PyObject * obj0 = 0 ;
18943 PyObject * obj1 = 0 ;
18944 char * kwnames[] = {
18945 (char *) "self",(char *) "ext", NULL
18946 };
18947
18948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18952 }
18953 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18954 {
18955 arg2 = wxString_in_helper(obj1);
18956 if (arg2 == NULL) SWIG_fail;
18957 temp2 = true;
18958 }
18959 {
18960 PyThreadState* __tstate = wxPyBeginAllowThreads();
18961 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18962 wxPyEndAllowThreads(__tstate);
18963 if (PyErr_Occurred()) SWIG_fail;
18964 }
18965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18966 {
18967 if (temp2)
18968 delete arg2;
18969 }
18970 return resultobj;
18971 fail:
18972 {
18973 if (temp2)
18974 delete arg2;
18975 }
18976 return NULL;
18977 }
18978
18979
18980 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18981 PyObject *resultobj = 0;
18982 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18983 wxString *arg2 = 0 ;
18984 wxFileType *result = 0 ;
18985 void *argp1 = 0 ;
18986 int res1 = 0 ;
18987 bool temp2 = false ;
18988 PyObject * obj0 = 0 ;
18989 PyObject * obj1 = 0 ;
18990 char * kwnames[] = {
18991 (char *) "self",(char *) "mimeType", NULL
18992 };
18993
18994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18996 if (!SWIG_IsOK(res1)) {
18997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18998 }
18999 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19000 {
19001 arg2 = wxString_in_helper(obj1);
19002 if (arg2 == NULL) SWIG_fail;
19003 temp2 = true;
19004 }
19005 {
19006 PyThreadState* __tstate = wxPyBeginAllowThreads();
19007 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19008 wxPyEndAllowThreads(__tstate);
19009 if (PyErr_Occurred()) SWIG_fail;
19010 }
19011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19012 {
19013 if (temp2)
19014 delete arg2;
19015 }
19016 return resultobj;
19017 fail:
19018 {
19019 if (temp2)
19020 delete arg2;
19021 }
19022 return NULL;
19023 }
19024
19025
19026 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj = 0;
19028 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19029 wxString *arg2 = 0 ;
19030 bool arg3 = (bool) false ;
19031 bool result;
19032 void *argp1 = 0 ;
19033 int res1 = 0 ;
19034 bool temp2 = false ;
19035 bool val3 ;
19036 int ecode3 = 0 ;
19037 PyObject * obj0 = 0 ;
19038 PyObject * obj1 = 0 ;
19039 PyObject * obj2 = 0 ;
19040 char * kwnames[] = {
19041 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19042 };
19043
19044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19046 if (!SWIG_IsOK(res1)) {
19047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19048 }
19049 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19050 {
19051 arg2 = wxString_in_helper(obj1);
19052 if (arg2 == NULL) SWIG_fail;
19053 temp2 = true;
19054 }
19055 if (obj2) {
19056 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19057 if (!SWIG_IsOK(ecode3)) {
19058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19059 }
19060 arg3 = static_cast< bool >(val3);
19061 }
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19065 wxPyEndAllowThreads(__tstate);
19066 if (PyErr_Occurred()) SWIG_fail;
19067 }
19068 {
19069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19070 }
19071 {
19072 if (temp2)
19073 delete arg2;
19074 }
19075 return resultobj;
19076 fail:
19077 {
19078 if (temp2)
19079 delete arg2;
19080 }
19081 return NULL;
19082 }
19083
19084
19085 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj = 0;
19087 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19088 wxString *arg2 = 0 ;
19089 bool result;
19090 void *argp1 = 0 ;
19091 int res1 = 0 ;
19092 bool temp2 = false ;
19093 PyObject * obj0 = 0 ;
19094 PyObject * obj1 = 0 ;
19095 char * kwnames[] = {
19096 (char *) "self",(char *) "filename", NULL
19097 };
19098
19099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19101 if (!SWIG_IsOK(res1)) {
19102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19103 }
19104 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19105 {
19106 arg2 = wxString_in_helper(obj1);
19107 if (arg2 == NULL) SWIG_fail;
19108 temp2 = true;
19109 }
19110 {
19111 PyThreadState* __tstate = wxPyBeginAllowThreads();
19112 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19113 wxPyEndAllowThreads(__tstate);
19114 if (PyErr_Occurred()) SWIG_fail;
19115 }
19116 {
19117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19118 }
19119 {
19120 if (temp2)
19121 delete arg2;
19122 }
19123 return resultobj;
19124 fail:
19125 {
19126 if (temp2)
19127 delete arg2;
19128 }
19129 return NULL;
19130 }
19131
19132
19133 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19134 PyObject *resultobj = 0;
19135 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19136 PyObject *result = 0 ;
19137 void *argp1 = 0 ;
19138 int res1 = 0 ;
19139 PyObject *swig_obj[1] ;
19140
19141 if (!args) SWIG_fail;
19142 swig_obj[0] = args;
19143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19144 if (!SWIG_IsOK(res1)) {
19145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19146 }
19147 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 resultobj = result;
19155 return resultobj;
19156 fail:
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19162 PyObject *resultobj = 0;
19163 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19164 wxFileTypeInfo *arg2 = 0 ;
19165 void *argp1 = 0 ;
19166 int res1 = 0 ;
19167 void *argp2 = 0 ;
19168 int res2 = 0 ;
19169 PyObject * obj0 = 0 ;
19170 PyObject * obj1 = 0 ;
19171 char * kwnames[] = {
19172 (char *) "self",(char *) "ft", NULL
19173 };
19174
19175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19177 if (!SWIG_IsOK(res1)) {
19178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19179 }
19180 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19181 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19182 if (!SWIG_IsOK(res2)) {
19183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19184 }
19185 if (!argp2) {
19186 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19187 }
19188 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 resultobj = SWIG_Py_Void();
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19203 PyObject *resultobj = 0;
19204 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19205 wxFileTypeInfo *arg2 = 0 ;
19206 wxFileType *result = 0 ;
19207 void *argp1 = 0 ;
19208 int res1 = 0 ;
19209 void *argp2 = 0 ;
19210 int res2 = 0 ;
19211 PyObject * obj0 = 0 ;
19212 PyObject * obj1 = 0 ;
19213 char * kwnames[] = {
19214 (char *) "self",(char *) "ftInfo", NULL
19215 };
19216
19217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19219 if (!SWIG_IsOK(res1)) {
19220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19221 }
19222 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19223 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19224 if (!SWIG_IsOK(res2)) {
19225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19226 }
19227 if (!argp2) {
19228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19229 }
19230 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19231 {
19232 PyThreadState* __tstate = wxPyBeginAllowThreads();
19233 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj = 0;
19246 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19247 wxFileType *arg2 = (wxFileType *) 0 ;
19248 bool result;
19249 void *argp1 = 0 ;
19250 int res1 = 0 ;
19251 void *argp2 = 0 ;
19252 int res2 = 0 ;
19253 PyObject * obj0 = 0 ;
19254 PyObject * obj1 = 0 ;
19255 char * kwnames[] = {
19256 (char *) "self",(char *) "ft", NULL
19257 };
19258
19259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19261 if (!SWIG_IsOK(res1)) {
19262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19263 }
19264 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19265 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19266 if (!SWIG_IsOK(res2)) {
19267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19268 }
19269 arg2 = reinterpret_cast< wxFileType * >(argp2);
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (bool)(arg1)->Unassociate(arg2);
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 {
19277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19278 }
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19286 PyObject *resultobj = 0;
19287 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19288 void *argp1 = 0 ;
19289 int res1 = 0 ;
19290 PyObject *swig_obj[1] ;
19291
19292 if (!args) SWIG_fail;
19293 swig_obj[0] = args;
19294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19295 if (!SWIG_IsOK(res1)) {
19296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19297 }
19298 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19299 {
19300 PyThreadState* __tstate = wxPyBeginAllowThreads();
19301 delete arg1;
19302
19303 wxPyEndAllowThreads(__tstate);
19304 if (PyErr_Occurred()) SWIG_fail;
19305 }
19306 resultobj = SWIG_Py_Void();
19307 return resultobj;
19308 fail:
19309 return NULL;
19310 }
19311
19312
19313 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19314 PyObject *obj;
19315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19316 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19317 return SWIG_Py_Void();
19318 }
19319
19320 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19321 return SWIG_Python_InitShadowInstance(args);
19322 }
19323
19324 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19325 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19326 return 1;
19327 }
19328
19329
19330 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19331 PyObject *pyobj = 0;
19332
19333 {
19334 #if wxUSE_UNICODE
19335 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19336 #else
19337 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19338 #endif
19339 }
19340 return pyobj;
19341 }
19342
19343
19344 SWIGINTERN int ART_MENU_set(PyObject *) {
19345 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19346 return 1;
19347 }
19348
19349
19350 SWIGINTERN PyObject *ART_MENU_get(void) {
19351 PyObject *pyobj = 0;
19352
19353 {
19354 #if wxUSE_UNICODE
19355 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19356 #else
19357 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19358 #endif
19359 }
19360 return pyobj;
19361 }
19362
19363
19364 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19365 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19366 return 1;
19367 }
19368
19369
19370 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19371 PyObject *pyobj = 0;
19372
19373 {
19374 #if wxUSE_UNICODE
19375 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19376 #else
19377 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19378 #endif
19379 }
19380 return pyobj;
19381 }
19382
19383
19384 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19385 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19386 return 1;
19387 }
19388
19389
19390 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19391 PyObject *pyobj = 0;
19392
19393 {
19394 #if wxUSE_UNICODE
19395 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19396 #else
19397 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19398 #endif
19399 }
19400 return pyobj;
19401 }
19402
19403
19404 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19405 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19406 return 1;
19407 }
19408
19409
19410 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19411 PyObject *pyobj = 0;
19412
19413 {
19414 #if wxUSE_UNICODE
19415 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19416 #else
19417 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19418 #endif
19419 }
19420 return pyobj;
19421 }
19422
19423
19424 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19425 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19426 return 1;
19427 }
19428
19429
19430 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19431 PyObject *pyobj = 0;
19432
19433 {
19434 #if wxUSE_UNICODE
19435 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19436 #else
19437 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19438 #endif
19439 }
19440 return pyobj;
19441 }
19442
19443
19444 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19445 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19446 return 1;
19447 }
19448
19449
19450 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19451 PyObject *pyobj = 0;
19452
19453 {
19454 #if wxUSE_UNICODE
19455 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19456 #else
19457 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19458 #endif
19459 }
19460 return pyobj;
19461 }
19462
19463
19464 SWIGINTERN int ART_LIST_set(PyObject *) {
19465 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST is read-only.");
19466 return 1;
19467 }
19468
19469
19470 SWIGINTERN PyObject *ART_LIST_get(void) {
19471 PyObject *pyobj = 0;
19472
19473 {
19474 #if wxUSE_UNICODE
19475 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST)->c_str(), (&wxPyART_LIST)->Len());
19476 #else
19477 pyobj = PyString_FromStringAndSize((&wxPyART_LIST)->c_str(), (&wxPyART_LIST)->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_GetIconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20787 PyObject *resultobj = 0;
20788 wxArtID *arg1 = 0 ;
20789 wxArtClient const &arg2_defvalue = wxART_OTHER ;
20790 wxArtClient *arg2 = (wxArtClient *) &arg2_defvalue ;
20791 wxIconBundle result;
20792 void *argp1 = 0 ;
20793 int res1 = 0 ;
20794 void *argp2 = 0 ;
20795 int res2 = 0 ;
20796 PyObject * obj0 = 0 ;
20797 PyObject * obj1 = 0 ;
20798 char * kwnames[] = {
20799 (char *) "id",(char *) "client", NULL
20800 };
20801
20802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetIconBundle",kwnames,&obj0,&obj1)) SWIG_fail;
20803 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxArtID, 0 | 0);
20804 if (!SWIG_IsOK(res1)) {
20805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_GetIconBundle" "', expected argument " "1"" of type '" "wxArtID const &""'");
20806 }
20807 if (!argp1) {
20808 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArtProvider_GetIconBundle" "', expected argument " "1"" of type '" "wxArtID const &""'");
20809 }
20810 arg1 = reinterpret_cast< wxArtID * >(argp1);
20811 if (obj1) {
20812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxArtClient, 0 | 0);
20813 if (!SWIG_IsOK(res2)) {
20814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArtProvider_GetIconBundle" "', expected argument " "2"" of type '" "wxArtClient const &""'");
20815 }
20816 if (!argp2) {
20817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArtProvider_GetIconBundle" "', expected argument " "2"" of type '" "wxArtClient const &""'");
20818 }
20819 arg2 = reinterpret_cast< wxArtClient * >(argp2);
20820 }
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = wxPyArtProvider::GetIconBundle((wxArtID const &)*arg1,(wxArtClient const &)*arg2);
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 resultobj = SWIG_NewPointerObj((new wxIconBundle(static_cast< const wxIconBundle& >(result))), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
20828 return resultobj;
20829 fail:
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20835 PyObject *resultobj = 0;
20836 wxString *arg1 = 0 ;
20837 bool arg2 = (bool) false ;
20838 wxSize result;
20839 bool temp1 = false ;
20840 bool val2 ;
20841 int ecode2 = 0 ;
20842 PyObject * obj0 = 0 ;
20843 PyObject * obj1 = 0 ;
20844 char * kwnames[] = {
20845 (char *) "client",(char *) "platform_dependent", NULL
20846 };
20847
20848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20849 {
20850 arg1 = wxString_in_helper(obj0);
20851 if (arg1 == NULL) SWIG_fail;
20852 temp1 = true;
20853 }
20854 if (obj1) {
20855 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20856 if (!SWIG_IsOK(ecode2)) {
20857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20858 }
20859 arg2 = static_cast< bool >(val2);
20860 }
20861 {
20862 PyThreadState* __tstate = wxPyBeginAllowThreads();
20863 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20868 {
20869 if (temp1)
20870 delete arg1;
20871 }
20872 return resultobj;
20873 fail:
20874 {
20875 if (temp1)
20876 delete arg1;
20877 }
20878 return NULL;
20879 }
20880
20881
20882 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20883 PyObject *resultobj = 0;
20884 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20885 void *argp1 = 0 ;
20886 int res1 = 0 ;
20887 PyObject *swig_obj[1] ;
20888
20889 if (!args) SWIG_fail;
20890 swig_obj[0] = args;
20891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20892 if (!SWIG_IsOK(res1)) {
20893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20894 }
20895 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 wxPyArtProvider_Destroy(arg1);
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 resultobj = SWIG_Py_Void();
20903 return resultobj;
20904 fail:
20905 return NULL;
20906 }
20907
20908
20909 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20910 PyObject *obj;
20911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20912 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20913 return SWIG_Py_Void();
20914 }
20915
20916 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20917 return SWIG_Python_InitShadowInstance(args);
20918 }
20919
20920 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20921 PyObject *resultobj = 0;
20922 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20923 void *argp1 = 0 ;
20924 int res1 = 0 ;
20925 PyObject *swig_obj[1] ;
20926
20927 if (!args) SWIG_fail;
20928 swig_obj[0] = args;
20929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20930 if (!SWIG_IsOK(res1)) {
20931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20932 }
20933 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20934 {
20935 PyThreadState* __tstate = wxPyBeginAllowThreads();
20936 delete arg1;
20937
20938 wxPyEndAllowThreads(__tstate);
20939 if (PyErr_Occurred()) SWIG_fail;
20940 }
20941 resultobj = SWIG_Py_Void();
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20949 PyObject *resultobj = 0;
20950 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20951 wxConfigBase *result = 0 ;
20952 int res1 = 0 ;
20953 PyObject * obj0 = 0 ;
20954 char * kwnames[] = {
20955 (char *) "config", NULL
20956 };
20957
20958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20959 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20960 if (!SWIG_IsOK(res1)) {
20961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20962 }
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20977 PyObject *resultobj = 0;
20978 bool arg1 = (bool) true ;
20979 wxConfigBase *result = 0 ;
20980 bool val1 ;
20981 int ecode1 = 0 ;
20982 PyObject * obj0 = 0 ;
20983 char * kwnames[] = {
20984 (char *) "createOnDemand", NULL
20985 };
20986
20987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20988 if (obj0) {
20989 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20990 if (!SWIG_IsOK(ecode1)) {
20991 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20992 }
20993 arg1 = static_cast< bool >(val1);
20994 }
20995 {
20996 PyThreadState* __tstate = wxPyBeginAllowThreads();
20997 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20998 wxPyEndAllowThreads(__tstate);
20999 if (PyErr_Occurred()) SWIG_fail;
21000 }
21001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
21002 return resultobj;
21003 fail:
21004 return NULL;
21005 }
21006
21007
21008 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21009 PyObject *resultobj = 0;
21010 wxConfigBase *result = 0 ;
21011
21012 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 result = (wxConfigBase *)wxConfigBase::Create();
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
21020 return resultobj;
21021 fail:
21022 return NULL;
21023 }
21024
21025
21026 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21027 PyObject *resultobj = 0;
21028
21029 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
21030 {
21031 PyThreadState* __tstate = wxPyBeginAllowThreads();
21032 wxConfigBase::DontCreateOnDemand();
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 resultobj = SWIG_Py_Void();
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21044 PyObject *resultobj = 0;
21045 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21046 wxString *arg2 = 0 ;
21047 void *argp1 = 0 ;
21048 int res1 = 0 ;
21049 bool temp2 = false ;
21050 PyObject * obj0 = 0 ;
21051 PyObject * obj1 = 0 ;
21052 char * kwnames[] = {
21053 (char *) "self",(char *) "path", NULL
21054 };
21055
21056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21058 if (!SWIG_IsOK(res1)) {
21059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21060 }
21061 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21062 {
21063 arg2 = wxString_in_helper(obj1);
21064 if (arg2 == NULL) SWIG_fail;
21065 temp2 = true;
21066 }
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 (arg1)->SetPath((wxString const &)*arg2);
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 resultobj = SWIG_Py_Void();
21074 {
21075 if (temp2)
21076 delete arg2;
21077 }
21078 return resultobj;
21079 fail:
21080 {
21081 if (temp2)
21082 delete arg2;
21083 }
21084 return NULL;
21085 }
21086
21087
21088 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21089 PyObject *resultobj = 0;
21090 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21091 wxString *result = 0 ;
21092 void *argp1 = 0 ;
21093 int res1 = 0 ;
21094 PyObject *swig_obj[1] ;
21095
21096 if (!args) SWIG_fail;
21097 swig_obj[0] = args;
21098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21099 if (!SWIG_IsOK(res1)) {
21100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21101 }
21102 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 {
21106 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21107 result = (wxString *) &_result_ref;
21108 }
21109 wxPyEndAllowThreads(__tstate);
21110 if (PyErr_Occurred()) SWIG_fail;
21111 }
21112 {
21113 #if wxUSE_UNICODE
21114 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21115 #else
21116 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21117 #endif
21118 }
21119 return resultobj;
21120 fail:
21121 return NULL;
21122 }
21123
21124
21125 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21126 PyObject *resultobj = 0;
21127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21128 PyObject *result = 0 ;
21129 void *argp1 = 0 ;
21130 int res1 = 0 ;
21131 PyObject *swig_obj[1] ;
21132
21133 if (!args) SWIG_fail;
21134 swig_obj[0] = args;
21135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21136 if (!SWIG_IsOK(res1)) {
21137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21138 }
21139 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21140 {
21141 PyThreadState* __tstate = wxPyBeginAllowThreads();
21142 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21143 wxPyEndAllowThreads(__tstate);
21144 if (PyErr_Occurred()) SWIG_fail;
21145 }
21146 resultobj = result;
21147 return resultobj;
21148 fail:
21149 return NULL;
21150 }
21151
21152
21153 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21154 PyObject *resultobj = 0;
21155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21156 long arg2 ;
21157 PyObject *result = 0 ;
21158 void *argp1 = 0 ;
21159 int res1 = 0 ;
21160 long val2 ;
21161 int ecode2 = 0 ;
21162 PyObject * obj0 = 0 ;
21163 PyObject * obj1 = 0 ;
21164 char * kwnames[] = {
21165 (char *) "self",(char *) "index", NULL
21166 };
21167
21168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21172 }
21173 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21174 ecode2 = SWIG_AsVal_long(obj1, &val2);
21175 if (!SWIG_IsOK(ecode2)) {
21176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21177 }
21178 arg2 = static_cast< long >(val2);
21179 {
21180 PyThreadState* __tstate = wxPyBeginAllowThreads();
21181 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 resultobj = result;
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21193 PyObject *resultobj = 0;
21194 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21195 PyObject *result = 0 ;
21196 void *argp1 = 0 ;
21197 int res1 = 0 ;
21198 PyObject *swig_obj[1] ;
21199
21200 if (!args) SWIG_fail;
21201 swig_obj[0] = args;
21202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21203 if (!SWIG_IsOK(res1)) {
21204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21205 }
21206 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21207 {
21208 PyThreadState* __tstate = wxPyBeginAllowThreads();
21209 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21210 wxPyEndAllowThreads(__tstate);
21211 if (PyErr_Occurred()) SWIG_fail;
21212 }
21213 resultobj = result;
21214 return resultobj;
21215 fail:
21216 return NULL;
21217 }
21218
21219
21220 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21221 PyObject *resultobj = 0;
21222 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21223 long arg2 ;
21224 PyObject *result = 0 ;
21225 void *argp1 = 0 ;
21226 int res1 = 0 ;
21227 long val2 ;
21228 int ecode2 = 0 ;
21229 PyObject * obj0 = 0 ;
21230 PyObject * obj1 = 0 ;
21231 char * kwnames[] = {
21232 (char *) "self",(char *) "index", NULL
21233 };
21234
21235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21237 if (!SWIG_IsOK(res1)) {
21238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21239 }
21240 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21241 ecode2 = SWIG_AsVal_long(obj1, &val2);
21242 if (!SWIG_IsOK(ecode2)) {
21243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21244 }
21245 arg2 = static_cast< long >(val2);
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21249 wxPyEndAllowThreads(__tstate);
21250 if (PyErr_Occurred()) SWIG_fail;
21251 }
21252 resultobj = result;
21253 return resultobj;
21254 fail:
21255 return NULL;
21256 }
21257
21258
21259 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21260 PyObject *resultobj = 0;
21261 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21262 bool arg2 = (bool) false ;
21263 size_t result;
21264 void *argp1 = 0 ;
21265 int res1 = 0 ;
21266 bool val2 ;
21267 int ecode2 = 0 ;
21268 PyObject * obj0 = 0 ;
21269 PyObject * obj1 = 0 ;
21270 char * kwnames[] = {
21271 (char *) "self",(char *) "recursive", NULL
21272 };
21273
21274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21276 if (!SWIG_IsOK(res1)) {
21277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21278 }
21279 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21280 if (obj1) {
21281 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21282 if (!SWIG_IsOK(ecode2)) {
21283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21284 }
21285 arg2 = static_cast< bool >(val2);
21286 }
21287 {
21288 PyThreadState* __tstate = wxPyBeginAllowThreads();
21289 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21290 wxPyEndAllowThreads(__tstate);
21291 if (PyErr_Occurred()) SWIG_fail;
21292 }
21293 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21294 return resultobj;
21295 fail:
21296 return NULL;
21297 }
21298
21299
21300 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21301 PyObject *resultobj = 0;
21302 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21303 bool arg2 = (bool) false ;
21304 size_t result;
21305 void *argp1 = 0 ;
21306 int res1 = 0 ;
21307 bool val2 ;
21308 int ecode2 = 0 ;
21309 PyObject * obj0 = 0 ;
21310 PyObject * obj1 = 0 ;
21311 char * kwnames[] = {
21312 (char *) "self",(char *) "recursive", NULL
21313 };
21314
21315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21317 if (!SWIG_IsOK(res1)) {
21318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21319 }
21320 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21321 if (obj1) {
21322 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21323 if (!SWIG_IsOK(ecode2)) {
21324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21325 }
21326 arg2 = static_cast< bool >(val2);
21327 }
21328 {
21329 PyThreadState* __tstate = wxPyBeginAllowThreads();
21330 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21331 wxPyEndAllowThreads(__tstate);
21332 if (PyErr_Occurred()) SWIG_fail;
21333 }
21334 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(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_HasGroup",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_HasGroup" "', 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)->HasGroup((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_HasEntry(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_HasEntry",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_HasEntry" "', 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)->HasEntry((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_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21438 PyObject *resultobj = 0;
21439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21440 wxString *arg2 = 0 ;
21441 bool 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_Exists",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_Exists" "', 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 = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 {
21469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21470 }
21471 {
21472 if (temp2)
21473 delete arg2;
21474 }
21475 return resultobj;
21476 fail:
21477 {
21478 if (temp2)
21479 delete arg2;
21480 }
21481 return NULL;
21482 }
21483
21484
21485 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21486 PyObject *resultobj = 0;
21487 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21488 wxString *arg2 = 0 ;
21489 wxConfigBase::EntryType result;
21490 void *argp1 = 0 ;
21491 int res1 = 0 ;
21492 bool temp2 = false ;
21493 PyObject * obj0 = 0 ;
21494 PyObject * obj1 = 0 ;
21495 char * kwnames[] = {
21496 (char *) "self",(char *) "name", NULL
21497 };
21498
21499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21501 if (!SWIG_IsOK(res1)) {
21502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21503 }
21504 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21505 {
21506 arg2 = wxString_in_helper(obj1);
21507 if (arg2 == NULL) SWIG_fail;
21508 temp2 = true;
21509 }
21510 {
21511 PyThreadState* __tstate = wxPyBeginAllowThreads();
21512 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21513 wxPyEndAllowThreads(__tstate);
21514 if (PyErr_Occurred()) SWIG_fail;
21515 }
21516 resultobj = SWIG_From_int(static_cast< int >(result));
21517 {
21518 if (temp2)
21519 delete arg2;
21520 }
21521 return resultobj;
21522 fail:
21523 {
21524 if (temp2)
21525 delete arg2;
21526 }
21527 return NULL;
21528 }
21529
21530
21531 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21532 PyObject *resultobj = 0;
21533 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21534 wxString *arg2 = 0 ;
21535 wxString const &arg3_defvalue = wxPyEmptyString ;
21536 wxString *arg3 = (wxString *) &arg3_defvalue ;
21537 wxString result;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 bool temp2 = false ;
21541 bool temp3 = false ;
21542 PyObject * obj0 = 0 ;
21543 PyObject * obj1 = 0 ;
21544 PyObject * obj2 = 0 ;
21545 char * kwnames[] = {
21546 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21547 };
21548
21549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21551 if (!SWIG_IsOK(res1)) {
21552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21553 }
21554 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21555 {
21556 arg2 = wxString_in_helper(obj1);
21557 if (arg2 == NULL) SWIG_fail;
21558 temp2 = true;
21559 }
21560 if (obj2) {
21561 {
21562 arg3 = wxString_in_helper(obj2);
21563 if (arg3 == NULL) SWIG_fail;
21564 temp3 = true;
21565 }
21566 }
21567 {
21568 PyThreadState* __tstate = wxPyBeginAllowThreads();
21569 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21570 wxPyEndAllowThreads(__tstate);
21571 if (PyErr_Occurred()) SWIG_fail;
21572 }
21573 {
21574 #if wxUSE_UNICODE
21575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21576 #else
21577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21578 #endif
21579 }
21580 {
21581 if (temp2)
21582 delete arg2;
21583 }
21584 {
21585 if (temp3)
21586 delete arg3;
21587 }
21588 return resultobj;
21589 fail:
21590 {
21591 if (temp2)
21592 delete arg2;
21593 }
21594 {
21595 if (temp3)
21596 delete arg3;
21597 }
21598 return NULL;
21599 }
21600
21601
21602 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21603 PyObject *resultobj = 0;
21604 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21605 wxString *arg2 = 0 ;
21606 long arg3 = (long) 0 ;
21607 long result;
21608 void *argp1 = 0 ;
21609 int res1 = 0 ;
21610 bool temp2 = false ;
21611 long val3 ;
21612 int ecode3 = 0 ;
21613 PyObject * obj0 = 0 ;
21614 PyObject * obj1 = 0 ;
21615 PyObject * obj2 = 0 ;
21616 char * kwnames[] = {
21617 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21618 };
21619
21620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21622 if (!SWIG_IsOK(res1)) {
21623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21624 }
21625 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21626 {
21627 arg2 = wxString_in_helper(obj1);
21628 if (arg2 == NULL) SWIG_fail;
21629 temp2 = true;
21630 }
21631 if (obj2) {
21632 ecode3 = SWIG_AsVal_long(obj2, &val3);
21633 if (!SWIG_IsOK(ecode3)) {
21634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21635 }
21636 arg3 = static_cast< long >(val3);
21637 }
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21641 wxPyEndAllowThreads(__tstate);
21642 if (PyErr_Occurred()) SWIG_fail;
21643 }
21644 resultobj = SWIG_From_long(static_cast< long >(result));
21645 {
21646 if (temp2)
21647 delete arg2;
21648 }
21649 return resultobj;
21650 fail:
21651 {
21652 if (temp2)
21653 delete arg2;
21654 }
21655 return NULL;
21656 }
21657
21658
21659 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21660 PyObject *resultobj = 0;
21661 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21662 wxString *arg2 = 0 ;
21663 double arg3 = (double) 0.0 ;
21664 double result;
21665 void *argp1 = 0 ;
21666 int res1 = 0 ;
21667 bool temp2 = false ;
21668 double val3 ;
21669 int ecode3 = 0 ;
21670 PyObject * obj0 = 0 ;
21671 PyObject * obj1 = 0 ;
21672 PyObject * obj2 = 0 ;
21673 char * kwnames[] = {
21674 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21675 };
21676
21677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21679 if (!SWIG_IsOK(res1)) {
21680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21681 }
21682 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21683 {
21684 arg2 = wxString_in_helper(obj1);
21685 if (arg2 == NULL) SWIG_fail;
21686 temp2 = true;
21687 }
21688 if (obj2) {
21689 ecode3 = SWIG_AsVal_double(obj2, &val3);
21690 if (!SWIG_IsOK(ecode3)) {
21691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21692 }
21693 arg3 = static_cast< double >(val3);
21694 }
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 resultobj = SWIG_From_double(static_cast< double >(result));
21702 {
21703 if (temp2)
21704 delete arg2;
21705 }
21706 return resultobj;
21707 fail:
21708 {
21709 if (temp2)
21710 delete arg2;
21711 }
21712 return NULL;
21713 }
21714
21715
21716 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj = 0;
21718 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21719 wxString *arg2 = 0 ;
21720 bool arg3 = (bool) false ;
21721 bool result;
21722 void *argp1 = 0 ;
21723 int res1 = 0 ;
21724 bool temp2 = false ;
21725 bool val3 ;
21726 int ecode3 = 0 ;
21727 PyObject * obj0 = 0 ;
21728 PyObject * obj1 = 0 ;
21729 PyObject * obj2 = 0 ;
21730 char * kwnames[] = {
21731 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21732 };
21733
21734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21736 if (!SWIG_IsOK(res1)) {
21737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21738 }
21739 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21740 {
21741 arg2 = wxString_in_helper(obj1);
21742 if (arg2 == NULL) SWIG_fail;
21743 temp2 = true;
21744 }
21745 if (obj2) {
21746 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21747 if (!SWIG_IsOK(ecode3)) {
21748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21749 }
21750 arg3 = static_cast< bool >(val3);
21751 }
21752 {
21753 PyThreadState* __tstate = wxPyBeginAllowThreads();
21754 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21755 wxPyEndAllowThreads(__tstate);
21756 if (PyErr_Occurred()) SWIG_fail;
21757 }
21758 {
21759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21760 }
21761 {
21762 if (temp2)
21763 delete arg2;
21764 }
21765 return resultobj;
21766 fail:
21767 {
21768 if (temp2)
21769 delete arg2;
21770 }
21771 return NULL;
21772 }
21773
21774
21775 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21776 PyObject *resultobj = 0;
21777 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21778 wxString *arg2 = 0 ;
21779 wxString *arg3 = 0 ;
21780 bool result;
21781 void *argp1 = 0 ;
21782 int res1 = 0 ;
21783 bool temp2 = false ;
21784 bool temp3 = false ;
21785 PyObject * obj0 = 0 ;
21786 PyObject * obj1 = 0 ;
21787 PyObject * obj2 = 0 ;
21788 char * kwnames[] = {
21789 (char *) "self",(char *) "key",(char *) "value", NULL
21790 };
21791
21792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21794 if (!SWIG_IsOK(res1)) {
21795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21796 }
21797 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21798 {
21799 arg2 = wxString_in_helper(obj1);
21800 if (arg2 == NULL) SWIG_fail;
21801 temp2 = true;
21802 }
21803 {
21804 arg3 = wxString_in_helper(obj2);
21805 if (arg3 == NULL) SWIG_fail;
21806 temp3 = true;
21807 }
21808 {
21809 PyThreadState* __tstate = wxPyBeginAllowThreads();
21810 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21811 wxPyEndAllowThreads(__tstate);
21812 if (PyErr_Occurred()) SWIG_fail;
21813 }
21814 {
21815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21816 }
21817 {
21818 if (temp2)
21819 delete arg2;
21820 }
21821 {
21822 if (temp3)
21823 delete arg3;
21824 }
21825 return resultobj;
21826 fail:
21827 {
21828 if (temp2)
21829 delete arg2;
21830 }
21831 {
21832 if (temp3)
21833 delete arg3;
21834 }
21835 return NULL;
21836 }
21837
21838
21839 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21840 PyObject *resultobj = 0;
21841 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21842 wxString *arg2 = 0 ;
21843 long arg3 ;
21844 bool result;
21845 void *argp1 = 0 ;
21846 int res1 = 0 ;
21847 bool temp2 = false ;
21848 long val3 ;
21849 int ecode3 = 0 ;
21850 PyObject * obj0 = 0 ;
21851 PyObject * obj1 = 0 ;
21852 PyObject * obj2 = 0 ;
21853 char * kwnames[] = {
21854 (char *) "self",(char *) "key",(char *) "value", NULL
21855 };
21856
21857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21859 if (!SWIG_IsOK(res1)) {
21860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21861 }
21862 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21863 {
21864 arg2 = wxString_in_helper(obj1);
21865 if (arg2 == NULL) SWIG_fail;
21866 temp2 = true;
21867 }
21868 ecode3 = SWIG_AsVal_long(obj2, &val3);
21869 if (!SWIG_IsOK(ecode3)) {
21870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21871 }
21872 arg3 = static_cast< long >(val3);
21873 {
21874 PyThreadState* __tstate = wxPyBeginAllowThreads();
21875 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21876 wxPyEndAllowThreads(__tstate);
21877 if (PyErr_Occurred()) SWIG_fail;
21878 }
21879 {
21880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21881 }
21882 {
21883 if (temp2)
21884 delete arg2;
21885 }
21886 return resultobj;
21887 fail:
21888 {
21889 if (temp2)
21890 delete arg2;
21891 }
21892 return NULL;
21893 }
21894
21895
21896 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21897 PyObject *resultobj = 0;
21898 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21899 wxString *arg2 = 0 ;
21900 double arg3 ;
21901 bool result;
21902 void *argp1 = 0 ;
21903 int res1 = 0 ;
21904 bool temp2 = false ;
21905 double val3 ;
21906 int ecode3 = 0 ;
21907 PyObject * obj0 = 0 ;
21908 PyObject * obj1 = 0 ;
21909 PyObject * obj2 = 0 ;
21910 char * kwnames[] = {
21911 (char *) "self",(char *) "key",(char *) "value", NULL
21912 };
21913
21914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21916 if (!SWIG_IsOK(res1)) {
21917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21918 }
21919 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21920 {
21921 arg2 = wxString_in_helper(obj1);
21922 if (arg2 == NULL) SWIG_fail;
21923 temp2 = true;
21924 }
21925 ecode3 = SWIG_AsVal_double(obj2, &val3);
21926 if (!SWIG_IsOK(ecode3)) {
21927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21928 }
21929 arg3 = static_cast< double >(val3);
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21933 wxPyEndAllowThreads(__tstate);
21934 if (PyErr_Occurred()) SWIG_fail;
21935 }
21936 {
21937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21938 }
21939 {
21940 if (temp2)
21941 delete arg2;
21942 }
21943 return resultobj;
21944 fail:
21945 {
21946 if (temp2)
21947 delete arg2;
21948 }
21949 return NULL;
21950 }
21951
21952
21953 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21954 PyObject *resultobj = 0;
21955 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21956 wxString *arg2 = 0 ;
21957 bool arg3 ;
21958 bool result;
21959 void *argp1 = 0 ;
21960 int res1 = 0 ;
21961 bool temp2 = false ;
21962 bool val3 ;
21963 int ecode3 = 0 ;
21964 PyObject * obj0 = 0 ;
21965 PyObject * obj1 = 0 ;
21966 PyObject * obj2 = 0 ;
21967 char * kwnames[] = {
21968 (char *) "self",(char *) "key",(char *) "value", NULL
21969 };
21970
21971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21973 if (!SWIG_IsOK(res1)) {
21974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21975 }
21976 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21977 {
21978 arg2 = wxString_in_helper(obj1);
21979 if (arg2 == NULL) SWIG_fail;
21980 temp2 = true;
21981 }
21982 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21983 if (!SWIG_IsOK(ecode3)) {
21984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21985 }
21986 arg3 = static_cast< bool >(val3);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 {
21997 if (temp2)
21998 delete arg2;
21999 }
22000 return resultobj;
22001 fail:
22002 {
22003 if (temp2)
22004 delete arg2;
22005 }
22006 return NULL;
22007 }
22008
22009
22010 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22011 PyObject *resultobj = 0;
22012 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22013 bool arg2 = (bool) false ;
22014 bool result;
22015 void *argp1 = 0 ;
22016 int res1 = 0 ;
22017 bool val2 ;
22018 int ecode2 = 0 ;
22019 PyObject * obj0 = 0 ;
22020 PyObject * obj1 = 0 ;
22021 char * kwnames[] = {
22022 (char *) "self",(char *) "currentOnly", NULL
22023 };
22024
22025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
22026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22027 if (!SWIG_IsOK(res1)) {
22028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22029 }
22030 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22031 if (obj1) {
22032 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22033 if (!SWIG_IsOK(ecode2)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
22035 }
22036 arg2 = static_cast< bool >(val2);
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (bool)(arg1)->Flush(arg2);
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 {
22045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22046 }
22047 return resultobj;
22048 fail:
22049 return NULL;
22050 }
22051
22052
22053 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22054 PyObject *resultobj = 0;
22055 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22056 wxString *arg2 = 0 ;
22057 wxString *arg3 = 0 ;
22058 bool result;
22059 void *argp1 = 0 ;
22060 int res1 = 0 ;
22061 bool temp2 = false ;
22062 bool temp3 = false ;
22063 PyObject * obj0 = 0 ;
22064 PyObject * obj1 = 0 ;
22065 PyObject * obj2 = 0 ;
22066 char * kwnames[] = {
22067 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22068 };
22069
22070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22072 if (!SWIG_IsOK(res1)) {
22073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22074 }
22075 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22076 {
22077 arg2 = wxString_in_helper(obj1);
22078 if (arg2 == NULL) SWIG_fail;
22079 temp2 = true;
22080 }
22081 {
22082 arg3 = wxString_in_helper(obj2);
22083 if (arg3 == NULL) SWIG_fail;
22084 temp3 = true;
22085 }
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 {
22093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22094 }
22095 {
22096 if (temp2)
22097 delete arg2;
22098 }
22099 {
22100 if (temp3)
22101 delete arg3;
22102 }
22103 return resultobj;
22104 fail:
22105 {
22106 if (temp2)
22107 delete arg2;
22108 }
22109 {
22110 if (temp3)
22111 delete arg3;
22112 }
22113 return NULL;
22114 }
22115
22116
22117 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22118 PyObject *resultobj = 0;
22119 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22120 wxString *arg2 = 0 ;
22121 wxString *arg3 = 0 ;
22122 bool result;
22123 void *argp1 = 0 ;
22124 int res1 = 0 ;
22125 bool temp2 = false ;
22126 bool temp3 = false ;
22127 PyObject * obj0 = 0 ;
22128 PyObject * obj1 = 0 ;
22129 PyObject * obj2 = 0 ;
22130 char * kwnames[] = {
22131 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22132 };
22133
22134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22136 if (!SWIG_IsOK(res1)) {
22137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22138 }
22139 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22140 {
22141 arg2 = wxString_in_helper(obj1);
22142 if (arg2 == NULL) SWIG_fail;
22143 temp2 = true;
22144 }
22145 {
22146 arg3 = wxString_in_helper(obj2);
22147 if (arg3 == NULL) SWIG_fail;
22148 temp3 = true;
22149 }
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 {
22157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22158 }
22159 {
22160 if (temp2)
22161 delete arg2;
22162 }
22163 {
22164 if (temp3)
22165 delete arg3;
22166 }
22167 return resultobj;
22168 fail:
22169 {
22170 if (temp2)
22171 delete arg2;
22172 }
22173 {
22174 if (temp3)
22175 delete arg3;
22176 }
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22182 PyObject *resultobj = 0;
22183 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22184 wxString *arg2 = 0 ;
22185 bool arg3 = (bool) true ;
22186 bool result;
22187 void *argp1 = 0 ;
22188 int res1 = 0 ;
22189 bool temp2 = false ;
22190 bool val3 ;
22191 int ecode3 = 0 ;
22192 PyObject * obj0 = 0 ;
22193 PyObject * obj1 = 0 ;
22194 PyObject * obj2 = 0 ;
22195 char * kwnames[] = {
22196 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22197 };
22198
22199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22201 if (!SWIG_IsOK(res1)) {
22202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22203 }
22204 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22205 {
22206 arg2 = wxString_in_helper(obj1);
22207 if (arg2 == NULL) SWIG_fail;
22208 temp2 = true;
22209 }
22210 if (obj2) {
22211 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22212 if (!SWIG_IsOK(ecode3)) {
22213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22214 }
22215 arg3 = static_cast< bool >(val3);
22216 }
22217 {
22218 PyThreadState* __tstate = wxPyBeginAllowThreads();
22219 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
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_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22241 PyObject *resultobj = 0;
22242 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22243 wxString *arg2 = 0 ;
22244 bool result;
22245 void *argp1 = 0 ;
22246 int res1 = 0 ;
22247 bool temp2 = false ;
22248 PyObject * obj0 = 0 ;
22249 PyObject * obj1 = 0 ;
22250 char * kwnames[] = {
22251 (char *) "self",(char *) "key", NULL
22252 };
22253
22254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22256 if (!SWIG_IsOK(res1)) {
22257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22258 }
22259 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22260 {
22261 arg2 = wxString_in_helper(obj1);
22262 if (arg2 == NULL) SWIG_fail;
22263 temp2 = true;
22264 }
22265 {
22266 PyThreadState* __tstate = wxPyBeginAllowThreads();
22267 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22268 wxPyEndAllowThreads(__tstate);
22269 if (PyErr_Occurred()) SWIG_fail;
22270 }
22271 {
22272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22273 }
22274 {
22275 if (temp2)
22276 delete arg2;
22277 }
22278 return resultobj;
22279 fail:
22280 {
22281 if (temp2)
22282 delete arg2;
22283 }
22284 return NULL;
22285 }
22286
22287
22288 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22289 PyObject *resultobj = 0;
22290 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22291 bool result;
22292 void *argp1 = 0 ;
22293 int res1 = 0 ;
22294 PyObject *swig_obj[1] ;
22295
22296 if (!args) SWIG_fail;
22297 swig_obj[0] = args;
22298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22299 if (!SWIG_IsOK(res1)) {
22300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22301 }
22302 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22303 {
22304 PyThreadState* __tstate = wxPyBeginAllowThreads();
22305 result = (bool)(arg1)->DeleteAll();
22306 wxPyEndAllowThreads(__tstate);
22307 if (PyErr_Occurred()) SWIG_fail;
22308 }
22309 {
22310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22311 }
22312 return resultobj;
22313 fail:
22314 return NULL;
22315 }
22316
22317
22318 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22319 PyObject *resultobj = 0;
22320 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22321 bool arg2 = (bool) true ;
22322 void *argp1 = 0 ;
22323 int res1 = 0 ;
22324 bool val2 ;
22325 int ecode2 = 0 ;
22326 PyObject * obj0 = 0 ;
22327 PyObject * obj1 = 0 ;
22328 char * kwnames[] = {
22329 (char *) "self",(char *) "doIt", NULL
22330 };
22331
22332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22334 if (!SWIG_IsOK(res1)) {
22335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22336 }
22337 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22338 if (obj1) {
22339 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22340 if (!SWIG_IsOK(ecode2)) {
22341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22342 }
22343 arg2 = static_cast< bool >(val2);
22344 }
22345 {
22346 PyThreadState* __tstate = wxPyBeginAllowThreads();
22347 (arg1)->SetExpandEnvVars(arg2);
22348 wxPyEndAllowThreads(__tstate);
22349 if (PyErr_Occurred()) SWIG_fail;
22350 }
22351 resultobj = SWIG_Py_Void();
22352 return resultobj;
22353 fail:
22354 return NULL;
22355 }
22356
22357
22358 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22359 PyObject *resultobj = 0;
22360 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22361 bool result;
22362 void *argp1 = 0 ;
22363 int res1 = 0 ;
22364 PyObject *swig_obj[1] ;
22365
22366 if (!args) SWIG_fail;
22367 swig_obj[0] = args;
22368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22369 if (!SWIG_IsOK(res1)) {
22370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22371 }
22372 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22373 {
22374 PyThreadState* __tstate = wxPyBeginAllowThreads();
22375 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22376 wxPyEndAllowThreads(__tstate);
22377 if (PyErr_Occurred()) SWIG_fail;
22378 }
22379 {
22380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22381 }
22382 return resultobj;
22383 fail:
22384 return NULL;
22385 }
22386
22387
22388 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22389 PyObject *resultobj = 0;
22390 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22391 bool arg2 = (bool) true ;
22392 void *argp1 = 0 ;
22393 int res1 = 0 ;
22394 bool val2 ;
22395 int ecode2 = 0 ;
22396 PyObject * obj0 = 0 ;
22397 PyObject * obj1 = 0 ;
22398 char * kwnames[] = {
22399 (char *) "self",(char *) "doIt", NULL
22400 };
22401
22402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22404 if (!SWIG_IsOK(res1)) {
22405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22406 }
22407 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22408 if (obj1) {
22409 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22410 if (!SWIG_IsOK(ecode2)) {
22411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22412 }
22413 arg2 = static_cast< bool >(val2);
22414 }
22415 {
22416 PyThreadState* __tstate = wxPyBeginAllowThreads();
22417 (arg1)->SetRecordDefaults(arg2);
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 resultobj = SWIG_Py_Void();
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22429 PyObject *resultobj = 0;
22430 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22431 bool result;
22432 void *argp1 = 0 ;
22433 int res1 = 0 ;
22434 PyObject *swig_obj[1] ;
22435
22436 if (!args) SWIG_fail;
22437 swig_obj[0] = args;
22438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22439 if (!SWIG_IsOK(res1)) {
22440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22441 }
22442 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22446 wxPyEndAllowThreads(__tstate);
22447 if (PyErr_Occurred()) SWIG_fail;
22448 }
22449 {
22450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22451 }
22452 return resultobj;
22453 fail:
22454 return NULL;
22455 }
22456
22457
22458 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22459 PyObject *resultobj = 0;
22460 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22461 wxString *arg2 = 0 ;
22462 wxString result;
22463 void *argp1 = 0 ;
22464 int res1 = 0 ;
22465 bool temp2 = false ;
22466 PyObject * obj0 = 0 ;
22467 PyObject * obj1 = 0 ;
22468 char * kwnames[] = {
22469 (char *) "self",(char *) "str", NULL
22470 };
22471
22472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22474 if (!SWIG_IsOK(res1)) {
22475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22476 }
22477 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22478 {
22479 arg2 = wxString_in_helper(obj1);
22480 if (arg2 == NULL) SWIG_fail;
22481 temp2 = true;
22482 }
22483 {
22484 PyThreadState* __tstate = wxPyBeginAllowThreads();
22485 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22486 wxPyEndAllowThreads(__tstate);
22487 if (PyErr_Occurred()) SWIG_fail;
22488 }
22489 {
22490 #if wxUSE_UNICODE
22491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22492 #else
22493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22494 #endif
22495 }
22496 {
22497 if (temp2)
22498 delete arg2;
22499 }
22500 return resultobj;
22501 fail:
22502 {
22503 if (temp2)
22504 delete arg2;
22505 }
22506 return NULL;
22507 }
22508
22509
22510 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22511 PyObject *resultobj = 0;
22512 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22513 wxString result;
22514 void *argp1 = 0 ;
22515 int res1 = 0 ;
22516 PyObject *swig_obj[1] ;
22517
22518 if (!args) SWIG_fail;
22519 swig_obj[0] = args;
22520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22521 if (!SWIG_IsOK(res1)) {
22522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22523 }
22524 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22525 {
22526 PyThreadState* __tstate = wxPyBeginAllowThreads();
22527 result = ((wxConfigBase const *)arg1)->GetAppName();
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 {
22532 #if wxUSE_UNICODE
22533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22534 #else
22535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22536 #endif
22537 }
22538 return resultobj;
22539 fail:
22540 return NULL;
22541 }
22542
22543
22544 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22545 PyObject *resultobj = 0;
22546 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22547 wxString result;
22548 void *argp1 = 0 ;
22549 int res1 = 0 ;
22550 PyObject *swig_obj[1] ;
22551
22552 if (!args) SWIG_fail;
22553 swig_obj[0] = args;
22554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22555 if (!SWIG_IsOK(res1)) {
22556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22557 }
22558 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22559 {
22560 PyThreadState* __tstate = wxPyBeginAllowThreads();
22561 result = ((wxConfigBase const *)arg1)->GetVendorName();
22562 wxPyEndAllowThreads(__tstate);
22563 if (PyErr_Occurred()) SWIG_fail;
22564 }
22565 {
22566 #if wxUSE_UNICODE
22567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22568 #else
22569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22570 #endif
22571 }
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22579 PyObject *resultobj = 0;
22580 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22581 wxString *arg2 = 0 ;
22582 void *argp1 = 0 ;
22583 int res1 = 0 ;
22584 bool temp2 = false ;
22585 PyObject * obj0 = 0 ;
22586 PyObject * obj1 = 0 ;
22587 char * kwnames[] = {
22588 (char *) "self",(char *) "appName", NULL
22589 };
22590
22591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22593 if (!SWIG_IsOK(res1)) {
22594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22595 }
22596 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22597 {
22598 arg2 = wxString_in_helper(obj1);
22599 if (arg2 == NULL) SWIG_fail;
22600 temp2 = true;
22601 }
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 (arg1)->SetAppName((wxString const &)*arg2);
22605 wxPyEndAllowThreads(__tstate);
22606 if (PyErr_Occurred()) SWIG_fail;
22607 }
22608 resultobj = SWIG_Py_Void();
22609 {
22610 if (temp2)
22611 delete arg2;
22612 }
22613 return resultobj;
22614 fail:
22615 {
22616 if (temp2)
22617 delete arg2;
22618 }
22619 return NULL;
22620 }
22621
22622
22623 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22624 PyObject *resultobj = 0;
22625 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22626 wxString *arg2 = 0 ;
22627 void *argp1 = 0 ;
22628 int res1 = 0 ;
22629 bool temp2 = false ;
22630 PyObject * obj0 = 0 ;
22631 PyObject * obj1 = 0 ;
22632 char * kwnames[] = {
22633 (char *) "self",(char *) "vendorName", NULL
22634 };
22635
22636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22638 if (!SWIG_IsOK(res1)) {
22639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22640 }
22641 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22642 {
22643 arg2 = wxString_in_helper(obj1);
22644 if (arg2 == NULL) SWIG_fail;
22645 temp2 = true;
22646 }
22647 {
22648 PyThreadState* __tstate = wxPyBeginAllowThreads();
22649 (arg1)->SetVendorName((wxString const &)*arg2);
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 resultobj = SWIG_Py_Void();
22654 {
22655 if (temp2)
22656 delete arg2;
22657 }
22658 return resultobj;
22659 fail:
22660 {
22661 if (temp2)
22662 delete arg2;
22663 }
22664 return NULL;
22665 }
22666
22667
22668 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22669 PyObject *resultobj = 0;
22670 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22671 long arg2 ;
22672 void *argp1 = 0 ;
22673 int res1 = 0 ;
22674 long val2 ;
22675 int ecode2 = 0 ;
22676 PyObject * obj0 = 0 ;
22677 PyObject * obj1 = 0 ;
22678 char * kwnames[] = {
22679 (char *) "self",(char *) "style", NULL
22680 };
22681
22682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22684 if (!SWIG_IsOK(res1)) {
22685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22686 }
22687 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22688 ecode2 = SWIG_AsVal_long(obj1, &val2);
22689 if (!SWIG_IsOK(ecode2)) {
22690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22691 }
22692 arg2 = static_cast< long >(val2);
22693 {
22694 PyThreadState* __tstate = wxPyBeginAllowThreads();
22695 (arg1)->SetStyle(arg2);
22696 wxPyEndAllowThreads(__tstate);
22697 if (PyErr_Occurred()) SWIG_fail;
22698 }
22699 resultobj = SWIG_Py_Void();
22700 return resultobj;
22701 fail:
22702 return NULL;
22703 }
22704
22705
22706 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22707 PyObject *resultobj = 0;
22708 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22709 long result;
22710 void *argp1 = 0 ;
22711 int res1 = 0 ;
22712 PyObject *swig_obj[1] ;
22713
22714 if (!args) SWIG_fail;
22715 swig_obj[0] = args;
22716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22717 if (!SWIG_IsOK(res1)) {
22718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22719 }
22720 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22721 {
22722 PyThreadState* __tstate = wxPyBeginAllowThreads();
22723 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22724 wxPyEndAllowThreads(__tstate);
22725 if (PyErr_Occurred()) SWIG_fail;
22726 }
22727 resultobj = SWIG_From_long(static_cast< long >(result));
22728 return resultobj;
22729 fail:
22730 return NULL;
22731 }
22732
22733
22734 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22735 PyObject *obj;
22736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22737 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22738 return SWIG_Py_Void();
22739 }
22740
22741 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22742 PyObject *resultobj = 0;
22743 wxString const &arg1_defvalue = wxPyEmptyString ;
22744 wxString *arg1 = (wxString *) &arg1_defvalue ;
22745 wxString const &arg2_defvalue = wxPyEmptyString ;
22746 wxString *arg2 = (wxString *) &arg2_defvalue ;
22747 wxString const &arg3_defvalue = wxPyEmptyString ;
22748 wxString *arg3 = (wxString *) &arg3_defvalue ;
22749 wxString const &arg4_defvalue = wxPyEmptyString ;
22750 wxString *arg4 = (wxString *) &arg4_defvalue ;
22751 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22752 wxConfig *result = 0 ;
22753 bool temp1 = false ;
22754 bool temp2 = false ;
22755 bool temp3 = false ;
22756 bool temp4 = false ;
22757 long val5 ;
22758 int ecode5 = 0 ;
22759 PyObject * obj0 = 0 ;
22760 PyObject * obj1 = 0 ;
22761 PyObject * obj2 = 0 ;
22762 PyObject * obj3 = 0 ;
22763 PyObject * obj4 = 0 ;
22764 char * kwnames[] = {
22765 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22766 };
22767
22768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22769 if (obj0) {
22770 {
22771 arg1 = wxString_in_helper(obj0);
22772 if (arg1 == NULL) SWIG_fail;
22773 temp1 = true;
22774 }
22775 }
22776 if (obj1) {
22777 {
22778 arg2 = wxString_in_helper(obj1);
22779 if (arg2 == NULL) SWIG_fail;
22780 temp2 = true;
22781 }
22782 }
22783 if (obj2) {
22784 {
22785 arg3 = wxString_in_helper(obj2);
22786 if (arg3 == NULL) SWIG_fail;
22787 temp3 = true;
22788 }
22789 }
22790 if (obj3) {
22791 {
22792 arg4 = wxString_in_helper(obj3);
22793 if (arg4 == NULL) SWIG_fail;
22794 temp4 = true;
22795 }
22796 }
22797 if (obj4) {
22798 ecode5 = SWIG_AsVal_long(obj4, &val5);
22799 if (!SWIG_IsOK(ecode5)) {
22800 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22801 }
22802 arg5 = static_cast< long >(val5);
22803 }
22804 {
22805 PyThreadState* __tstate = wxPyBeginAllowThreads();
22806 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22807 wxPyEndAllowThreads(__tstate);
22808 if (PyErr_Occurred()) SWIG_fail;
22809 }
22810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22811 {
22812 if (temp1)
22813 delete arg1;
22814 }
22815 {
22816 if (temp2)
22817 delete arg2;
22818 }
22819 {
22820 if (temp3)
22821 delete arg3;
22822 }
22823 {
22824 if (temp4)
22825 delete arg4;
22826 }
22827 return resultobj;
22828 fail:
22829 {
22830 if (temp1)
22831 delete arg1;
22832 }
22833 {
22834 if (temp2)
22835 delete arg2;
22836 }
22837 {
22838 if (temp3)
22839 delete arg3;
22840 }
22841 {
22842 if (temp4)
22843 delete arg4;
22844 }
22845 return NULL;
22846 }
22847
22848
22849 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22850 PyObject *resultobj = 0;
22851 wxConfig *arg1 = (wxConfig *) 0 ;
22852 void *argp1 = 0 ;
22853 int res1 = 0 ;
22854 PyObject *swig_obj[1] ;
22855
22856 if (!args) SWIG_fail;
22857 swig_obj[0] = args;
22858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22859 if (!SWIG_IsOK(res1)) {
22860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22861 }
22862 arg1 = reinterpret_cast< wxConfig * >(argp1);
22863 {
22864 PyThreadState* __tstate = wxPyBeginAllowThreads();
22865 delete arg1;
22866
22867 wxPyEndAllowThreads(__tstate);
22868 if (PyErr_Occurred()) SWIG_fail;
22869 }
22870 resultobj = SWIG_Py_Void();
22871 return resultobj;
22872 fail:
22873 return NULL;
22874 }
22875
22876
22877 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22878 PyObject *obj;
22879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22880 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22881 return SWIG_Py_Void();
22882 }
22883
22884 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22885 return SWIG_Python_InitShadowInstance(args);
22886 }
22887
22888 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22889 PyObject *resultobj = 0;
22890 wxString const &arg1_defvalue = wxPyEmptyString ;
22891 wxString *arg1 = (wxString *) &arg1_defvalue ;
22892 wxString const &arg2_defvalue = wxPyEmptyString ;
22893 wxString *arg2 = (wxString *) &arg2_defvalue ;
22894 wxString const &arg3_defvalue = wxPyEmptyString ;
22895 wxString *arg3 = (wxString *) &arg3_defvalue ;
22896 wxString const &arg4_defvalue = wxPyEmptyString ;
22897 wxString *arg4 = (wxString *) &arg4_defvalue ;
22898 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22899 wxFileConfig *result = 0 ;
22900 bool temp1 = false ;
22901 bool temp2 = false ;
22902 bool temp3 = false ;
22903 bool temp4 = false ;
22904 long val5 ;
22905 int ecode5 = 0 ;
22906 PyObject * obj0 = 0 ;
22907 PyObject * obj1 = 0 ;
22908 PyObject * obj2 = 0 ;
22909 PyObject * obj3 = 0 ;
22910 PyObject * obj4 = 0 ;
22911 char * kwnames[] = {
22912 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22913 };
22914
22915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22916 if (obj0) {
22917 {
22918 arg1 = wxString_in_helper(obj0);
22919 if (arg1 == NULL) SWIG_fail;
22920 temp1 = true;
22921 }
22922 }
22923 if (obj1) {
22924 {
22925 arg2 = wxString_in_helper(obj1);
22926 if (arg2 == NULL) SWIG_fail;
22927 temp2 = true;
22928 }
22929 }
22930 if (obj2) {
22931 {
22932 arg3 = wxString_in_helper(obj2);
22933 if (arg3 == NULL) SWIG_fail;
22934 temp3 = true;
22935 }
22936 }
22937 if (obj3) {
22938 {
22939 arg4 = wxString_in_helper(obj3);
22940 if (arg4 == NULL) SWIG_fail;
22941 temp4 = true;
22942 }
22943 }
22944 if (obj4) {
22945 ecode5 = SWIG_AsVal_long(obj4, &val5);
22946 if (!SWIG_IsOK(ecode5)) {
22947 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22948 }
22949 arg5 = static_cast< long >(val5);
22950 }
22951 {
22952 PyThreadState* __tstate = wxPyBeginAllowThreads();
22953 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22954 wxPyEndAllowThreads(__tstate);
22955 if (PyErr_Occurred()) SWIG_fail;
22956 }
22957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22958 {
22959 if (temp1)
22960 delete arg1;
22961 }
22962 {
22963 if (temp2)
22964 delete arg2;
22965 }
22966 {
22967 if (temp3)
22968 delete arg3;
22969 }
22970 {
22971 if (temp4)
22972 delete arg4;
22973 }
22974 return resultobj;
22975 fail:
22976 {
22977 if (temp1)
22978 delete arg1;
22979 }
22980 {
22981 if (temp2)
22982 delete arg2;
22983 }
22984 {
22985 if (temp3)
22986 delete arg3;
22987 }
22988 {
22989 if (temp4)
22990 delete arg4;
22991 }
22992 return NULL;
22993 }
22994
22995
22996 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22997 PyObject *resultobj = 0;
22998 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22999 void *argp1 = 0 ;
23000 int res1 = 0 ;
23001 PyObject *swig_obj[1] ;
23002
23003 if (!args) SWIG_fail;
23004 swig_obj[0] = args;
23005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
23006 if (!SWIG_IsOK(res1)) {
23007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
23008 }
23009 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
23010 {
23011 PyThreadState* __tstate = wxPyBeginAllowThreads();
23012 delete arg1;
23013
23014 wxPyEndAllowThreads(__tstate);
23015 if (PyErr_Occurred()) SWIG_fail;
23016 }
23017 resultobj = SWIG_Py_Void();
23018 return resultobj;
23019 fail:
23020 return NULL;
23021 }
23022
23023
23024 SWIGINTERN PyObject *_wrap_FileConfig_GetGlobalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23025 PyObject *resultobj = 0;
23026 wxString *arg1 = 0 ;
23027 wxString result;
23028 bool temp1 = false ;
23029 PyObject * obj0 = 0 ;
23030 char * kwnames[] = {
23031 (char *) "szFile", NULL
23032 };
23033
23034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileConfig_GetGlobalFileName",kwnames,&obj0)) SWIG_fail;
23035 {
23036 arg1 = wxString_in_helper(obj0);
23037 if (arg1 == NULL) SWIG_fail;
23038 temp1 = true;
23039 }
23040 {
23041 PyThreadState* __tstate = wxPyBeginAllowThreads();
23042 result = wxFileConfig::GetGlobalFileName((wxString const &)*arg1);
23043 wxPyEndAllowThreads(__tstate);
23044 if (PyErr_Occurred()) SWIG_fail;
23045 }
23046 {
23047 #if wxUSE_UNICODE
23048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23049 #else
23050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23051 #endif
23052 }
23053 {
23054 if (temp1)
23055 delete arg1;
23056 }
23057 return resultobj;
23058 fail:
23059 {
23060 if (temp1)
23061 delete arg1;
23062 }
23063 return NULL;
23064 }
23065
23066
23067 SWIGINTERN PyObject *_wrap_FileConfig_GetLocalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23068 PyObject *resultobj = 0;
23069 wxString *arg1 = 0 ;
23070 int arg2 = (int) 0 ;
23071 wxString result;
23072 bool temp1 = false ;
23073 int val2 ;
23074 int ecode2 = 0 ;
23075 PyObject * obj0 = 0 ;
23076 PyObject * obj1 = 0 ;
23077 char * kwnames[] = {
23078 (char *) "szFile",(char *) "style", NULL
23079 };
23080
23081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FileConfig_GetLocalFileName",kwnames,&obj0,&obj1)) SWIG_fail;
23082 {
23083 arg1 = wxString_in_helper(obj0);
23084 if (arg1 == NULL) SWIG_fail;
23085 temp1 = true;
23086 }
23087 if (obj1) {
23088 ecode2 = SWIG_AsVal_int(obj1, &val2);
23089 if (!SWIG_IsOK(ecode2)) {
23090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileConfig_GetLocalFileName" "', expected argument " "2"" of type '" "int""'");
23091 }
23092 arg2 = static_cast< int >(val2);
23093 }
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = wxFileConfig::GetLocalFileName((wxString const &)*arg1,arg2);
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 {
23101 #if wxUSE_UNICODE
23102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23103 #else
23104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23105 #endif
23106 }
23107 {
23108 if (temp1)
23109 delete arg1;
23110 }
23111 return resultobj;
23112 fail:
23113 {
23114 if (temp1)
23115 delete arg1;
23116 }
23117 return NULL;
23118 }
23119
23120
23121 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23122 PyObject *obj;
23123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23124 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
23125 return SWIG_Py_Void();
23126 }
23127
23128 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23129 return SWIG_Python_InitShadowInstance(args);
23130 }
23131
23132 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23133 PyObject *resultobj = 0;
23134 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
23135 wxString *arg2 = 0 ;
23136 wxConfigPathChanger *result = 0 ;
23137 void *argp1 = 0 ;
23138 int res1 = 0 ;
23139 bool temp2 = false ;
23140 PyObject * obj0 = 0 ;
23141 PyObject * obj1 = 0 ;
23142 char * kwnames[] = {
23143 (char *) "config",(char *) "entry", NULL
23144 };
23145
23146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
23147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
23150 }
23151 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23152 {
23153 arg2 = wxString_in_helper(obj1);
23154 if (arg2 == NULL) SWIG_fail;
23155 temp2 = true;
23156 }
23157 {
23158 PyThreadState* __tstate = wxPyBeginAllowThreads();
23159 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23160 wxPyEndAllowThreads(__tstate);
23161 if (PyErr_Occurred()) SWIG_fail;
23162 }
23163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23164 {
23165 if (temp2)
23166 delete arg2;
23167 }
23168 return resultobj;
23169 fail:
23170 {
23171 if (temp2)
23172 delete arg2;
23173 }
23174 return NULL;
23175 }
23176
23177
23178 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23179 PyObject *resultobj = 0;
23180 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23181 void *argp1 = 0 ;
23182 int res1 = 0 ;
23183 PyObject *swig_obj[1] ;
23184
23185 if (!args) SWIG_fail;
23186 swig_obj[0] = args;
23187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23188 if (!SWIG_IsOK(res1)) {
23189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23190 }
23191 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23192 {
23193 PyThreadState* __tstate = wxPyBeginAllowThreads();
23194 delete arg1;
23195
23196 wxPyEndAllowThreads(__tstate);
23197 if (PyErr_Occurred()) SWIG_fail;
23198 }
23199 resultobj = SWIG_Py_Void();
23200 return resultobj;
23201 fail:
23202 return NULL;
23203 }
23204
23205
23206 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23207 PyObject *resultobj = 0;
23208 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23209 wxString *result = 0 ;
23210 void *argp1 = 0 ;
23211 int res1 = 0 ;
23212 PyObject *swig_obj[1] ;
23213
23214 if (!args) SWIG_fail;
23215 swig_obj[0] = args;
23216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23217 if (!SWIG_IsOK(res1)) {
23218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23219 }
23220 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23221 {
23222 PyThreadState* __tstate = wxPyBeginAllowThreads();
23223 {
23224 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23225 result = (wxString *) &_result_ref;
23226 }
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 {
23231 #if wxUSE_UNICODE
23232 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23233 #else
23234 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23235 #endif
23236 }
23237 return resultobj;
23238 fail:
23239 return NULL;
23240 }
23241
23242
23243 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23244 PyObject *obj;
23245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23246 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23247 return SWIG_Py_Void();
23248 }
23249
23250 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23251 return SWIG_Python_InitShadowInstance(args);
23252 }
23253
23254 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23255 PyObject *resultobj = 0;
23256 wxString *arg1 = 0 ;
23257 wxString result;
23258 bool temp1 = false ;
23259 PyObject * obj0 = 0 ;
23260 char * kwnames[] = {
23261 (char *) "sz", NULL
23262 };
23263
23264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23265 {
23266 arg1 = wxString_in_helper(obj0);
23267 if (arg1 == NULL) SWIG_fail;
23268 temp1 = true;
23269 }
23270 {
23271 PyThreadState* __tstate = wxPyBeginAllowThreads();
23272 result = wxExpandEnvVars((wxString const &)*arg1);
23273 wxPyEndAllowThreads(__tstate);
23274 if (PyErr_Occurred()) SWIG_fail;
23275 }
23276 {
23277 #if wxUSE_UNICODE
23278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23279 #else
23280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23281 #endif
23282 }
23283 {
23284 if (temp1)
23285 delete arg1;
23286 }
23287 return resultobj;
23288 fail:
23289 {
23290 if (temp1)
23291 delete arg1;
23292 }
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23298 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23299 return 1;
23300 }
23301
23302
23303 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23304 PyObject *pyobj = 0;
23305
23306 {
23307 #if wxUSE_UNICODE
23308 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23309 #else
23310 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23311 #endif
23312 }
23313 return pyobj;
23314 }
23315
23316
23317 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23318 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23319 return 1;
23320 }
23321
23322
23323 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23324 PyObject *pyobj = 0;
23325
23326 {
23327 #if wxUSE_UNICODE
23328 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23329 #else
23330 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23331 #endif
23332 }
23333 return pyobj;
23334 }
23335
23336
23337 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23338 PyObject *resultobj = 0;
23339 wxDateTime::Country arg1 ;
23340 int val1 ;
23341 int ecode1 = 0 ;
23342 PyObject * obj0 = 0 ;
23343 char * kwnames[] = {
23344 (char *) "country", NULL
23345 };
23346
23347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23348 ecode1 = SWIG_AsVal_int(obj0, &val1);
23349 if (!SWIG_IsOK(ecode1)) {
23350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23351 }
23352 arg1 = static_cast< wxDateTime::Country >(val1);
23353 {
23354 PyThreadState* __tstate = wxPyBeginAllowThreads();
23355 wxDateTime::SetCountry(arg1);
23356 wxPyEndAllowThreads(__tstate);
23357 if (PyErr_Occurred()) SWIG_fail;
23358 }
23359 resultobj = SWIG_Py_Void();
23360 return resultobj;
23361 fail:
23362 return NULL;
23363 }
23364
23365
23366 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23367 PyObject *resultobj = 0;
23368 wxDateTime::Country result;
23369
23370 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 result = (wxDateTime::Country)wxDateTime::GetCountry();
23374 wxPyEndAllowThreads(__tstate);
23375 if (PyErr_Occurred()) SWIG_fail;
23376 }
23377 resultobj = SWIG_From_int(static_cast< int >(result));
23378 return resultobj;
23379 fail:
23380 return NULL;
23381 }
23382
23383
23384 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23385 PyObject *resultobj = 0;
23386 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23387 bool result;
23388 int val1 ;
23389 int ecode1 = 0 ;
23390 PyObject * obj0 = 0 ;
23391 char * kwnames[] = {
23392 (char *) "country", NULL
23393 };
23394
23395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23396 if (obj0) {
23397 ecode1 = SWIG_AsVal_int(obj0, &val1);
23398 if (!SWIG_IsOK(ecode1)) {
23399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23400 }
23401 arg1 = static_cast< wxDateTime::Country >(val1);
23402 }
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 {
23410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23411 }
23412 return resultobj;
23413 fail:
23414 return NULL;
23415 }
23416
23417
23418 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23419 PyObject *resultobj = 0;
23420 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23421 int result;
23422 int val1 ;
23423 int ecode1 = 0 ;
23424 PyObject * obj0 = 0 ;
23425 char * kwnames[] = {
23426 (char *) "cal", NULL
23427 };
23428
23429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23430 if (obj0) {
23431 ecode1 = SWIG_AsVal_int(obj0, &val1);
23432 if (!SWIG_IsOK(ecode1)) {
23433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23434 }
23435 arg1 = static_cast< wxDateTime::Calendar >(val1);
23436 }
23437 {
23438 PyThreadState* __tstate = wxPyBeginAllowThreads();
23439 result = (int)wxDateTime::GetCurrentYear(arg1);
23440 wxPyEndAllowThreads(__tstate);
23441 if (PyErr_Occurred()) SWIG_fail;
23442 }
23443 resultobj = SWIG_From_int(static_cast< int >(result));
23444 return resultobj;
23445 fail:
23446 return NULL;
23447 }
23448
23449
23450 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23451 PyObject *resultobj = 0;
23452 int arg1 ;
23453 int result;
23454 int val1 ;
23455 int ecode1 = 0 ;
23456 PyObject * obj0 = 0 ;
23457 char * kwnames[] = {
23458 (char *) "year", NULL
23459 };
23460
23461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23462 ecode1 = SWIG_AsVal_int(obj0, &val1);
23463 if (!SWIG_IsOK(ecode1)) {
23464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23465 }
23466 arg1 = static_cast< int >(val1);
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 result = (int)wxDateTime::ConvertYearToBC(arg1);
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 resultobj = SWIG_From_int(static_cast< int >(result));
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj = 0;
23482 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23483 wxDateTime::Month result;
23484 int val1 ;
23485 int ecode1 = 0 ;
23486 PyObject * obj0 = 0 ;
23487 char * kwnames[] = {
23488 (char *) "cal", NULL
23489 };
23490
23491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23492 if (obj0) {
23493 ecode1 = SWIG_AsVal_int(obj0, &val1);
23494 if (!SWIG_IsOK(ecode1)) {
23495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23496 }
23497 arg1 = static_cast< wxDateTime::Calendar >(val1);
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23502 wxPyEndAllowThreads(__tstate);
23503 if (PyErr_Occurred()) SWIG_fail;
23504 }
23505 resultobj = SWIG_From_int(static_cast< int >(result));
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23513 PyObject *resultobj = 0;
23514 int arg1 = (int) wxDateTime::Inv_Year ;
23515 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23516 bool result;
23517 int val1 ;
23518 int ecode1 = 0 ;
23519 int val2 ;
23520 int ecode2 = 0 ;
23521 PyObject * obj0 = 0 ;
23522 PyObject * obj1 = 0 ;
23523 char * kwnames[] = {
23524 (char *) "year",(char *) "cal", NULL
23525 };
23526
23527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23528 if (obj0) {
23529 ecode1 = SWIG_AsVal_int(obj0, &val1);
23530 if (!SWIG_IsOK(ecode1)) {
23531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23532 }
23533 arg1 = static_cast< int >(val1);
23534 }
23535 if (obj1) {
23536 ecode2 = SWIG_AsVal_int(obj1, &val2);
23537 if (!SWIG_IsOK(ecode2)) {
23538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23539 }
23540 arg2 = static_cast< wxDateTime::Calendar >(val2);
23541 }
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 {
23549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23550 }
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23558 PyObject *resultobj = 0;
23559 int arg1 = (int) wxDateTime::Inv_Year ;
23560 int result;
23561 int val1 ;
23562 int ecode1 = 0 ;
23563 PyObject * obj0 = 0 ;
23564 char * kwnames[] = {
23565 (char *) "year", NULL
23566 };
23567
23568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23569 if (obj0) {
23570 ecode1 = SWIG_AsVal_int(obj0, &val1);
23571 if (!SWIG_IsOK(ecode1)) {
23572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23573 }
23574 arg1 = static_cast< int >(val1);
23575 }
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (int)wxDateTime::GetCentury(arg1);
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 resultobj = SWIG_From_int(static_cast< int >(result));
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23590 PyObject *resultobj = 0;
23591 int arg1 ;
23592 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23593 int result;
23594 int val1 ;
23595 int ecode1 = 0 ;
23596 int val2 ;
23597 int ecode2 = 0 ;
23598 PyObject * obj0 = 0 ;
23599 PyObject * obj1 = 0 ;
23600 char * kwnames[] = {
23601 (char *) "year",(char *) "cal", NULL
23602 };
23603
23604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23605 ecode1 = SWIG_AsVal_int(obj0, &val1);
23606 if (!SWIG_IsOK(ecode1)) {
23607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23608 }
23609 arg1 = static_cast< int >(val1);
23610 if (obj1) {
23611 ecode2 = SWIG_AsVal_int(obj1, &val2);
23612 if (!SWIG_IsOK(ecode2)) {
23613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23614 }
23615 arg2 = static_cast< wxDateTime::Calendar >(val2);
23616 }
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 resultobj = SWIG_From_int(static_cast< int >(result));
23624 return resultobj;
23625 fail:
23626 return NULL;
23627 }
23628
23629
23630 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23631 PyObject *resultobj = 0;
23632 wxDateTime::Month arg1 ;
23633 int arg2 = (int) wxDateTime::Inv_Year ;
23634 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23635 int result;
23636 int val1 ;
23637 int ecode1 = 0 ;
23638 int val2 ;
23639 int ecode2 = 0 ;
23640 int val3 ;
23641 int ecode3 = 0 ;
23642 PyObject * obj0 = 0 ;
23643 PyObject * obj1 = 0 ;
23644 PyObject * obj2 = 0 ;
23645 char * kwnames[] = {
23646 (char *) "month",(char *) "year",(char *) "cal", NULL
23647 };
23648
23649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23650 ecode1 = SWIG_AsVal_int(obj0, &val1);
23651 if (!SWIG_IsOK(ecode1)) {
23652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23653 }
23654 arg1 = static_cast< wxDateTime::Month >(val1);
23655 if (obj1) {
23656 ecode2 = SWIG_AsVal_int(obj1, &val2);
23657 if (!SWIG_IsOK(ecode2)) {
23658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23659 }
23660 arg2 = static_cast< int >(val2);
23661 }
23662 if (obj2) {
23663 ecode3 = SWIG_AsVal_int(obj2, &val3);
23664 if (!SWIG_IsOK(ecode3)) {
23665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23666 }
23667 arg3 = static_cast< wxDateTime::Calendar >(val3);
23668 }
23669 {
23670 PyThreadState* __tstate = wxPyBeginAllowThreads();
23671 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23672 wxPyEndAllowThreads(__tstate);
23673 if (PyErr_Occurred()) SWIG_fail;
23674 }
23675 resultobj = SWIG_From_int(static_cast< int >(result));
23676 return resultobj;
23677 fail:
23678 return NULL;
23679 }
23680
23681
23682 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23683 PyObject *resultobj = 0;
23684 wxDateTime::Month arg1 ;
23685 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23686 wxString result;
23687 int val1 ;
23688 int ecode1 = 0 ;
23689 int val2 ;
23690 int ecode2 = 0 ;
23691 PyObject * obj0 = 0 ;
23692 PyObject * obj1 = 0 ;
23693 char * kwnames[] = {
23694 (char *) "month",(char *) "flags", NULL
23695 };
23696
23697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23698 ecode1 = SWIG_AsVal_int(obj0, &val1);
23699 if (!SWIG_IsOK(ecode1)) {
23700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23701 }
23702 arg1 = static_cast< wxDateTime::Month >(val1);
23703 if (obj1) {
23704 ecode2 = SWIG_AsVal_int(obj1, &val2);
23705 if (!SWIG_IsOK(ecode2)) {
23706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23707 }
23708 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23709 }
23710 {
23711 PyThreadState* __tstate = wxPyBeginAllowThreads();
23712 result = wxDateTime::GetMonthName(arg1,arg2);
23713 wxPyEndAllowThreads(__tstate);
23714 if (PyErr_Occurred()) SWIG_fail;
23715 }
23716 {
23717 #if wxUSE_UNICODE
23718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23719 #else
23720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23721 #endif
23722 }
23723 return resultobj;
23724 fail:
23725 return NULL;
23726 }
23727
23728
23729 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23730 PyObject *resultobj = 0;
23731 wxDateTime::WeekDay arg1 ;
23732 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23733 wxString result;
23734 int val1 ;
23735 int ecode1 = 0 ;
23736 int val2 ;
23737 int ecode2 = 0 ;
23738 PyObject * obj0 = 0 ;
23739 PyObject * obj1 = 0 ;
23740 char * kwnames[] = {
23741 (char *) "weekday",(char *) "flags", NULL
23742 };
23743
23744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23745 ecode1 = SWIG_AsVal_int(obj0, &val1);
23746 if (!SWIG_IsOK(ecode1)) {
23747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23748 }
23749 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23750 if (obj1) {
23751 ecode2 = SWIG_AsVal_int(obj1, &val2);
23752 if (!SWIG_IsOK(ecode2)) {
23753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23754 }
23755 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23756 }
23757 {
23758 PyThreadState* __tstate = wxPyBeginAllowThreads();
23759 result = wxDateTime::GetWeekDayName(arg1,arg2);
23760 wxPyEndAllowThreads(__tstate);
23761 if (PyErr_Occurred()) SWIG_fail;
23762 }
23763 {
23764 #if wxUSE_UNICODE
23765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23766 #else
23767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23768 #endif
23769 }
23770 return resultobj;
23771 fail:
23772 return NULL;
23773 }
23774
23775
23776 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23777 PyObject *resultobj = 0;
23778 PyObject *result = 0 ;
23779
23780 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23781 {
23782 PyThreadState* __tstate = wxPyBeginAllowThreads();
23783 result = (PyObject *)wxDateTime_GetAmPmStrings();
23784 wxPyEndAllowThreads(__tstate);
23785 if (PyErr_Occurred()) SWIG_fail;
23786 }
23787 resultobj = result;
23788 return resultobj;
23789 fail:
23790 return NULL;
23791 }
23792
23793
23794 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23795 PyObject *resultobj = 0;
23796 int arg1 = (int) wxDateTime::Inv_Year ;
23797 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23798 bool result;
23799 int val1 ;
23800 int ecode1 = 0 ;
23801 int val2 ;
23802 int ecode2 = 0 ;
23803 PyObject * obj0 = 0 ;
23804 PyObject * obj1 = 0 ;
23805 char * kwnames[] = {
23806 (char *) "year",(char *) "country", NULL
23807 };
23808
23809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23810 if (obj0) {
23811 ecode1 = SWIG_AsVal_int(obj0, &val1);
23812 if (!SWIG_IsOK(ecode1)) {
23813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23814 }
23815 arg1 = static_cast< int >(val1);
23816 }
23817 if (obj1) {
23818 ecode2 = SWIG_AsVal_int(obj1, &val2);
23819 if (!SWIG_IsOK(ecode2)) {
23820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23821 }
23822 arg2 = static_cast< wxDateTime::Country >(val2);
23823 }
23824 {
23825 PyThreadState* __tstate = wxPyBeginAllowThreads();
23826 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23827 wxPyEndAllowThreads(__tstate);
23828 if (PyErr_Occurred()) SWIG_fail;
23829 }
23830 {
23831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23832 }
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23840 PyObject *resultobj = 0;
23841 int arg1 = (int) wxDateTime::Inv_Year ;
23842 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23843 wxDateTime result;
23844 int val1 ;
23845 int ecode1 = 0 ;
23846 int val2 ;
23847 int ecode2 = 0 ;
23848 PyObject * obj0 = 0 ;
23849 PyObject * obj1 = 0 ;
23850 char * kwnames[] = {
23851 (char *) "year",(char *) "country", NULL
23852 };
23853
23854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23855 if (obj0) {
23856 ecode1 = SWIG_AsVal_int(obj0, &val1);
23857 if (!SWIG_IsOK(ecode1)) {
23858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23859 }
23860 arg1 = static_cast< int >(val1);
23861 }
23862 if (obj1) {
23863 ecode2 = SWIG_AsVal_int(obj1, &val2);
23864 if (!SWIG_IsOK(ecode2)) {
23865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23866 }
23867 arg2 = static_cast< wxDateTime::Country >(val2);
23868 }
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = wxDateTime::GetBeginDST(arg1,arg2);
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23883 PyObject *resultobj = 0;
23884 int arg1 = (int) wxDateTime::Inv_Year ;
23885 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23886 wxDateTime result;
23887 int val1 ;
23888 int ecode1 = 0 ;
23889 int val2 ;
23890 int ecode2 = 0 ;
23891 PyObject * obj0 = 0 ;
23892 PyObject * obj1 = 0 ;
23893 char * kwnames[] = {
23894 (char *) "year",(char *) "country", NULL
23895 };
23896
23897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23898 if (obj0) {
23899 ecode1 = SWIG_AsVal_int(obj0, &val1);
23900 if (!SWIG_IsOK(ecode1)) {
23901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23902 }
23903 arg1 = static_cast< int >(val1);
23904 }
23905 if (obj1) {
23906 ecode2 = SWIG_AsVal_int(obj1, &val2);
23907 if (!SWIG_IsOK(ecode2)) {
23908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23909 }
23910 arg2 = static_cast< wxDateTime::Country >(val2);
23911 }
23912 {
23913 PyThreadState* __tstate = wxPyBeginAllowThreads();
23914 result = wxDateTime::GetEndDST(arg1,arg2);
23915 wxPyEndAllowThreads(__tstate);
23916 if (PyErr_Occurred()) SWIG_fail;
23917 }
23918 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23926 PyObject *resultobj = 0;
23927 wxDateTime result;
23928
23929 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23930 {
23931 PyThreadState* __tstate = wxPyBeginAllowThreads();
23932 result = wxDateTime::Now();
23933 wxPyEndAllowThreads(__tstate);
23934 if (PyErr_Occurred()) SWIG_fail;
23935 }
23936 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23937 return resultobj;
23938 fail:
23939 return NULL;
23940 }
23941
23942
23943 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23944 PyObject *resultobj = 0;
23945 wxDateTime result;
23946
23947 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23948 {
23949 PyThreadState* __tstate = wxPyBeginAllowThreads();
23950 result = wxDateTime::UNow();
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23962 PyObject *resultobj = 0;
23963 wxDateTime result;
23964
23965 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23966 {
23967 PyThreadState* __tstate = wxPyBeginAllowThreads();
23968 result = wxDateTime::Today();
23969 wxPyEndAllowThreads(__tstate);
23970 if (PyErr_Occurred()) SWIG_fail;
23971 }
23972 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23973 return resultobj;
23974 fail:
23975 return NULL;
23976 }
23977
23978
23979 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23980 PyObject *resultobj = 0;
23981 wxDateTime *result = 0 ;
23982
23983 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 result = (wxDateTime *)new wxDateTime();
23987 wxPyEndAllowThreads(__tstate);
23988 if (PyErr_Occurred()) SWIG_fail;
23989 }
23990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23998 PyObject *resultobj = 0;
23999 time_t arg1 ;
24000 wxDateTime *result = 0 ;
24001 unsigned int val1 ;
24002 int ecode1 = 0 ;
24003 PyObject * obj0 = 0 ;
24004 char * kwnames[] = {
24005 (char *) "timet", NULL
24006 };
24007
24008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
24009 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
24010 if (!SWIG_IsOK(ecode1)) {
24011 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
24012 }
24013 arg1 = static_cast< time_t >(val1);
24014 {
24015 PyThreadState* __tstate = wxPyBeginAllowThreads();
24016 result = (wxDateTime *)new wxDateTime(arg1);
24017 wxPyEndAllowThreads(__tstate);
24018 if (PyErr_Occurred()) SWIG_fail;
24019 }
24020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24021 return resultobj;
24022 fail:
24023 return NULL;
24024 }
24025
24026
24027 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24028 PyObject *resultobj = 0;
24029 double arg1 ;
24030 wxDateTime *result = 0 ;
24031 double val1 ;
24032 int ecode1 = 0 ;
24033 PyObject * obj0 = 0 ;
24034 char * kwnames[] = {
24035 (char *) "jdn", NULL
24036 };
24037
24038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
24039 ecode1 = SWIG_AsVal_double(obj0, &val1);
24040 if (!SWIG_IsOK(ecode1)) {
24041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
24042 }
24043 arg1 = static_cast< double >(val1);
24044 {
24045 PyThreadState* __tstate = wxPyBeginAllowThreads();
24046 result = (wxDateTime *)new wxDateTime(arg1);
24047 wxPyEndAllowThreads(__tstate);
24048 if (PyErr_Occurred()) SWIG_fail;
24049 }
24050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24051 return resultobj;
24052 fail:
24053 return NULL;
24054 }
24055
24056
24057 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24058 PyObject *resultobj = 0;
24059 int arg1 ;
24060 int arg2 = (int) 0 ;
24061 int arg3 = (int) 0 ;
24062 int arg4 = (int) 0 ;
24063 wxDateTime *result = 0 ;
24064 int val1 ;
24065 int ecode1 = 0 ;
24066 int val2 ;
24067 int ecode2 = 0 ;
24068 int val3 ;
24069 int ecode3 = 0 ;
24070 int val4 ;
24071 int ecode4 = 0 ;
24072 PyObject * obj0 = 0 ;
24073 PyObject * obj1 = 0 ;
24074 PyObject * obj2 = 0 ;
24075 PyObject * obj3 = 0 ;
24076 char * kwnames[] = {
24077 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24078 };
24079
24080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24081 ecode1 = SWIG_AsVal_int(obj0, &val1);
24082 if (!SWIG_IsOK(ecode1)) {
24083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
24084 }
24085 arg1 = static_cast< int >(val1);
24086 if (obj1) {
24087 ecode2 = SWIG_AsVal_int(obj1, &val2);
24088 if (!SWIG_IsOK(ecode2)) {
24089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
24090 }
24091 arg2 = static_cast< int >(val2);
24092 }
24093 if (obj2) {
24094 ecode3 = SWIG_AsVal_int(obj2, &val3);
24095 if (!SWIG_IsOK(ecode3)) {
24096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
24097 }
24098 arg3 = static_cast< int >(val3);
24099 }
24100 if (obj3) {
24101 ecode4 = SWIG_AsVal_int(obj3, &val4);
24102 if (!SWIG_IsOK(ecode4)) {
24103 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
24104 }
24105 arg4 = static_cast< int >(val4);
24106 }
24107 {
24108 PyThreadState* __tstate = wxPyBeginAllowThreads();
24109 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
24110 wxPyEndAllowThreads(__tstate);
24111 if (PyErr_Occurred()) SWIG_fail;
24112 }
24113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24114 return resultobj;
24115 fail:
24116 return NULL;
24117 }
24118
24119
24120 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24121 PyObject *resultobj = 0;
24122 int arg1 ;
24123 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24124 int arg3 = (int) wxDateTime::Inv_Year ;
24125 int arg4 = (int) 0 ;
24126 int arg5 = (int) 0 ;
24127 int arg6 = (int) 0 ;
24128 int arg7 = (int) 0 ;
24129 wxDateTime *result = 0 ;
24130 int val1 ;
24131 int ecode1 = 0 ;
24132 int val2 ;
24133 int ecode2 = 0 ;
24134 int val3 ;
24135 int ecode3 = 0 ;
24136 int val4 ;
24137 int ecode4 = 0 ;
24138 int val5 ;
24139 int ecode5 = 0 ;
24140 int val6 ;
24141 int ecode6 = 0 ;
24142 int val7 ;
24143 int ecode7 = 0 ;
24144 PyObject * obj0 = 0 ;
24145 PyObject * obj1 = 0 ;
24146 PyObject * obj2 = 0 ;
24147 PyObject * obj3 = 0 ;
24148 PyObject * obj4 = 0 ;
24149 PyObject * obj5 = 0 ;
24150 PyObject * obj6 = 0 ;
24151 char * kwnames[] = {
24152 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24153 };
24154
24155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24156 ecode1 = SWIG_AsVal_int(obj0, &val1);
24157 if (!SWIG_IsOK(ecode1)) {
24158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24159 }
24160 arg1 = static_cast< int >(val1);
24161 if (obj1) {
24162 ecode2 = SWIG_AsVal_int(obj1, &val2);
24163 if (!SWIG_IsOK(ecode2)) {
24164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24165 }
24166 arg2 = static_cast< wxDateTime::Month >(val2);
24167 }
24168 if (obj2) {
24169 ecode3 = SWIG_AsVal_int(obj2, &val3);
24170 if (!SWIG_IsOK(ecode3)) {
24171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24172 }
24173 arg3 = static_cast< int >(val3);
24174 }
24175 if (obj3) {
24176 ecode4 = SWIG_AsVal_int(obj3, &val4);
24177 if (!SWIG_IsOK(ecode4)) {
24178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24179 }
24180 arg4 = static_cast< int >(val4);
24181 }
24182 if (obj4) {
24183 ecode5 = SWIG_AsVal_int(obj4, &val5);
24184 if (!SWIG_IsOK(ecode5)) {
24185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24186 }
24187 arg5 = static_cast< int >(val5);
24188 }
24189 if (obj5) {
24190 ecode6 = SWIG_AsVal_int(obj5, &val6);
24191 if (!SWIG_IsOK(ecode6)) {
24192 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24193 }
24194 arg6 = static_cast< int >(val6);
24195 }
24196 if (obj6) {
24197 ecode7 = SWIG_AsVal_int(obj6, &val7);
24198 if (!SWIG_IsOK(ecode7)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24200 }
24201 arg7 = static_cast< int >(val7);
24202 }
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24217 PyObject *resultobj = 0;
24218 wxDateTime *arg1 = 0 ;
24219 wxDateTime *result = 0 ;
24220 void *argp1 = 0 ;
24221 int res1 = 0 ;
24222 PyObject * obj0 = 0 ;
24223 char * kwnames[] = {
24224 (char *) "date", NULL
24225 };
24226
24227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24228 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24229 if (!SWIG_IsOK(res1)) {
24230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24231 }
24232 if (!argp1) {
24233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24234 }
24235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24243 return resultobj;
24244 fail:
24245 return NULL;
24246 }
24247
24248
24249 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250 PyObject *resultobj = 0;
24251 wxDateTime *arg1 = (wxDateTime *) 0 ;
24252 void *argp1 = 0 ;
24253 int res1 = 0 ;
24254 PyObject *swig_obj[1] ;
24255
24256 if (!args) SWIG_fail;
24257 swig_obj[0] = args;
24258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24261 }
24262 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24263 {
24264 PyThreadState* __tstate = wxPyBeginAllowThreads();
24265 delete arg1;
24266
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 resultobj = SWIG_Py_Void();
24271 return resultobj;
24272 fail:
24273 return NULL;
24274 }
24275
24276
24277 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24278 PyObject *resultobj = 0;
24279 wxDateTime *arg1 = (wxDateTime *) 0 ;
24280 wxDateTime *result = 0 ;
24281 void *argp1 = 0 ;
24282 int res1 = 0 ;
24283 PyObject *swig_obj[1] ;
24284
24285 if (!args) SWIG_fail;
24286 swig_obj[0] = args;
24287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24288 if (!SWIG_IsOK(res1)) {
24289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24290 }
24291 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 {
24295 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24296 result = (wxDateTime *) &_result_ref;
24297 }
24298 wxPyEndAllowThreads(__tstate);
24299 if (PyErr_Occurred()) SWIG_fail;
24300 }
24301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj = 0;
24310 wxDateTime *arg1 = (wxDateTime *) 0 ;
24311 time_t arg2 ;
24312 wxDateTime *result = 0 ;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 unsigned int val2 ;
24316 int ecode2 = 0 ;
24317 PyObject * obj0 = 0 ;
24318 PyObject * obj1 = 0 ;
24319 char * kwnames[] = {
24320 (char *) "self",(char *) "timet", NULL
24321 };
24322
24323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24325 if (!SWIG_IsOK(res1)) {
24326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24327 }
24328 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24329 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24330 if (!SWIG_IsOK(ecode2)) {
24331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24332 }
24333 arg2 = static_cast< time_t >(val2);
24334 {
24335 PyThreadState* __tstate = wxPyBeginAllowThreads();
24336 {
24337 wxDateTime &_result_ref = (arg1)->Set(arg2);
24338 result = (wxDateTime *) &_result_ref;
24339 }
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj = 0;
24352 wxDateTime *arg1 = (wxDateTime *) 0 ;
24353 double arg2 ;
24354 wxDateTime *result = 0 ;
24355 void *argp1 = 0 ;
24356 int res1 = 0 ;
24357 double val2 ;
24358 int ecode2 = 0 ;
24359 PyObject * obj0 = 0 ;
24360 PyObject * obj1 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "self",(char *) "jdn", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24367 if (!SWIG_IsOK(res1)) {
24368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24369 }
24370 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24371 ecode2 = SWIG_AsVal_double(obj1, &val2);
24372 if (!SWIG_IsOK(ecode2)) {
24373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24374 }
24375 arg2 = static_cast< double >(val2);
24376 {
24377 PyThreadState* __tstate = wxPyBeginAllowThreads();
24378 {
24379 wxDateTime &_result_ref = (arg1)->Set(arg2);
24380 result = (wxDateTime *) &_result_ref;
24381 }
24382 wxPyEndAllowThreads(__tstate);
24383 if (PyErr_Occurred()) SWIG_fail;
24384 }
24385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24386 return resultobj;
24387 fail:
24388 return NULL;
24389 }
24390
24391
24392 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24393 PyObject *resultobj = 0;
24394 wxDateTime *arg1 = (wxDateTime *) 0 ;
24395 int arg2 ;
24396 int arg3 = (int) 0 ;
24397 int arg4 = (int) 0 ;
24398 int arg5 = (int) 0 ;
24399 wxDateTime *result = 0 ;
24400 void *argp1 = 0 ;
24401 int res1 = 0 ;
24402 int val2 ;
24403 int ecode2 = 0 ;
24404 int val3 ;
24405 int ecode3 = 0 ;
24406 int val4 ;
24407 int ecode4 = 0 ;
24408 int val5 ;
24409 int ecode5 = 0 ;
24410 PyObject * obj0 = 0 ;
24411 PyObject * obj1 = 0 ;
24412 PyObject * obj2 = 0 ;
24413 PyObject * obj3 = 0 ;
24414 PyObject * obj4 = 0 ;
24415 char * kwnames[] = {
24416 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24417 };
24418
24419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24421 if (!SWIG_IsOK(res1)) {
24422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24423 }
24424 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24425 ecode2 = SWIG_AsVal_int(obj1, &val2);
24426 if (!SWIG_IsOK(ecode2)) {
24427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24428 }
24429 arg2 = static_cast< int >(val2);
24430 if (obj2) {
24431 ecode3 = SWIG_AsVal_int(obj2, &val3);
24432 if (!SWIG_IsOK(ecode3)) {
24433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24434 }
24435 arg3 = static_cast< int >(val3);
24436 }
24437 if (obj3) {
24438 ecode4 = SWIG_AsVal_int(obj3, &val4);
24439 if (!SWIG_IsOK(ecode4)) {
24440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24441 }
24442 arg4 = static_cast< int >(val4);
24443 }
24444 if (obj4) {
24445 ecode5 = SWIG_AsVal_int(obj4, &val5);
24446 if (!SWIG_IsOK(ecode5)) {
24447 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24448 }
24449 arg5 = static_cast< int >(val5);
24450 }
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 {
24454 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24455 result = (wxDateTime *) &_result_ref;
24456 }
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24468 PyObject *resultobj = 0;
24469 wxDateTime *arg1 = (wxDateTime *) 0 ;
24470 int arg2 ;
24471 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24472 int arg4 = (int) wxDateTime::Inv_Year ;
24473 int arg5 = (int) 0 ;
24474 int arg6 = (int) 0 ;
24475 int arg7 = (int) 0 ;
24476 int arg8 = (int) 0 ;
24477 wxDateTime *result = 0 ;
24478 void *argp1 = 0 ;
24479 int res1 = 0 ;
24480 int val2 ;
24481 int ecode2 = 0 ;
24482 int val3 ;
24483 int ecode3 = 0 ;
24484 int val4 ;
24485 int ecode4 = 0 ;
24486 int val5 ;
24487 int ecode5 = 0 ;
24488 int val6 ;
24489 int ecode6 = 0 ;
24490 int val7 ;
24491 int ecode7 = 0 ;
24492 int val8 ;
24493 int ecode8 = 0 ;
24494 PyObject * obj0 = 0 ;
24495 PyObject * obj1 = 0 ;
24496 PyObject * obj2 = 0 ;
24497 PyObject * obj3 = 0 ;
24498 PyObject * obj4 = 0 ;
24499 PyObject * obj5 = 0 ;
24500 PyObject * obj6 = 0 ;
24501 PyObject * obj7 = 0 ;
24502 char * kwnames[] = {
24503 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24504 };
24505
24506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24508 if (!SWIG_IsOK(res1)) {
24509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24510 }
24511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24512 ecode2 = SWIG_AsVal_int(obj1, &val2);
24513 if (!SWIG_IsOK(ecode2)) {
24514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24515 }
24516 arg2 = static_cast< int >(val2);
24517 if (obj2) {
24518 ecode3 = SWIG_AsVal_int(obj2, &val3);
24519 if (!SWIG_IsOK(ecode3)) {
24520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24521 }
24522 arg3 = static_cast< wxDateTime::Month >(val3);
24523 }
24524 if (obj3) {
24525 ecode4 = SWIG_AsVal_int(obj3, &val4);
24526 if (!SWIG_IsOK(ecode4)) {
24527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24528 }
24529 arg4 = static_cast< int >(val4);
24530 }
24531 if (obj4) {
24532 ecode5 = SWIG_AsVal_int(obj4, &val5);
24533 if (!SWIG_IsOK(ecode5)) {
24534 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24535 }
24536 arg5 = static_cast< int >(val5);
24537 }
24538 if (obj5) {
24539 ecode6 = SWIG_AsVal_int(obj5, &val6);
24540 if (!SWIG_IsOK(ecode6)) {
24541 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24542 }
24543 arg6 = static_cast< int >(val6);
24544 }
24545 if (obj6) {
24546 ecode7 = SWIG_AsVal_int(obj6, &val7);
24547 if (!SWIG_IsOK(ecode7)) {
24548 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24549 }
24550 arg7 = static_cast< int >(val7);
24551 }
24552 if (obj7) {
24553 ecode8 = SWIG_AsVal_int(obj7, &val8);
24554 if (!SWIG_IsOK(ecode8)) {
24555 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24556 }
24557 arg8 = static_cast< int >(val8);
24558 }
24559 {
24560 PyThreadState* __tstate = wxPyBeginAllowThreads();
24561 {
24562 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24563 result = (wxDateTime *) &_result_ref;
24564 }
24565 wxPyEndAllowThreads(__tstate);
24566 if (PyErr_Occurred()) SWIG_fail;
24567 }
24568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24576 PyObject *resultobj = 0;
24577 wxDateTime *arg1 = (wxDateTime *) 0 ;
24578 wxDateTime *result = 0 ;
24579 void *argp1 = 0 ;
24580 int res1 = 0 ;
24581 PyObject *swig_obj[1] ;
24582
24583 if (!args) SWIG_fail;
24584 swig_obj[0] = args;
24585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24586 if (!SWIG_IsOK(res1)) {
24587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24588 }
24589 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 {
24593 wxDateTime &_result_ref = (arg1)->ResetTime();
24594 result = (wxDateTime *) &_result_ref;
24595 }
24596 wxPyEndAllowThreads(__tstate);
24597 if (PyErr_Occurred()) SWIG_fail;
24598 }
24599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 SWIGINTERN PyObject *_wrap_DateTime_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24607 PyObject *resultobj = 0;
24608 wxDateTime *arg1 = (wxDateTime *) 0 ;
24609 wxDateTime result;
24610 void *argp1 = 0 ;
24611 int res1 = 0 ;
24612 PyObject *swig_obj[1] ;
24613
24614 if (!args) SWIG_fail;
24615 swig_obj[0] = args;
24616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24617 if (!SWIG_IsOK(res1)) {
24618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24619 }
24620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24621 {
24622 PyThreadState* __tstate = wxPyBeginAllowThreads();
24623 result = ((wxDateTime const *)arg1)->GetDateOnly();
24624 wxPyEndAllowThreads(__tstate);
24625 if (PyErr_Occurred()) SWIG_fail;
24626 }
24627 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj = 0;
24636 wxDateTime *arg1 = (wxDateTime *) 0 ;
24637 int arg2 ;
24638 wxDateTime *result = 0 ;
24639 void *argp1 = 0 ;
24640 int res1 = 0 ;
24641 int val2 ;
24642 int ecode2 = 0 ;
24643 PyObject * obj0 = 0 ;
24644 PyObject * obj1 = 0 ;
24645 char * kwnames[] = {
24646 (char *) "self",(char *) "year", NULL
24647 };
24648
24649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24651 if (!SWIG_IsOK(res1)) {
24652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24653 }
24654 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24655 ecode2 = SWIG_AsVal_int(obj1, &val2);
24656 if (!SWIG_IsOK(ecode2)) {
24657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24658 }
24659 arg2 = static_cast< int >(val2);
24660 {
24661 PyThreadState* __tstate = wxPyBeginAllowThreads();
24662 {
24663 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24664 result = (wxDateTime *) &_result_ref;
24665 }
24666 wxPyEndAllowThreads(__tstate);
24667 if (PyErr_Occurred()) SWIG_fail;
24668 }
24669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24670 return resultobj;
24671 fail:
24672 return NULL;
24673 }
24674
24675
24676 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24677 PyObject *resultobj = 0;
24678 wxDateTime *arg1 = (wxDateTime *) 0 ;
24679 wxDateTime::Month arg2 ;
24680 wxDateTime *result = 0 ;
24681 void *argp1 = 0 ;
24682 int res1 = 0 ;
24683 int val2 ;
24684 int ecode2 = 0 ;
24685 PyObject * obj0 = 0 ;
24686 PyObject * obj1 = 0 ;
24687 char * kwnames[] = {
24688 (char *) "self",(char *) "month", NULL
24689 };
24690
24691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24693 if (!SWIG_IsOK(res1)) {
24694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24695 }
24696 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24697 ecode2 = SWIG_AsVal_int(obj1, &val2);
24698 if (!SWIG_IsOK(ecode2)) {
24699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24700 }
24701 arg2 = static_cast< wxDateTime::Month >(val2);
24702 {
24703 PyThreadState* __tstate = wxPyBeginAllowThreads();
24704 {
24705 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24706 result = (wxDateTime *) &_result_ref;
24707 }
24708 wxPyEndAllowThreads(__tstate);
24709 if (PyErr_Occurred()) SWIG_fail;
24710 }
24711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24712 return resultobj;
24713 fail:
24714 return NULL;
24715 }
24716
24717
24718 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24719 PyObject *resultobj = 0;
24720 wxDateTime *arg1 = (wxDateTime *) 0 ;
24721 int arg2 ;
24722 wxDateTime *result = 0 ;
24723 void *argp1 = 0 ;
24724 int res1 = 0 ;
24725 int val2 ;
24726 int ecode2 = 0 ;
24727 PyObject * obj0 = 0 ;
24728 PyObject * obj1 = 0 ;
24729 char * kwnames[] = {
24730 (char *) "self",(char *) "day", NULL
24731 };
24732
24733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24737 }
24738 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24739 ecode2 = SWIG_AsVal_int(obj1, &val2);
24740 if (!SWIG_IsOK(ecode2)) {
24741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24742 }
24743 arg2 = static_cast< int >(val2);
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 {
24747 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24748 result = (wxDateTime *) &_result_ref;
24749 }
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24761 PyObject *resultobj = 0;
24762 wxDateTime *arg1 = (wxDateTime *) 0 ;
24763 int arg2 ;
24764 wxDateTime *result = 0 ;
24765 void *argp1 = 0 ;
24766 int res1 = 0 ;
24767 int val2 ;
24768 int ecode2 = 0 ;
24769 PyObject * obj0 = 0 ;
24770 PyObject * obj1 = 0 ;
24771 char * kwnames[] = {
24772 (char *) "self",(char *) "hour", NULL
24773 };
24774
24775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24777 if (!SWIG_IsOK(res1)) {
24778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24779 }
24780 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24781 ecode2 = SWIG_AsVal_int(obj1, &val2);
24782 if (!SWIG_IsOK(ecode2)) {
24783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24784 }
24785 arg2 = static_cast< int >(val2);
24786 {
24787 PyThreadState* __tstate = wxPyBeginAllowThreads();
24788 {
24789 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24790 result = (wxDateTime *) &_result_ref;
24791 }
24792 wxPyEndAllowThreads(__tstate);
24793 if (PyErr_Occurred()) SWIG_fail;
24794 }
24795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24796 return resultobj;
24797 fail:
24798 return NULL;
24799 }
24800
24801
24802 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24803 PyObject *resultobj = 0;
24804 wxDateTime *arg1 = (wxDateTime *) 0 ;
24805 int arg2 ;
24806 wxDateTime *result = 0 ;
24807 void *argp1 = 0 ;
24808 int res1 = 0 ;
24809 int val2 ;
24810 int ecode2 = 0 ;
24811 PyObject * obj0 = 0 ;
24812 PyObject * obj1 = 0 ;
24813 char * kwnames[] = {
24814 (char *) "self",(char *) "minute", NULL
24815 };
24816
24817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24819 if (!SWIG_IsOK(res1)) {
24820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24821 }
24822 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24823 ecode2 = SWIG_AsVal_int(obj1, &val2);
24824 if (!SWIG_IsOK(ecode2)) {
24825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24826 }
24827 arg2 = static_cast< int >(val2);
24828 {
24829 PyThreadState* __tstate = wxPyBeginAllowThreads();
24830 {
24831 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24832 result = (wxDateTime *) &_result_ref;
24833 }
24834 wxPyEndAllowThreads(__tstate);
24835 if (PyErr_Occurred()) SWIG_fail;
24836 }
24837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24838 return resultobj;
24839 fail:
24840 return NULL;
24841 }
24842
24843
24844 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24845 PyObject *resultobj = 0;
24846 wxDateTime *arg1 = (wxDateTime *) 0 ;
24847 int arg2 ;
24848 wxDateTime *result = 0 ;
24849 void *argp1 = 0 ;
24850 int res1 = 0 ;
24851 int val2 ;
24852 int ecode2 = 0 ;
24853 PyObject * obj0 = 0 ;
24854 PyObject * obj1 = 0 ;
24855 char * kwnames[] = {
24856 (char *) "self",(char *) "second", NULL
24857 };
24858
24859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24861 if (!SWIG_IsOK(res1)) {
24862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24863 }
24864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24865 ecode2 = SWIG_AsVal_int(obj1, &val2);
24866 if (!SWIG_IsOK(ecode2)) {
24867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24868 }
24869 arg2 = static_cast< int >(val2);
24870 {
24871 PyThreadState* __tstate = wxPyBeginAllowThreads();
24872 {
24873 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24874 result = (wxDateTime *) &_result_ref;
24875 }
24876 wxPyEndAllowThreads(__tstate);
24877 if (PyErr_Occurred()) SWIG_fail;
24878 }
24879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24880 return resultobj;
24881 fail:
24882 return NULL;
24883 }
24884
24885
24886 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24887 PyObject *resultobj = 0;
24888 wxDateTime *arg1 = (wxDateTime *) 0 ;
24889 int 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 *) "millisecond", NULL
24899 };
24900
24901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",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_SetMillisecond" "', 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_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24910 }
24911 arg2 = static_cast< int >(val2);
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 {
24915 wxDateTime &_result_ref = (arg1)->SetMillisecond(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_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = 0;
24930 wxDateTime *arg1 = (wxDateTime *) 0 ;
24931 wxDateTime::WeekDay arg2 ;
24932 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24933 wxDateTime *result = 0 ;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 int val2 ;
24937 int ecode2 = 0 ;
24938 int val3 ;
24939 int ecode3 = 0 ;
24940 PyObject * obj0 = 0 ;
24941 PyObject * obj1 = 0 ;
24942 PyObject * obj2 = 0 ;
24943 char * kwnames[] = {
24944 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24945 };
24946
24947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24949 if (!SWIG_IsOK(res1)) {
24950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24951 }
24952 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24953 ecode2 = SWIG_AsVal_int(obj1, &val2);
24954 if (!SWIG_IsOK(ecode2)) {
24955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24956 }
24957 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24958 if (obj2) {
24959 ecode3 = SWIG_AsVal_int(obj2, &val3);
24960 if (!SWIG_IsOK(ecode3)) {
24961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24962 }
24963 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24964 }
24965 {
24966 PyThreadState* __tstate = wxPyBeginAllowThreads();
24967 {
24968 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24969 result = (wxDateTime *) &_result_ref;
24970 }
24971 wxPyEndAllowThreads(__tstate);
24972 if (PyErr_Occurred()) SWIG_fail;
24973 }
24974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24982 PyObject *resultobj = 0;
24983 wxDateTime *arg1 = (wxDateTime *) 0 ;
24984 wxDateTime::WeekDay arg2 ;
24985 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24986 wxDateTime result;
24987 void *argp1 = 0 ;
24988 int res1 = 0 ;
24989 int val2 ;
24990 int ecode2 = 0 ;
24991 int val3 ;
24992 int ecode3 = 0 ;
24993 PyObject * obj0 = 0 ;
24994 PyObject * obj1 = 0 ;
24995 PyObject * obj2 = 0 ;
24996 char * kwnames[] = {
24997 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24998 };
24999
25000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25002 if (!SWIG_IsOK(res1)) {
25003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25004 }
25005 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25006 ecode2 = SWIG_AsVal_int(obj1, &val2);
25007 if (!SWIG_IsOK(ecode2)) {
25008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25009 }
25010 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25011 if (obj2) {
25012 ecode3 = SWIG_AsVal_int(obj2, &val3);
25013 if (!SWIG_IsOK(ecode3)) {
25014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
25015 }
25016 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
25017 }
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25025 return resultobj;
25026 fail:
25027 return NULL;
25028 }
25029
25030
25031 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25032 PyObject *resultobj = 0;
25033 wxDateTime *arg1 = (wxDateTime *) 0 ;
25034 wxDateTime::WeekDay arg2 ;
25035 wxDateTime *result = 0 ;
25036 void *argp1 = 0 ;
25037 int res1 = 0 ;
25038 int val2 ;
25039 int ecode2 = 0 ;
25040 PyObject * obj0 = 0 ;
25041 PyObject * obj1 = 0 ;
25042 char * kwnames[] = {
25043 (char *) "self",(char *) "weekday", NULL
25044 };
25045
25046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25048 if (!SWIG_IsOK(res1)) {
25049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25050 }
25051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25052 ecode2 = SWIG_AsVal_int(obj1, &val2);
25053 if (!SWIG_IsOK(ecode2)) {
25054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25055 }
25056 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25057 {
25058 PyThreadState* __tstate = wxPyBeginAllowThreads();
25059 {
25060 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
25061 result = (wxDateTime *) &_result_ref;
25062 }
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj = 0;
25075 wxDateTime *arg1 = (wxDateTime *) 0 ;
25076 wxDateTime::WeekDay arg2 ;
25077 wxDateTime result;
25078 void *argp1 = 0 ;
25079 int res1 = 0 ;
25080 int val2 ;
25081 int ecode2 = 0 ;
25082 PyObject * obj0 = 0 ;
25083 PyObject * obj1 = 0 ;
25084 char * kwnames[] = {
25085 (char *) "self",(char *) "weekday", NULL
25086 };
25087
25088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25090 if (!SWIG_IsOK(res1)) {
25091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25092 }
25093 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25094 ecode2 = SWIG_AsVal_int(obj1, &val2);
25095 if (!SWIG_IsOK(ecode2)) {
25096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25097 }
25098 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25099 {
25100 PyThreadState* __tstate = wxPyBeginAllowThreads();
25101 result = (arg1)->GetNextWeekDay(arg2);
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25106 return resultobj;
25107 fail:
25108 return NULL;
25109 }
25110
25111
25112 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj = 0;
25114 wxDateTime *arg1 = (wxDateTime *) 0 ;
25115 wxDateTime::WeekDay arg2 ;
25116 wxDateTime *result = 0 ;
25117 void *argp1 = 0 ;
25118 int res1 = 0 ;
25119 int val2 ;
25120 int ecode2 = 0 ;
25121 PyObject * obj0 = 0 ;
25122 PyObject * obj1 = 0 ;
25123 char * kwnames[] = {
25124 (char *) "self",(char *) "weekday", NULL
25125 };
25126
25127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25129 if (!SWIG_IsOK(res1)) {
25130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25131 }
25132 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25133 ecode2 = SWIG_AsVal_int(obj1, &val2);
25134 if (!SWIG_IsOK(ecode2)) {
25135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25136 }
25137 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25138 {
25139 PyThreadState* __tstate = wxPyBeginAllowThreads();
25140 {
25141 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
25142 result = (wxDateTime *) &_result_ref;
25143 }
25144 wxPyEndAllowThreads(__tstate);
25145 if (PyErr_Occurred()) SWIG_fail;
25146 }
25147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25148 return resultobj;
25149 fail:
25150 return NULL;
25151 }
25152
25153
25154 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25155 PyObject *resultobj = 0;
25156 wxDateTime *arg1 = (wxDateTime *) 0 ;
25157 wxDateTime::WeekDay arg2 ;
25158 wxDateTime result;
25159 void *argp1 = 0 ;
25160 int res1 = 0 ;
25161 int val2 ;
25162 int ecode2 = 0 ;
25163 PyObject * obj0 = 0 ;
25164 PyObject * obj1 = 0 ;
25165 char * kwnames[] = {
25166 (char *) "self",(char *) "weekday", NULL
25167 };
25168
25169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25171 if (!SWIG_IsOK(res1)) {
25172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25173 }
25174 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25175 ecode2 = SWIG_AsVal_int(obj1, &val2);
25176 if (!SWIG_IsOK(ecode2)) {
25177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25178 }
25179 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (arg1)->GetPrevWeekDay(arg2);
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25194 PyObject *resultobj = 0;
25195 wxDateTime *arg1 = (wxDateTime *) 0 ;
25196 wxDateTime::WeekDay arg2 ;
25197 int arg3 = (int) 1 ;
25198 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25199 int arg5 = (int) wxDateTime::Inv_Year ;
25200 bool result;
25201 void *argp1 = 0 ;
25202 int res1 = 0 ;
25203 int val2 ;
25204 int ecode2 = 0 ;
25205 int val3 ;
25206 int ecode3 = 0 ;
25207 int val4 ;
25208 int ecode4 = 0 ;
25209 int val5 ;
25210 int ecode5 = 0 ;
25211 PyObject * obj0 = 0 ;
25212 PyObject * obj1 = 0 ;
25213 PyObject * obj2 = 0 ;
25214 PyObject * obj3 = 0 ;
25215 PyObject * obj4 = 0 ;
25216 char * kwnames[] = {
25217 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25218 };
25219
25220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25222 if (!SWIG_IsOK(res1)) {
25223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25224 }
25225 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25226 ecode2 = SWIG_AsVal_int(obj1, &val2);
25227 if (!SWIG_IsOK(ecode2)) {
25228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25229 }
25230 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25231 if (obj2) {
25232 ecode3 = SWIG_AsVal_int(obj2, &val3);
25233 if (!SWIG_IsOK(ecode3)) {
25234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25235 }
25236 arg3 = static_cast< int >(val3);
25237 }
25238 if (obj3) {
25239 ecode4 = SWIG_AsVal_int(obj3, &val4);
25240 if (!SWIG_IsOK(ecode4)) {
25241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25242 }
25243 arg4 = static_cast< wxDateTime::Month >(val4);
25244 }
25245 if (obj4) {
25246 ecode5 = SWIG_AsVal_int(obj4, &val5);
25247 if (!SWIG_IsOK(ecode5)) {
25248 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25249 }
25250 arg5 = static_cast< int >(val5);
25251 }
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 {
25259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25260 }
25261 return resultobj;
25262 fail:
25263 return NULL;
25264 }
25265
25266
25267 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25268 PyObject *resultobj = 0;
25269 wxDateTime *arg1 = (wxDateTime *) 0 ;
25270 wxDateTime::WeekDay arg2 ;
25271 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25272 int arg4 = (int) wxDateTime::Inv_Year ;
25273 bool result;
25274 void *argp1 = 0 ;
25275 int res1 = 0 ;
25276 int val2 ;
25277 int ecode2 = 0 ;
25278 int val3 ;
25279 int ecode3 = 0 ;
25280 int val4 ;
25281 int ecode4 = 0 ;
25282 PyObject * obj0 = 0 ;
25283 PyObject * obj1 = 0 ;
25284 PyObject * obj2 = 0 ;
25285 PyObject * obj3 = 0 ;
25286 char * kwnames[] = {
25287 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25288 };
25289
25290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25292 if (!SWIG_IsOK(res1)) {
25293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25294 }
25295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25296 ecode2 = SWIG_AsVal_int(obj1, &val2);
25297 if (!SWIG_IsOK(ecode2)) {
25298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25299 }
25300 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25301 if (obj2) {
25302 ecode3 = SWIG_AsVal_int(obj2, &val3);
25303 if (!SWIG_IsOK(ecode3)) {
25304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25305 }
25306 arg3 = static_cast< wxDateTime::Month >(val3);
25307 }
25308 if (obj3) {
25309 ecode4 = SWIG_AsVal_int(obj3, &val4);
25310 if (!SWIG_IsOK(ecode4)) {
25311 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25312 }
25313 arg4 = static_cast< int >(val4);
25314 }
25315 {
25316 PyThreadState* __tstate = wxPyBeginAllowThreads();
25317 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25318 wxPyEndAllowThreads(__tstate);
25319 if (PyErr_Occurred()) SWIG_fail;
25320 }
25321 {
25322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25323 }
25324 return resultobj;
25325 fail:
25326 return NULL;
25327 }
25328
25329
25330 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25331 PyObject *resultobj = 0;
25332 wxDateTime *arg1 = (wxDateTime *) 0 ;
25333 wxDateTime::WeekDay arg2 ;
25334 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25335 int arg4 = (int) wxDateTime::Inv_Year ;
25336 wxDateTime result;
25337 void *argp1 = 0 ;
25338 int res1 = 0 ;
25339 int val2 ;
25340 int ecode2 = 0 ;
25341 int val3 ;
25342 int ecode3 = 0 ;
25343 int val4 ;
25344 int ecode4 = 0 ;
25345 PyObject * obj0 = 0 ;
25346 PyObject * obj1 = 0 ;
25347 PyObject * obj2 = 0 ;
25348 PyObject * obj3 = 0 ;
25349 char * kwnames[] = {
25350 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25351 };
25352
25353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25355 if (!SWIG_IsOK(res1)) {
25356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25357 }
25358 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25359 ecode2 = SWIG_AsVal_int(obj1, &val2);
25360 if (!SWIG_IsOK(ecode2)) {
25361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25362 }
25363 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25364 if (obj2) {
25365 ecode3 = SWIG_AsVal_int(obj2, &val3);
25366 if (!SWIG_IsOK(ecode3)) {
25367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25368 }
25369 arg3 = static_cast< wxDateTime::Month >(val3);
25370 }
25371 if (obj3) {
25372 ecode4 = SWIG_AsVal_int(obj3, &val4);
25373 if (!SWIG_IsOK(ecode4)) {
25374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25375 }
25376 arg4 = static_cast< int >(val4);
25377 }
25378 {
25379 PyThreadState* __tstate = wxPyBeginAllowThreads();
25380 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25385 return resultobj;
25386 fail:
25387 return NULL;
25388 }
25389
25390
25391 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25392 PyObject *resultobj = 0;
25393 int arg1 ;
25394 int arg2 ;
25395 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25396 wxDateTime result;
25397 int val1 ;
25398 int ecode1 = 0 ;
25399 int val2 ;
25400 int ecode2 = 0 ;
25401 int val3 ;
25402 int ecode3 = 0 ;
25403 PyObject * obj0 = 0 ;
25404 PyObject * obj1 = 0 ;
25405 PyObject * obj2 = 0 ;
25406 char * kwnames[] = {
25407 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25408 };
25409
25410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25411 ecode1 = SWIG_AsVal_int(obj0, &val1);
25412 if (!SWIG_IsOK(ecode1)) {
25413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25414 }
25415 arg1 = static_cast< int >(val1);
25416 ecode2 = SWIG_AsVal_int(obj1, &val2);
25417 if (!SWIG_IsOK(ecode2)) {
25418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25419 }
25420 arg2 = static_cast< int >(val2);
25421 if (obj2) {
25422 ecode3 = SWIG_AsVal_int(obj2, &val3);
25423 if (!SWIG_IsOK(ecode3)) {
25424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25425 }
25426 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25427 }
25428 {
25429 PyThreadState* __tstate = wxPyBeginAllowThreads();
25430 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25431 wxPyEndAllowThreads(__tstate);
25432 if (PyErr_Occurred()) SWIG_fail;
25433 }
25434 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25442 PyObject *resultobj = 0;
25443 wxDateTime *arg1 = (wxDateTime *) 0 ;
25444 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25445 int arg3 = (int) wxDateTime::Inv_Year ;
25446 wxDateTime *result = 0 ;
25447 void *argp1 = 0 ;
25448 int res1 = 0 ;
25449 int val2 ;
25450 int ecode2 = 0 ;
25451 int val3 ;
25452 int ecode3 = 0 ;
25453 PyObject * obj0 = 0 ;
25454 PyObject * obj1 = 0 ;
25455 PyObject * obj2 = 0 ;
25456 char * kwnames[] = {
25457 (char *) "self",(char *) "month",(char *) "year", NULL
25458 };
25459
25460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25462 if (!SWIG_IsOK(res1)) {
25463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25464 }
25465 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25466 if (obj1) {
25467 ecode2 = SWIG_AsVal_int(obj1, &val2);
25468 if (!SWIG_IsOK(ecode2)) {
25469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25470 }
25471 arg2 = static_cast< wxDateTime::Month >(val2);
25472 }
25473 if (obj2) {
25474 ecode3 = SWIG_AsVal_int(obj2, &val3);
25475 if (!SWIG_IsOK(ecode3)) {
25476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25477 }
25478 arg3 = static_cast< int >(val3);
25479 }
25480 {
25481 PyThreadState* __tstate = wxPyBeginAllowThreads();
25482 {
25483 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25484 result = (wxDateTime *) &_result_ref;
25485 }
25486 wxPyEndAllowThreads(__tstate);
25487 if (PyErr_Occurred()) SWIG_fail;
25488 }
25489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25490 return resultobj;
25491 fail:
25492 return NULL;
25493 }
25494
25495
25496 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25497 PyObject *resultobj = 0;
25498 wxDateTime *arg1 = (wxDateTime *) 0 ;
25499 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25500 int arg3 = (int) wxDateTime::Inv_Year ;
25501 wxDateTime result;
25502 void *argp1 = 0 ;
25503 int res1 = 0 ;
25504 int val2 ;
25505 int ecode2 = 0 ;
25506 int val3 ;
25507 int ecode3 = 0 ;
25508 PyObject * obj0 = 0 ;
25509 PyObject * obj1 = 0 ;
25510 PyObject * obj2 = 0 ;
25511 char * kwnames[] = {
25512 (char *) "self",(char *) "month",(char *) "year", NULL
25513 };
25514
25515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25517 if (!SWIG_IsOK(res1)) {
25518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25519 }
25520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25521 if (obj1) {
25522 ecode2 = SWIG_AsVal_int(obj1, &val2);
25523 if (!SWIG_IsOK(ecode2)) {
25524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25525 }
25526 arg2 = static_cast< wxDateTime::Month >(val2);
25527 }
25528 if (obj2) {
25529 ecode3 = SWIG_AsVal_int(obj2, &val3);
25530 if (!SWIG_IsOK(ecode3)) {
25531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25532 }
25533 arg3 = static_cast< int >(val3);
25534 }
25535 {
25536 PyThreadState* __tstate = wxPyBeginAllowThreads();
25537 result = (arg1)->GetLastMonthDay(arg2,arg3);
25538 wxPyEndAllowThreads(__tstate);
25539 if (PyErr_Occurred()) SWIG_fail;
25540 }
25541 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25542 return resultobj;
25543 fail:
25544 return NULL;
25545 }
25546
25547
25548 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25549 PyObject *resultobj = 0;
25550 wxDateTime *arg1 = (wxDateTime *) 0 ;
25551 int arg2 ;
25552 wxDateTime *result = 0 ;
25553 void *argp1 = 0 ;
25554 int res1 = 0 ;
25555 int val2 ;
25556 int ecode2 = 0 ;
25557 PyObject * obj0 = 0 ;
25558 PyObject * obj1 = 0 ;
25559 char * kwnames[] = {
25560 (char *) "self",(char *) "yday", NULL
25561 };
25562
25563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25565 if (!SWIG_IsOK(res1)) {
25566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25567 }
25568 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25569 ecode2 = SWIG_AsVal_int(obj1, &val2);
25570 if (!SWIG_IsOK(ecode2)) {
25571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25572 }
25573 arg2 = static_cast< int >(val2);
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 {
25577 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25578 result = (wxDateTime *) &_result_ref;
25579 }
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj = 0;
25592 wxDateTime *arg1 = (wxDateTime *) 0 ;
25593 int arg2 ;
25594 wxDateTime result;
25595 void *argp1 = 0 ;
25596 int res1 = 0 ;
25597 int val2 ;
25598 int ecode2 = 0 ;
25599 PyObject * obj0 = 0 ;
25600 PyObject * obj1 = 0 ;
25601 char * kwnames[] = {
25602 (char *) "self",(char *) "yday", NULL
25603 };
25604
25605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25607 if (!SWIG_IsOK(res1)) {
25608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25609 }
25610 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25611 ecode2 = SWIG_AsVal_int(obj1, &val2);
25612 if (!SWIG_IsOK(ecode2)) {
25613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25614 }
25615 arg2 = static_cast< int >(val2);
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 result = (arg1)->GetYearDay(arg2);
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25623 return resultobj;
25624 fail:
25625 return NULL;
25626 }
25627
25628
25629 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25630 PyObject *resultobj = 0;
25631 wxDateTime *arg1 = (wxDateTime *) 0 ;
25632 double result;
25633 void *argp1 = 0 ;
25634 int res1 = 0 ;
25635 PyObject *swig_obj[1] ;
25636
25637 if (!args) SWIG_fail;
25638 swig_obj[0] = args;
25639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25640 if (!SWIG_IsOK(res1)) {
25641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25642 }
25643 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = (double)(arg1)->GetJulianDayNumber();
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 resultobj = SWIG_From_double(static_cast< double >(result));
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25658 PyObject *resultobj = 0;
25659 wxDateTime *arg1 = (wxDateTime *) 0 ;
25660 double result;
25661 void *argp1 = 0 ;
25662 int res1 = 0 ;
25663 PyObject *swig_obj[1] ;
25664
25665 if (!args) SWIG_fail;
25666 swig_obj[0] = args;
25667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25668 if (!SWIG_IsOK(res1)) {
25669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25670 }
25671 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (double)(arg1)->GetJDN();
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 resultobj = SWIG_From_double(static_cast< double >(result));
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 PyObject *resultobj = 0;
25687 wxDateTime *arg1 = (wxDateTime *) 0 ;
25688 double result;
25689 void *argp1 = 0 ;
25690 int res1 = 0 ;
25691 PyObject *swig_obj[1] ;
25692
25693 if (!args) SWIG_fail;
25694 swig_obj[0] = args;
25695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25696 if (!SWIG_IsOK(res1)) {
25697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25698 }
25699 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_From_double(static_cast< double >(result));
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25714 PyObject *resultobj = 0;
25715 wxDateTime *arg1 = (wxDateTime *) 0 ;
25716 double result;
25717 void *argp1 = 0 ;
25718 int res1 = 0 ;
25719 PyObject *swig_obj[1] ;
25720
25721 if (!args) SWIG_fail;
25722 swig_obj[0] = args;
25723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25724 if (!SWIG_IsOK(res1)) {
25725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25726 }
25727 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 result = (double)(arg1)->GetMJD();
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 resultobj = SWIG_From_double(static_cast< double >(result));
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25742 PyObject *resultobj = 0;
25743 wxDateTime *arg1 = (wxDateTime *) 0 ;
25744 double result;
25745 void *argp1 = 0 ;
25746 int res1 = 0 ;
25747 PyObject *swig_obj[1] ;
25748
25749 if (!args) SWIG_fail;
25750 swig_obj[0] = args;
25751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25754 }
25755 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 result = (double)(arg1)->GetRataDie();
25759 wxPyEndAllowThreads(__tstate);
25760 if (PyErr_Occurred()) SWIG_fail;
25761 }
25762 resultobj = SWIG_From_double(static_cast< double >(result));
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25770 PyObject *resultobj = 0;
25771 wxDateTime *arg1 = (wxDateTime *) 0 ;
25772 wxDateTime::TimeZone *arg2 = 0 ;
25773 bool arg3 = (bool) false ;
25774 wxDateTime result;
25775 void *argp1 = 0 ;
25776 int res1 = 0 ;
25777 bool temp2 = false ;
25778 bool val3 ;
25779 int ecode3 = 0 ;
25780 PyObject * obj0 = 0 ;
25781 PyObject * obj1 = 0 ;
25782 PyObject * obj2 = 0 ;
25783 char * kwnames[] = {
25784 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25785 };
25786
25787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25789 if (!SWIG_IsOK(res1)) {
25790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25791 }
25792 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25793 {
25794 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25795 temp2 = true;
25796 }
25797 if (obj2) {
25798 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25799 if (!SWIG_IsOK(ecode3)) {
25800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25801 }
25802 arg3 = static_cast< bool >(val3);
25803 }
25804 {
25805 PyThreadState* __tstate = wxPyBeginAllowThreads();
25806 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25807 wxPyEndAllowThreads(__tstate);
25808 if (PyErr_Occurred()) SWIG_fail;
25809 }
25810 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25811 {
25812 if (temp2) delete arg2;
25813 }
25814 return resultobj;
25815 fail:
25816 {
25817 if (temp2) delete arg2;
25818 }
25819 return NULL;
25820 }
25821
25822
25823 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25824 PyObject *resultobj = 0;
25825 wxDateTime *arg1 = (wxDateTime *) 0 ;
25826 wxDateTime::TimeZone *arg2 = 0 ;
25827 bool arg3 = (bool) false ;
25828 wxDateTime *result = 0 ;
25829 void *argp1 = 0 ;
25830 int res1 = 0 ;
25831 bool temp2 = false ;
25832 bool val3 ;
25833 int ecode3 = 0 ;
25834 PyObject * obj0 = 0 ;
25835 PyObject * obj1 = 0 ;
25836 PyObject * obj2 = 0 ;
25837 char * kwnames[] = {
25838 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25839 };
25840
25841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25843 if (!SWIG_IsOK(res1)) {
25844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25845 }
25846 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25847 {
25848 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25849 temp2 = true;
25850 }
25851 if (obj2) {
25852 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25853 if (!SWIG_IsOK(ecode3)) {
25854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25855 }
25856 arg3 = static_cast< bool >(val3);
25857 }
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 {
25861 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25862 result = (wxDateTime *) &_result_ref;
25863 }
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25868 {
25869 if (temp2) delete arg2;
25870 }
25871 return resultobj;
25872 fail:
25873 {
25874 if (temp2) delete arg2;
25875 }
25876 return NULL;
25877 }
25878
25879
25880 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25881 PyObject *resultobj = 0;
25882 wxDateTime *arg1 = (wxDateTime *) 0 ;
25883 wxDateTime::TimeZone *arg2 = 0 ;
25884 bool arg3 = (bool) false ;
25885 wxDateTime result;
25886 void *argp1 = 0 ;
25887 int res1 = 0 ;
25888 bool temp2 = false ;
25889 bool val3 ;
25890 int ecode3 = 0 ;
25891 PyObject * obj0 = 0 ;
25892 PyObject * obj1 = 0 ;
25893 PyObject * obj2 = 0 ;
25894 char * kwnames[] = {
25895 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25896 };
25897
25898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25900 if (!SWIG_IsOK(res1)) {
25901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25902 }
25903 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25904 {
25905 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25906 temp2 = true;
25907 }
25908 if (obj2) {
25909 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25910 if (!SWIG_IsOK(ecode3)) {
25911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25912 }
25913 arg3 = static_cast< bool >(val3);
25914 }
25915 {
25916 PyThreadState* __tstate = wxPyBeginAllowThreads();
25917 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25918 wxPyEndAllowThreads(__tstate);
25919 if (PyErr_Occurred()) SWIG_fail;
25920 }
25921 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25922 {
25923 if (temp2) delete arg2;
25924 }
25925 return resultobj;
25926 fail:
25927 {
25928 if (temp2) delete arg2;
25929 }
25930 return NULL;
25931 }
25932
25933
25934 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25935 PyObject *resultobj = 0;
25936 wxDateTime *arg1 = (wxDateTime *) 0 ;
25937 wxDateTime::TimeZone *arg2 = 0 ;
25938 bool arg3 = (bool) false ;
25939 wxDateTime *result = 0 ;
25940 void *argp1 = 0 ;
25941 int res1 = 0 ;
25942 bool temp2 = false ;
25943 bool val3 ;
25944 int ecode3 = 0 ;
25945 PyObject * obj0 = 0 ;
25946 PyObject * obj1 = 0 ;
25947 PyObject * obj2 = 0 ;
25948 char * kwnames[] = {
25949 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25950 };
25951
25952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25954 if (!SWIG_IsOK(res1)) {
25955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25956 }
25957 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25958 {
25959 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25960 temp2 = true;
25961 }
25962 if (obj2) {
25963 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25964 if (!SWIG_IsOK(ecode3)) {
25965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25966 }
25967 arg3 = static_cast< bool >(val3);
25968 }
25969 {
25970 PyThreadState* __tstate = wxPyBeginAllowThreads();
25971 {
25972 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25973 result = (wxDateTime *) &_result_ref;
25974 }
25975 wxPyEndAllowThreads(__tstate);
25976 if (PyErr_Occurred()) SWIG_fail;
25977 }
25978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25979 {
25980 if (temp2) delete arg2;
25981 }
25982 return resultobj;
25983 fail:
25984 {
25985 if (temp2) delete arg2;
25986 }
25987 return NULL;
25988 }
25989
25990
25991 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25992 PyObject *resultobj = 0;
25993 wxDateTime *arg1 = (wxDateTime *) 0 ;
25994 bool arg2 = (bool) false ;
25995 wxDateTime result;
25996 void *argp1 = 0 ;
25997 int res1 = 0 ;
25998 bool val2 ;
25999 int ecode2 = 0 ;
26000 PyObject * obj0 = 0 ;
26001 PyObject * obj1 = 0 ;
26002 char * kwnames[] = {
26003 (char *) "self",(char *) "noDST", NULL
26004 };
26005
26006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26008 if (!SWIG_IsOK(res1)) {
26009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26010 }
26011 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26012 if (obj1) {
26013 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26014 if (!SWIG_IsOK(ecode2)) {
26015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
26016 }
26017 arg2 = static_cast< bool >(val2);
26018 }
26019 {
26020 PyThreadState* __tstate = wxPyBeginAllowThreads();
26021 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
26022 wxPyEndAllowThreads(__tstate);
26023 if (PyErr_Occurred()) SWIG_fail;
26024 }
26025 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26026 return resultobj;
26027 fail:
26028 return NULL;
26029 }
26030
26031
26032 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26033 PyObject *resultobj = 0;
26034 wxDateTime *arg1 = (wxDateTime *) 0 ;
26035 bool arg2 = (bool) false ;
26036 wxDateTime *result = 0 ;
26037 void *argp1 = 0 ;
26038 int res1 = 0 ;
26039 bool val2 ;
26040 int ecode2 = 0 ;
26041 PyObject * obj0 = 0 ;
26042 PyObject * obj1 = 0 ;
26043 char * kwnames[] = {
26044 (char *) "self",(char *) "noDST", NULL
26045 };
26046
26047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26049 if (!SWIG_IsOK(res1)) {
26050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26051 }
26052 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26053 if (obj1) {
26054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26055 if (!SWIG_IsOK(ecode2)) {
26056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26057 }
26058 arg2 = static_cast< bool >(val2);
26059 }
26060 {
26061 PyThreadState* __tstate = wxPyBeginAllowThreads();
26062 {
26063 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26064 result = (wxDateTime *) &_result_ref;
26065 }
26066 wxPyEndAllowThreads(__tstate);
26067 if (PyErr_Occurred()) SWIG_fail;
26068 }
26069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26070 return resultobj;
26071 fail:
26072 return NULL;
26073 }
26074
26075
26076 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26077 PyObject *resultobj = 0;
26078 wxDateTime *arg1 = (wxDateTime *) 0 ;
26079 bool arg2 = (bool) false ;
26080 wxDateTime result;
26081 void *argp1 = 0 ;
26082 int res1 = 0 ;
26083 bool val2 ;
26084 int ecode2 = 0 ;
26085 PyObject * obj0 = 0 ;
26086 PyObject * obj1 = 0 ;
26087 char * kwnames[] = {
26088 (char *) "self",(char *) "noDST", NULL
26089 };
26090
26091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26093 if (!SWIG_IsOK(res1)) {
26094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26095 }
26096 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26097 if (obj1) {
26098 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26099 if (!SWIG_IsOK(ecode2)) {
26100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26101 }
26102 arg2 = static_cast< bool >(val2);
26103 }
26104 {
26105 PyThreadState* __tstate = wxPyBeginAllowThreads();
26106 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26111 return resultobj;
26112 fail:
26113 return NULL;
26114 }
26115
26116
26117 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26118 PyObject *resultobj = 0;
26119 wxDateTime *arg1 = (wxDateTime *) 0 ;
26120 bool arg2 = (bool) false ;
26121 wxDateTime *result = 0 ;
26122 void *argp1 = 0 ;
26123 int res1 = 0 ;
26124 bool val2 ;
26125 int ecode2 = 0 ;
26126 PyObject * obj0 = 0 ;
26127 PyObject * obj1 = 0 ;
26128 char * kwnames[] = {
26129 (char *) "self",(char *) "noDST", NULL
26130 };
26131
26132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26134 if (!SWIG_IsOK(res1)) {
26135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26136 }
26137 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26138 if (obj1) {
26139 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26140 if (!SWIG_IsOK(ecode2)) {
26141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26142 }
26143 arg2 = static_cast< bool >(val2);
26144 }
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 {
26148 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26149 result = (wxDateTime *) &_result_ref;
26150 }
26151 wxPyEndAllowThreads(__tstate);
26152 if (PyErr_Occurred()) SWIG_fail;
26153 }
26154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26155 return resultobj;
26156 fail:
26157 return NULL;
26158 }
26159
26160
26161 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26162 PyObject *resultobj = 0;
26163 wxDateTime *arg1 = (wxDateTime *) 0 ;
26164 bool arg2 = (bool) false ;
26165 wxDateTime result;
26166 void *argp1 = 0 ;
26167 int res1 = 0 ;
26168 bool val2 ;
26169 int ecode2 = 0 ;
26170 PyObject * obj0 = 0 ;
26171 PyObject * obj1 = 0 ;
26172 char * kwnames[] = {
26173 (char *) "self",(char *) "noDST", NULL
26174 };
26175
26176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26178 if (!SWIG_IsOK(res1)) {
26179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26180 }
26181 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26182 if (obj1) {
26183 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26184 if (!SWIG_IsOK(ecode2)) {
26185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26186 }
26187 arg2 = static_cast< bool >(val2);
26188 }
26189 {
26190 PyThreadState* __tstate = wxPyBeginAllowThreads();
26191 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26192 wxPyEndAllowThreads(__tstate);
26193 if (PyErr_Occurred()) SWIG_fail;
26194 }
26195 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26196 return resultobj;
26197 fail:
26198 return NULL;
26199 }
26200
26201
26202 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26203 PyObject *resultobj = 0;
26204 wxDateTime *arg1 = (wxDateTime *) 0 ;
26205 bool arg2 = (bool) false ;
26206 wxDateTime *result = 0 ;
26207 void *argp1 = 0 ;
26208 int res1 = 0 ;
26209 bool val2 ;
26210 int ecode2 = 0 ;
26211 PyObject * obj0 = 0 ;
26212 PyObject * obj1 = 0 ;
26213 char * kwnames[] = {
26214 (char *) "self",(char *) "noDST", NULL
26215 };
26216
26217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26219 if (!SWIG_IsOK(res1)) {
26220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26221 }
26222 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26223 if (obj1) {
26224 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26225 if (!SWIG_IsOK(ecode2)) {
26226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26227 }
26228 arg2 = static_cast< bool >(val2);
26229 }
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 {
26233 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26234 result = (wxDateTime *) &_result_ref;
26235 }
26236 wxPyEndAllowThreads(__tstate);
26237 if (PyErr_Occurred()) SWIG_fail;
26238 }
26239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26240 return resultobj;
26241 fail:
26242 return NULL;
26243 }
26244
26245
26246 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26247 PyObject *resultobj = 0;
26248 wxDateTime *arg1 = (wxDateTime *) 0 ;
26249 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26250 int result;
26251 void *argp1 = 0 ;
26252 int res1 = 0 ;
26253 int val2 ;
26254 int ecode2 = 0 ;
26255 PyObject * obj0 = 0 ;
26256 PyObject * obj1 = 0 ;
26257 char * kwnames[] = {
26258 (char *) "self",(char *) "country", NULL
26259 };
26260
26261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26263 if (!SWIG_IsOK(res1)) {
26264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26265 }
26266 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26267 if (obj1) {
26268 ecode2 = SWIG_AsVal_int(obj1, &val2);
26269 if (!SWIG_IsOK(ecode2)) {
26270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26271 }
26272 arg2 = static_cast< wxDateTime::Country >(val2);
26273 }
26274 {
26275 PyThreadState* __tstate = wxPyBeginAllowThreads();
26276 result = (int)(arg1)->IsDST(arg2);
26277 wxPyEndAllowThreads(__tstate);
26278 if (PyErr_Occurred()) SWIG_fail;
26279 }
26280 resultobj = SWIG_From_int(static_cast< int >(result));
26281 return resultobj;
26282 fail:
26283 return NULL;
26284 }
26285
26286
26287 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26288 PyObject *resultobj = 0;
26289 wxDateTime *arg1 = (wxDateTime *) 0 ;
26290 bool result;
26291 void *argp1 = 0 ;
26292 int res1 = 0 ;
26293 PyObject *swig_obj[1] ;
26294
26295 if (!args) SWIG_fail;
26296 swig_obj[0] = args;
26297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26298 if (!SWIG_IsOK(res1)) {
26299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26300 }
26301 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26302 {
26303 PyThreadState* __tstate = wxPyBeginAllowThreads();
26304 result = (bool)((wxDateTime const *)arg1)->IsValid();
26305 wxPyEndAllowThreads(__tstate);
26306 if (PyErr_Occurred()) SWIG_fail;
26307 }
26308 {
26309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26310 }
26311 return resultobj;
26312 fail:
26313 return NULL;
26314 }
26315
26316
26317 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26318 PyObject *resultobj = 0;
26319 wxDateTime *arg1 = (wxDateTime *) 0 ;
26320 time_t result;
26321 void *argp1 = 0 ;
26322 int res1 = 0 ;
26323 PyObject *swig_obj[1] ;
26324
26325 if (!args) SWIG_fail;
26326 swig_obj[0] = args;
26327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26328 if (!SWIG_IsOK(res1)) {
26329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26330 }
26331 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26332 {
26333 PyThreadState* __tstate = wxPyBeginAllowThreads();
26334 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26335 wxPyEndAllowThreads(__tstate);
26336 if (PyErr_Occurred()) SWIG_fail;
26337 }
26338 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26339 return resultobj;
26340 fail:
26341 return NULL;
26342 }
26343
26344
26345 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26346 PyObject *resultobj = 0;
26347 wxDateTime *arg1 = (wxDateTime *) 0 ;
26348 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26349 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26350 int result;
26351 void *argp1 = 0 ;
26352 int res1 = 0 ;
26353 bool temp2 = false ;
26354 PyObject * obj0 = 0 ;
26355 PyObject * obj1 = 0 ;
26356 char * kwnames[] = {
26357 (char *) "self",(char *) "tz", NULL
26358 };
26359
26360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26362 if (!SWIG_IsOK(res1)) {
26363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26364 }
26365 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26366 if (obj1) {
26367 {
26368 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26369 temp2 = true;
26370 }
26371 }
26372 {
26373 PyThreadState* __tstate = wxPyBeginAllowThreads();
26374 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26375 wxPyEndAllowThreads(__tstate);
26376 if (PyErr_Occurred()) SWIG_fail;
26377 }
26378 resultobj = SWIG_From_int(static_cast< int >(result));
26379 {
26380 if (temp2) delete arg2;
26381 }
26382 return resultobj;
26383 fail:
26384 {
26385 if (temp2) delete arg2;
26386 }
26387 return NULL;
26388 }
26389
26390
26391 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26392 PyObject *resultobj = 0;
26393 wxDateTime *arg1 = (wxDateTime *) 0 ;
26394 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26395 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26396 wxDateTime::Month result;
26397 void *argp1 = 0 ;
26398 int res1 = 0 ;
26399 bool temp2 = false ;
26400 PyObject * obj0 = 0 ;
26401 PyObject * obj1 = 0 ;
26402 char * kwnames[] = {
26403 (char *) "self",(char *) "tz", NULL
26404 };
26405
26406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26408 if (!SWIG_IsOK(res1)) {
26409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26410 }
26411 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26412 if (obj1) {
26413 {
26414 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26415 temp2 = true;
26416 }
26417 }
26418 {
26419 PyThreadState* __tstate = wxPyBeginAllowThreads();
26420 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26421 wxPyEndAllowThreads(__tstate);
26422 if (PyErr_Occurred()) SWIG_fail;
26423 }
26424 resultobj = SWIG_From_int(static_cast< int >(result));
26425 {
26426 if (temp2) delete arg2;
26427 }
26428 return resultobj;
26429 fail:
26430 {
26431 if (temp2) delete arg2;
26432 }
26433 return NULL;
26434 }
26435
26436
26437 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26438 PyObject *resultobj = 0;
26439 wxDateTime *arg1 = (wxDateTime *) 0 ;
26440 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26441 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26442 int result;
26443 void *argp1 = 0 ;
26444 int res1 = 0 ;
26445 bool temp2 = false ;
26446 PyObject * obj0 = 0 ;
26447 PyObject * obj1 = 0 ;
26448 char * kwnames[] = {
26449 (char *) "self",(char *) "tz", NULL
26450 };
26451
26452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26454 if (!SWIG_IsOK(res1)) {
26455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26456 }
26457 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26458 if (obj1) {
26459 {
26460 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26461 temp2 = true;
26462 }
26463 }
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26467 wxPyEndAllowThreads(__tstate);
26468 if (PyErr_Occurred()) SWIG_fail;
26469 }
26470 resultobj = SWIG_From_int(static_cast< int >(result));
26471 {
26472 if (temp2) delete arg2;
26473 }
26474 return resultobj;
26475 fail:
26476 {
26477 if (temp2) delete arg2;
26478 }
26479 return NULL;
26480 }
26481
26482
26483 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = 0;
26485 wxDateTime *arg1 = (wxDateTime *) 0 ;
26486 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26487 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26488 wxDateTime::WeekDay result;
26489 void *argp1 = 0 ;
26490 int res1 = 0 ;
26491 bool temp2 = false ;
26492 PyObject * obj0 = 0 ;
26493 PyObject * obj1 = 0 ;
26494 char * kwnames[] = {
26495 (char *) "self",(char *) "tz", NULL
26496 };
26497
26498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26500 if (!SWIG_IsOK(res1)) {
26501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26502 }
26503 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26504 if (obj1) {
26505 {
26506 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26507 temp2 = true;
26508 }
26509 }
26510 {
26511 PyThreadState* __tstate = wxPyBeginAllowThreads();
26512 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26513 wxPyEndAllowThreads(__tstate);
26514 if (PyErr_Occurred()) SWIG_fail;
26515 }
26516 resultobj = SWIG_From_int(static_cast< int >(result));
26517 {
26518 if (temp2) delete arg2;
26519 }
26520 return resultobj;
26521 fail:
26522 {
26523 if (temp2) delete arg2;
26524 }
26525 return NULL;
26526 }
26527
26528
26529 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26530 PyObject *resultobj = 0;
26531 wxDateTime *arg1 = (wxDateTime *) 0 ;
26532 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26533 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26534 int result;
26535 void *argp1 = 0 ;
26536 int res1 = 0 ;
26537 bool temp2 = false ;
26538 PyObject * obj0 = 0 ;
26539 PyObject * obj1 = 0 ;
26540 char * kwnames[] = {
26541 (char *) "self",(char *) "tz", NULL
26542 };
26543
26544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26546 if (!SWIG_IsOK(res1)) {
26547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26548 }
26549 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26550 if (obj1) {
26551 {
26552 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26553 temp2 = true;
26554 }
26555 }
26556 {
26557 PyThreadState* __tstate = wxPyBeginAllowThreads();
26558 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26559 wxPyEndAllowThreads(__tstate);
26560 if (PyErr_Occurred()) SWIG_fail;
26561 }
26562 resultobj = SWIG_From_int(static_cast< int >(result));
26563 {
26564 if (temp2) delete arg2;
26565 }
26566 return resultobj;
26567 fail:
26568 {
26569 if (temp2) delete arg2;
26570 }
26571 return NULL;
26572 }
26573
26574
26575 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj = 0;
26577 wxDateTime *arg1 = (wxDateTime *) 0 ;
26578 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26579 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26580 int result;
26581 void *argp1 = 0 ;
26582 int res1 = 0 ;
26583 bool temp2 = false ;
26584 PyObject * obj0 = 0 ;
26585 PyObject * obj1 = 0 ;
26586 char * kwnames[] = {
26587 (char *) "self",(char *) "tz", NULL
26588 };
26589
26590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26592 if (!SWIG_IsOK(res1)) {
26593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26594 }
26595 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26596 if (obj1) {
26597 {
26598 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26599 temp2 = true;
26600 }
26601 }
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26605 wxPyEndAllowThreads(__tstate);
26606 if (PyErr_Occurred()) SWIG_fail;
26607 }
26608 resultobj = SWIG_From_int(static_cast< int >(result));
26609 {
26610 if (temp2) delete arg2;
26611 }
26612 return resultobj;
26613 fail:
26614 {
26615 if (temp2) delete arg2;
26616 }
26617 return NULL;
26618 }
26619
26620
26621 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26622 PyObject *resultobj = 0;
26623 wxDateTime *arg1 = (wxDateTime *) 0 ;
26624 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26625 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26626 int result;
26627 void *argp1 = 0 ;
26628 int res1 = 0 ;
26629 bool temp2 = false ;
26630 PyObject * obj0 = 0 ;
26631 PyObject * obj1 = 0 ;
26632 char * kwnames[] = {
26633 (char *) "self",(char *) "tz", NULL
26634 };
26635
26636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26638 if (!SWIG_IsOK(res1)) {
26639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26640 }
26641 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26642 if (obj1) {
26643 {
26644 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26645 temp2 = true;
26646 }
26647 }
26648 {
26649 PyThreadState* __tstate = wxPyBeginAllowThreads();
26650 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26651 wxPyEndAllowThreads(__tstate);
26652 if (PyErr_Occurred()) SWIG_fail;
26653 }
26654 resultobj = SWIG_From_int(static_cast< int >(result));
26655 {
26656 if (temp2) delete arg2;
26657 }
26658 return resultobj;
26659 fail:
26660 {
26661 if (temp2) delete arg2;
26662 }
26663 return NULL;
26664 }
26665
26666
26667 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26668 PyObject *resultobj = 0;
26669 wxDateTime *arg1 = (wxDateTime *) 0 ;
26670 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26671 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26672 int result;
26673 void *argp1 = 0 ;
26674 int res1 = 0 ;
26675 bool temp2 = false ;
26676 PyObject * obj0 = 0 ;
26677 PyObject * obj1 = 0 ;
26678 char * kwnames[] = {
26679 (char *) "self",(char *) "tz", NULL
26680 };
26681
26682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26684 if (!SWIG_IsOK(res1)) {
26685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26686 }
26687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26688 if (obj1) {
26689 {
26690 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26691 temp2 = true;
26692 }
26693 }
26694 {
26695 PyThreadState* __tstate = wxPyBeginAllowThreads();
26696 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26697 wxPyEndAllowThreads(__tstate);
26698 if (PyErr_Occurred()) SWIG_fail;
26699 }
26700 resultobj = SWIG_From_int(static_cast< int >(result));
26701 {
26702 if (temp2) delete arg2;
26703 }
26704 return resultobj;
26705 fail:
26706 {
26707 if (temp2) delete arg2;
26708 }
26709 return NULL;
26710 }
26711
26712
26713 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26714 PyObject *resultobj = 0;
26715 wxDateTime *arg1 = (wxDateTime *) 0 ;
26716 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26717 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26718 int result;
26719 void *argp1 = 0 ;
26720 int res1 = 0 ;
26721 bool temp2 = false ;
26722 PyObject * obj0 = 0 ;
26723 PyObject * obj1 = 0 ;
26724 char * kwnames[] = {
26725 (char *) "self",(char *) "tz", NULL
26726 };
26727
26728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26730 if (!SWIG_IsOK(res1)) {
26731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26732 }
26733 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26734 if (obj1) {
26735 {
26736 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26737 temp2 = true;
26738 }
26739 }
26740 {
26741 PyThreadState* __tstate = wxPyBeginAllowThreads();
26742 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 resultobj = SWIG_From_int(static_cast< int >(result));
26747 {
26748 if (temp2) delete arg2;
26749 }
26750 return resultobj;
26751 fail:
26752 {
26753 if (temp2) delete arg2;
26754 }
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26760 PyObject *resultobj = 0;
26761 wxDateTime *arg1 = (wxDateTime *) 0 ;
26762 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26763 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26764 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26765 int result;
26766 void *argp1 = 0 ;
26767 int res1 = 0 ;
26768 int val2 ;
26769 int ecode2 = 0 ;
26770 bool temp3 = false ;
26771 PyObject * obj0 = 0 ;
26772 PyObject * obj1 = 0 ;
26773 PyObject * obj2 = 0 ;
26774 char * kwnames[] = {
26775 (char *) "self",(char *) "flags",(char *) "tz", NULL
26776 };
26777
26778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26780 if (!SWIG_IsOK(res1)) {
26781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26782 }
26783 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26784 if (obj1) {
26785 ecode2 = SWIG_AsVal_int(obj1, &val2);
26786 if (!SWIG_IsOK(ecode2)) {
26787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26788 }
26789 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26790 }
26791 if (obj2) {
26792 {
26793 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26794 temp3 = true;
26795 }
26796 }
26797 {
26798 PyThreadState* __tstate = wxPyBeginAllowThreads();
26799 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26800 wxPyEndAllowThreads(__tstate);
26801 if (PyErr_Occurred()) SWIG_fail;
26802 }
26803 resultobj = SWIG_From_int(static_cast< int >(result));
26804 {
26805 if (temp3) delete arg3;
26806 }
26807 return resultobj;
26808 fail:
26809 {
26810 if (temp3) delete arg3;
26811 }
26812 return NULL;
26813 }
26814
26815
26816 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26817 PyObject *resultobj = 0;
26818 wxDateTime *arg1 = (wxDateTime *) 0 ;
26819 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26820 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26821 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26822 int result;
26823 void *argp1 = 0 ;
26824 int res1 = 0 ;
26825 int val2 ;
26826 int ecode2 = 0 ;
26827 bool temp3 = false ;
26828 PyObject * obj0 = 0 ;
26829 PyObject * obj1 = 0 ;
26830 PyObject * obj2 = 0 ;
26831 char * kwnames[] = {
26832 (char *) "self",(char *) "flags",(char *) "tz", NULL
26833 };
26834
26835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26837 if (!SWIG_IsOK(res1)) {
26838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26839 }
26840 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26841 if (obj1) {
26842 ecode2 = SWIG_AsVal_int(obj1, &val2);
26843 if (!SWIG_IsOK(ecode2)) {
26844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26845 }
26846 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26847 }
26848 if (obj2) {
26849 {
26850 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26851 temp3 = true;
26852 }
26853 }
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 resultobj = SWIG_From_int(static_cast< int >(result));
26861 {
26862 if (temp3) delete arg3;
26863 }
26864 return resultobj;
26865 fail:
26866 {
26867 if (temp3) delete arg3;
26868 }
26869 return NULL;
26870 }
26871
26872
26873 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26874 PyObject *resultobj = 0;
26875 wxDateTime *arg1 = (wxDateTime *) 0 ;
26876 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26877 bool result;
26878 void *argp1 = 0 ;
26879 int res1 = 0 ;
26880 int val2 ;
26881 int ecode2 = 0 ;
26882 PyObject * obj0 = 0 ;
26883 PyObject * obj1 = 0 ;
26884 char * kwnames[] = {
26885 (char *) "self",(char *) "country", NULL
26886 };
26887
26888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26890 if (!SWIG_IsOK(res1)) {
26891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26892 }
26893 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26894 if (obj1) {
26895 ecode2 = SWIG_AsVal_int(obj1, &val2);
26896 if (!SWIG_IsOK(ecode2)) {
26897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26898 }
26899 arg2 = static_cast< wxDateTime::Country >(val2);
26900 }
26901 {
26902 PyThreadState* __tstate = wxPyBeginAllowThreads();
26903 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26904 wxPyEndAllowThreads(__tstate);
26905 if (PyErr_Occurred()) SWIG_fail;
26906 }
26907 {
26908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26909 }
26910 return resultobj;
26911 fail:
26912 return NULL;
26913 }
26914
26915
26916 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26917 PyObject *resultobj = 0;
26918 wxDateTime *arg1 = (wxDateTime *) 0 ;
26919 wxDateTime *arg2 = 0 ;
26920 bool result;
26921 void *argp1 = 0 ;
26922 int res1 = 0 ;
26923 void *argp2 = 0 ;
26924 int res2 = 0 ;
26925 PyObject * obj0 = 0 ;
26926 PyObject * obj1 = 0 ;
26927 char * kwnames[] = {
26928 (char *) "self",(char *) "datetime", NULL
26929 };
26930
26931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26933 if (!SWIG_IsOK(res1)) {
26934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26935 }
26936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26937 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26938 if (!SWIG_IsOK(res2)) {
26939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26940 }
26941 if (!argp2) {
26942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26943 }
26944 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26945 {
26946 PyThreadState* __tstate = wxPyBeginAllowThreads();
26947 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26948 wxPyEndAllowThreads(__tstate);
26949 if (PyErr_Occurred()) SWIG_fail;
26950 }
26951 {
26952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26953 }
26954 return resultobj;
26955 fail:
26956 return NULL;
26957 }
26958
26959
26960 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26961 PyObject *resultobj = 0;
26962 wxDateTime *arg1 = (wxDateTime *) 0 ;
26963 wxDateTime *arg2 = 0 ;
26964 bool result;
26965 void *argp1 = 0 ;
26966 int res1 = 0 ;
26967 void *argp2 = 0 ;
26968 int res2 = 0 ;
26969 PyObject * obj0 = 0 ;
26970 PyObject * obj1 = 0 ;
26971 char * kwnames[] = {
26972 (char *) "self",(char *) "datetime", NULL
26973 };
26974
26975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26977 if (!SWIG_IsOK(res1)) {
26978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26979 }
26980 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26981 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26982 if (!SWIG_IsOK(res2)) {
26983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26984 }
26985 if (!argp2) {
26986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26987 }
26988 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 {
26996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26997 }
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27005 PyObject *resultobj = 0;
27006 wxDateTime *arg1 = (wxDateTime *) 0 ;
27007 wxDateTime *arg2 = 0 ;
27008 bool result;
27009 void *argp1 = 0 ;
27010 int res1 = 0 ;
27011 void *argp2 = 0 ;
27012 int res2 = 0 ;
27013 PyObject * obj0 = 0 ;
27014 PyObject * obj1 = 0 ;
27015 char * kwnames[] = {
27016 (char *) "self",(char *) "datetime", NULL
27017 };
27018
27019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
27020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27021 if (!SWIG_IsOK(res1)) {
27022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27023 }
27024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27025 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27026 if (!SWIG_IsOK(res2)) {
27027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27028 }
27029 if (!argp2) {
27030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27031 }
27032 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 {
27040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27041 }
27042 return resultobj;
27043 fail:
27044 return NULL;
27045 }
27046
27047
27048 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27049 PyObject *resultobj = 0;
27050 wxDateTime *arg1 = (wxDateTime *) 0 ;
27051 wxDateTime *arg2 = 0 ;
27052 wxDateTime *arg3 = 0 ;
27053 bool result;
27054 void *argp1 = 0 ;
27055 int res1 = 0 ;
27056 void *argp2 = 0 ;
27057 int res2 = 0 ;
27058 void *argp3 = 0 ;
27059 int res3 = 0 ;
27060 PyObject * obj0 = 0 ;
27061 PyObject * obj1 = 0 ;
27062 PyObject * obj2 = 0 ;
27063 char * kwnames[] = {
27064 (char *) "self",(char *) "t1",(char *) "t2", NULL
27065 };
27066
27067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27069 if (!SWIG_IsOK(res1)) {
27070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27071 }
27072 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27073 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27074 if (!SWIG_IsOK(res2)) {
27075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27076 }
27077 if (!argp2) {
27078 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27079 }
27080 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27081 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27082 if (!SWIG_IsOK(res3)) {
27083 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27084 }
27085 if (!argp3) {
27086 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27087 }
27088 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 {
27096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27097 }
27098 return resultobj;
27099 fail:
27100 return NULL;
27101 }
27102
27103
27104 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27105 PyObject *resultobj = 0;
27106 wxDateTime *arg1 = (wxDateTime *) 0 ;
27107 wxDateTime *arg2 = 0 ;
27108 wxDateTime *arg3 = 0 ;
27109 bool result;
27110 void *argp1 = 0 ;
27111 int res1 = 0 ;
27112 void *argp2 = 0 ;
27113 int res2 = 0 ;
27114 void *argp3 = 0 ;
27115 int res3 = 0 ;
27116 PyObject * obj0 = 0 ;
27117 PyObject * obj1 = 0 ;
27118 PyObject * obj2 = 0 ;
27119 char * kwnames[] = {
27120 (char *) "self",(char *) "t1",(char *) "t2", NULL
27121 };
27122
27123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27125 if (!SWIG_IsOK(res1)) {
27126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27127 }
27128 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27129 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27130 if (!SWIG_IsOK(res2)) {
27131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27132 }
27133 if (!argp2) {
27134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27135 }
27136 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27137 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27138 if (!SWIG_IsOK(res3)) {
27139 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27140 }
27141 if (!argp3) {
27142 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27143 }
27144 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 {
27152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27153 }
27154 return resultobj;
27155 fail:
27156 return NULL;
27157 }
27158
27159
27160 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27161 PyObject *resultobj = 0;
27162 wxDateTime *arg1 = (wxDateTime *) 0 ;
27163 wxDateTime *arg2 = 0 ;
27164 bool result;
27165 void *argp1 = 0 ;
27166 int res1 = 0 ;
27167 void *argp2 = 0 ;
27168 int res2 = 0 ;
27169 PyObject * obj0 = 0 ;
27170 PyObject * obj1 = 0 ;
27171 char * kwnames[] = {
27172 (char *) "self",(char *) "dt", NULL
27173 };
27174
27175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27177 if (!SWIG_IsOK(res1)) {
27178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27179 }
27180 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27181 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27182 if (!SWIG_IsOK(res2)) {
27183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27184 }
27185 if (!argp2) {
27186 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27187 }
27188 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27189 {
27190 PyThreadState* __tstate = wxPyBeginAllowThreads();
27191 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27192 wxPyEndAllowThreads(__tstate);
27193 if (PyErr_Occurred()) SWIG_fail;
27194 }
27195 {
27196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27197 }
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27205 PyObject *resultobj = 0;
27206 wxDateTime *arg1 = (wxDateTime *) 0 ;
27207 wxDateTime *arg2 = 0 ;
27208 bool result;
27209 void *argp1 = 0 ;
27210 int res1 = 0 ;
27211 void *argp2 = 0 ;
27212 int res2 = 0 ;
27213 PyObject * obj0 = 0 ;
27214 PyObject * obj1 = 0 ;
27215 char * kwnames[] = {
27216 (char *) "self",(char *) "dt", NULL
27217 };
27218
27219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27221 if (!SWIG_IsOK(res1)) {
27222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27223 }
27224 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27225 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27226 if (!SWIG_IsOK(res2)) {
27227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27228 }
27229 if (!argp2) {
27230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27231 }
27232 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27233 {
27234 PyThreadState* __tstate = wxPyBeginAllowThreads();
27235 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27236 wxPyEndAllowThreads(__tstate);
27237 if (PyErr_Occurred()) SWIG_fail;
27238 }
27239 {
27240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27241 }
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27249 PyObject *resultobj = 0;
27250 wxDateTime *arg1 = (wxDateTime *) 0 ;
27251 wxDateTime *arg2 = 0 ;
27252 wxTimeSpan *arg3 = 0 ;
27253 bool result;
27254 void *argp1 = 0 ;
27255 int res1 = 0 ;
27256 void *argp2 = 0 ;
27257 int res2 = 0 ;
27258 void *argp3 = 0 ;
27259 int res3 = 0 ;
27260 PyObject * obj0 = 0 ;
27261 PyObject * obj1 = 0 ;
27262 PyObject * obj2 = 0 ;
27263 char * kwnames[] = {
27264 (char *) "self",(char *) "dt",(char *) "ts", NULL
27265 };
27266
27267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27269 if (!SWIG_IsOK(res1)) {
27270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27271 }
27272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27273 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27274 if (!SWIG_IsOK(res2)) {
27275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27276 }
27277 if (!argp2) {
27278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27279 }
27280 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27281 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27282 if (!SWIG_IsOK(res3)) {
27283 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27284 }
27285 if (!argp3) {
27286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27287 }
27288 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27292 wxPyEndAllowThreads(__tstate);
27293 if (PyErr_Occurred()) SWIG_fail;
27294 }
27295 {
27296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27297 }
27298 return resultobj;
27299 fail:
27300 return NULL;
27301 }
27302
27303
27304 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27305 PyObject *resultobj = 0;
27306 wxDateTime *arg1 = (wxDateTime *) 0 ;
27307 wxTimeSpan *arg2 = 0 ;
27308 wxDateTime *result = 0 ;
27309 void *argp1 = 0 ;
27310 int res1 = 0 ;
27311 void *argp2 = 0 ;
27312 int res2 = 0 ;
27313 PyObject * obj0 = 0 ;
27314 PyObject * obj1 = 0 ;
27315 char * kwnames[] = {
27316 (char *) "self",(char *) "diff", NULL
27317 };
27318
27319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27321 if (!SWIG_IsOK(res1)) {
27322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27323 }
27324 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27326 if (!SWIG_IsOK(res2)) {
27327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27328 }
27329 if (!argp2) {
27330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27331 }
27332 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27333 {
27334 PyThreadState* __tstate = wxPyBeginAllowThreads();
27335 {
27336 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27337 result = (wxDateTime *) &_result_ref;
27338 }
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27350 PyObject *resultobj = 0;
27351 wxDateTime *arg1 = (wxDateTime *) 0 ;
27352 wxDateSpan *arg2 = 0 ;
27353 wxDateTime *result = 0 ;
27354 void *argp1 = 0 ;
27355 int res1 = 0 ;
27356 void *argp2 = 0 ;
27357 int res2 = 0 ;
27358 PyObject * obj0 = 0 ;
27359 PyObject * obj1 = 0 ;
27360 char * kwnames[] = {
27361 (char *) "self",(char *) "diff", NULL
27362 };
27363
27364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27366 if (!SWIG_IsOK(res1)) {
27367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27368 }
27369 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27370 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27371 if (!SWIG_IsOK(res2)) {
27372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27373 }
27374 if (!argp2) {
27375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27376 }
27377 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27378 {
27379 PyThreadState* __tstate = wxPyBeginAllowThreads();
27380 {
27381 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27382 result = (wxDateTime *) &_result_ref;
27383 }
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27395 PyObject *resultobj = 0;
27396 wxDateTime *arg1 = (wxDateTime *) 0 ;
27397 wxTimeSpan *arg2 = 0 ;
27398 wxDateTime *result = 0 ;
27399 void *argp1 = 0 ;
27400 int res1 = 0 ;
27401 void *argp2 = 0 ;
27402 int res2 = 0 ;
27403 PyObject * obj0 = 0 ;
27404 PyObject * obj1 = 0 ;
27405 char * kwnames[] = {
27406 (char *) "self",(char *) "diff", NULL
27407 };
27408
27409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27411 if (!SWIG_IsOK(res1)) {
27412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27413 }
27414 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27415 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27416 if (!SWIG_IsOK(res2)) {
27417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27418 }
27419 if (!argp2) {
27420 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27421 }
27422 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27423 {
27424 PyThreadState* __tstate = wxPyBeginAllowThreads();
27425 {
27426 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27427 result = (wxDateTime *) &_result_ref;
27428 }
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27433 return resultobj;
27434 fail:
27435 return NULL;
27436 }
27437
27438
27439 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27440 PyObject *resultobj = 0;
27441 wxDateTime *arg1 = (wxDateTime *) 0 ;
27442 wxDateSpan *arg2 = 0 ;
27443 wxDateTime *result = 0 ;
27444 void *argp1 = 0 ;
27445 int res1 = 0 ;
27446 void *argp2 = 0 ;
27447 int res2 = 0 ;
27448 PyObject * obj0 = 0 ;
27449 PyObject * obj1 = 0 ;
27450 char * kwnames[] = {
27451 (char *) "self",(char *) "diff", NULL
27452 };
27453
27454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27456 if (!SWIG_IsOK(res1)) {
27457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27458 }
27459 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27460 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27461 if (!SWIG_IsOK(res2)) {
27462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27463 }
27464 if (!argp2) {
27465 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27466 }
27467 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 {
27471 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27472 result = (wxDateTime *) &_result_ref;
27473 }
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27485 PyObject *resultobj = 0;
27486 wxDateTime *arg1 = (wxDateTime *) 0 ;
27487 wxDateTime *arg2 = 0 ;
27488 wxTimeSpan result;
27489 void *argp1 = 0 ;
27490 int res1 = 0 ;
27491 void *argp2 = 0 ;
27492 int res2 = 0 ;
27493 PyObject * obj0 = 0 ;
27494 PyObject * obj1 = 0 ;
27495 char * kwnames[] = {
27496 (char *) "self",(char *) "dt", NULL
27497 };
27498
27499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27501 if (!SWIG_IsOK(res1)) {
27502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27503 }
27504 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27505 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27506 if (!SWIG_IsOK(res2)) {
27507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27508 }
27509 if (!argp2) {
27510 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27511 }
27512 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27527 PyObject *resultobj = 0;
27528 wxDateTime *arg1 = (wxDateTime *) 0 ;
27529 wxTimeSpan *arg2 = 0 ;
27530 wxDateTime *result = 0 ;
27531 void *argp1 = 0 ;
27532 int res1 = 0 ;
27533 void *argp2 = 0 ;
27534 int res2 = 0 ;
27535
27536 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27538 if (!SWIG_IsOK(res1)) {
27539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27540 }
27541 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27542 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27543 if (!SWIG_IsOK(res2)) {
27544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27545 }
27546 if (!argp2) {
27547 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27548 }
27549 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27550 {
27551 PyThreadState* __tstate = wxPyBeginAllowThreads();
27552 {
27553 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27554 result = (wxDateTime *) &_result_ref;
27555 }
27556 wxPyEndAllowThreads(__tstate);
27557 if (PyErr_Occurred()) SWIG_fail;
27558 }
27559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27560 return resultobj;
27561 fail:
27562 return NULL;
27563 }
27564
27565
27566 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27567 PyObject *resultobj = 0;
27568 wxDateTime *arg1 = (wxDateTime *) 0 ;
27569 wxDateSpan *arg2 = 0 ;
27570 wxDateTime *result = 0 ;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 void *argp2 = 0 ;
27574 int res2 = 0 ;
27575
27576 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27580 }
27581 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27582 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27583 if (!SWIG_IsOK(res2)) {
27584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27585 }
27586 if (!argp2) {
27587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27588 }
27589 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 {
27593 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27594 result = (wxDateTime *) &_result_ref;
27595 }
27596 wxPyEndAllowThreads(__tstate);
27597 if (PyErr_Occurred()) SWIG_fail;
27598 }
27599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27600 return resultobj;
27601 fail:
27602 return NULL;
27603 }
27604
27605
27606 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27607 int argc;
27608 PyObject *argv[3];
27609
27610 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27611 --argc;
27612 if (argc == 2) {
27613 int _v = 0;
27614 {
27615 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27616 _v = SWIG_CheckState(res);
27617 }
27618 if (!_v) goto check_1;
27619 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27620 }
27621 check_1:
27622
27623 if (argc == 2) {
27624 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27625 }
27626
27627 fail:
27628 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27629 return NULL;
27630 }
27631
27632
27633 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27634 PyObject *resultobj = 0;
27635 wxDateTime *arg1 = (wxDateTime *) 0 ;
27636 wxTimeSpan *arg2 = 0 ;
27637 wxDateTime *result = 0 ;
27638 void *argp1 = 0 ;
27639 int res1 = 0 ;
27640 void *argp2 = 0 ;
27641 int res2 = 0 ;
27642
27643 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27645 if (!SWIG_IsOK(res1)) {
27646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27647 }
27648 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27649 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27650 if (!SWIG_IsOK(res2)) {
27651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27652 }
27653 if (!argp2) {
27654 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27655 }
27656 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27657 {
27658 PyThreadState* __tstate = wxPyBeginAllowThreads();
27659 {
27660 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27661 result = (wxDateTime *) &_result_ref;
27662 }
27663 wxPyEndAllowThreads(__tstate);
27664 if (PyErr_Occurred()) SWIG_fail;
27665 }
27666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27667 return resultobj;
27668 fail:
27669 return NULL;
27670 }
27671
27672
27673 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27674 PyObject *resultobj = 0;
27675 wxDateTime *arg1 = (wxDateTime *) 0 ;
27676 wxDateSpan *arg2 = 0 ;
27677 wxDateTime *result = 0 ;
27678 void *argp1 = 0 ;
27679 int res1 = 0 ;
27680 void *argp2 = 0 ;
27681 int res2 = 0 ;
27682
27683 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27685 if (!SWIG_IsOK(res1)) {
27686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27687 }
27688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27689 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27690 if (!SWIG_IsOK(res2)) {
27691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27692 }
27693 if (!argp2) {
27694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27695 }
27696 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 {
27700 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27701 result = (wxDateTime *) &_result_ref;
27702 }
27703 wxPyEndAllowThreads(__tstate);
27704 if (PyErr_Occurred()) SWIG_fail;
27705 }
27706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27707 return resultobj;
27708 fail:
27709 return NULL;
27710 }
27711
27712
27713 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27714 int argc;
27715 PyObject *argv[3];
27716
27717 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27718 --argc;
27719 if (argc == 2) {
27720 int _v = 0;
27721 {
27722 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27723 _v = SWIG_CheckState(res);
27724 }
27725 if (!_v) goto check_1;
27726 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27727 }
27728 check_1:
27729
27730 if (argc == 2) {
27731 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27732 }
27733
27734 fail:
27735 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27736 return NULL;
27737 }
27738
27739
27740 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27741 PyObject *resultobj = 0;
27742 wxDateTime *arg1 = (wxDateTime *) 0 ;
27743 wxTimeSpan *arg2 = 0 ;
27744 wxDateTime result;
27745 void *argp1 = 0 ;
27746 int res1 = 0 ;
27747 void *argp2 = 0 ;
27748 int res2 = 0 ;
27749
27750 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27752 if (!SWIG_IsOK(res1)) {
27753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27754 }
27755 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27756 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27757 if (!SWIG_IsOK(res2)) {
27758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27759 }
27760 if (!argp2) {
27761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27762 }
27763 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27764 {
27765 PyThreadState* __tstate = wxPyBeginAllowThreads();
27766 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27778 PyObject *resultobj = 0;
27779 wxDateTime *arg1 = (wxDateTime *) 0 ;
27780 wxDateSpan *arg2 = 0 ;
27781 wxDateTime result;
27782 void *argp1 = 0 ;
27783 int res1 = 0 ;
27784 void *argp2 = 0 ;
27785 int res2 = 0 ;
27786
27787 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27789 if (!SWIG_IsOK(res1)) {
27790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27791 }
27792 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27793 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27794 if (!SWIG_IsOK(res2)) {
27795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27796 }
27797 if (!argp2) {
27798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27799 }
27800 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27808 return resultobj;
27809 fail:
27810 return NULL;
27811 }
27812
27813
27814 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27815 int argc;
27816 PyObject *argv[3];
27817
27818 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27819 --argc;
27820 if (argc == 2) {
27821 int _v = 0;
27822 {
27823 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27824 _v = SWIG_CheckState(res);
27825 }
27826 if (!_v) goto check_1;
27827 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27828 }
27829 check_1:
27830
27831 if (argc == 2) {
27832 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27833 }
27834
27835 fail:
27836 Py_INCREF(Py_NotImplemented);
27837 return Py_NotImplemented;
27838 }
27839
27840
27841 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27842 PyObject *resultobj = 0;
27843 wxDateTime *arg1 = (wxDateTime *) 0 ;
27844 wxDateTime *arg2 = 0 ;
27845 wxTimeSpan result;
27846 void *argp1 = 0 ;
27847 int res1 = 0 ;
27848 void *argp2 = 0 ;
27849 int res2 = 0 ;
27850
27851 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27853 if (!SWIG_IsOK(res1)) {
27854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27855 }
27856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27857 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27858 if (!SWIG_IsOK(res2)) {
27859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27860 }
27861 if (!argp2) {
27862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27863 }
27864 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27865 {
27866 PyThreadState* __tstate = wxPyBeginAllowThreads();
27867 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27872 return resultobj;
27873 fail:
27874 return NULL;
27875 }
27876
27877
27878 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27879 PyObject *resultobj = 0;
27880 wxDateTime *arg1 = (wxDateTime *) 0 ;
27881 wxTimeSpan *arg2 = 0 ;
27882 wxDateTime result;
27883 void *argp1 = 0 ;
27884 int res1 = 0 ;
27885 void *argp2 = 0 ;
27886 int res2 = 0 ;
27887
27888 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27890 if (!SWIG_IsOK(res1)) {
27891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27892 }
27893 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27894 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27895 if (!SWIG_IsOK(res2)) {
27896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27897 }
27898 if (!argp2) {
27899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27900 }
27901 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27902 {
27903 PyThreadState* __tstate = wxPyBeginAllowThreads();
27904 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27916 PyObject *resultobj = 0;
27917 wxDateTime *arg1 = (wxDateTime *) 0 ;
27918 wxDateSpan *arg2 = 0 ;
27919 wxDateTime result;
27920 void *argp1 = 0 ;
27921 int res1 = 0 ;
27922 void *argp2 = 0 ;
27923 int res2 = 0 ;
27924
27925 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27927 if (!SWIG_IsOK(res1)) {
27928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27929 }
27930 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27931 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27932 if (!SWIG_IsOK(res2)) {
27933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27934 }
27935 if (!argp2) {
27936 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27937 }
27938 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27939 {
27940 PyThreadState* __tstate = wxPyBeginAllowThreads();
27941 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27942 wxPyEndAllowThreads(__tstate);
27943 if (PyErr_Occurred()) SWIG_fail;
27944 }
27945 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27946 return resultobj;
27947 fail:
27948 return NULL;
27949 }
27950
27951
27952 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27953 int argc;
27954 PyObject *argv[3];
27955
27956 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27957 --argc;
27958 if (argc == 2) {
27959 int _v = 0;
27960 {
27961 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27962 _v = SWIG_CheckState(res);
27963 }
27964 if (!_v) goto check_1;
27965 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27966 }
27967 check_1:
27968
27969 if (argc == 2) {
27970 int _v = 0;
27971 {
27972 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27973 _v = SWIG_CheckState(res);
27974 }
27975 if (!_v) goto check_2;
27976 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27977 }
27978 check_2:
27979
27980 if (argc == 2) {
27981 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27982 }
27983
27984 fail:
27985 Py_INCREF(Py_NotImplemented);
27986 return Py_NotImplemented;
27987 }
27988
27989
27990 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27991 PyObject *resultobj = 0;
27992 wxDateTime *arg1 = (wxDateTime *) 0 ;
27993 wxDateTime *arg2 = (wxDateTime *) 0 ;
27994 bool result;
27995 void *argp1 = 0 ;
27996 int res1 = 0 ;
27997 void *argp2 = 0 ;
27998 int res2 = 0 ;
27999 PyObject * obj0 = 0 ;
28000 PyObject * obj1 = 0 ;
28001 char * kwnames[] = {
28002 (char *) "self",(char *) "other", NULL
28003 };
28004
28005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28007 if (!SWIG_IsOK(res1)) {
28008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28009 }
28010 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28011 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28012 if (!SWIG_IsOK(res2)) {
28013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28014 }
28015 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28016 {
28017 PyThreadState* __tstate = wxPyBeginAllowThreads();
28018 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
28019 wxPyEndAllowThreads(__tstate);
28020 if (PyErr_Occurred()) SWIG_fail;
28021 }
28022 {
28023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28024 }
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj = 0;
28033 wxDateTime *arg1 = (wxDateTime *) 0 ;
28034 wxDateTime *arg2 = (wxDateTime *) 0 ;
28035 bool result;
28036 void *argp1 = 0 ;
28037 int res1 = 0 ;
28038 void *argp2 = 0 ;
28039 int res2 = 0 ;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 char * kwnames[] = {
28043 (char *) "self",(char *) "other", NULL
28044 };
28045
28046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28048 if (!SWIG_IsOK(res1)) {
28049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28050 }
28051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28053 if (!SWIG_IsOK(res2)) {
28054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28055 }
28056 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28057 {
28058 PyThreadState* __tstate = wxPyBeginAllowThreads();
28059 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 {
28064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28065 }
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28073 PyObject *resultobj = 0;
28074 wxDateTime *arg1 = (wxDateTime *) 0 ;
28075 wxDateTime *arg2 = (wxDateTime *) 0 ;
28076 bool result;
28077 void *argp1 = 0 ;
28078 int res1 = 0 ;
28079 void *argp2 = 0 ;
28080 int res2 = 0 ;
28081 PyObject * obj0 = 0 ;
28082 PyObject * obj1 = 0 ;
28083 char * kwnames[] = {
28084 (char *) "self",(char *) "other", NULL
28085 };
28086
28087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28089 if (!SWIG_IsOK(res1)) {
28090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28091 }
28092 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28093 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28094 if (!SWIG_IsOK(res2)) {
28095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28096 }
28097 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28098 {
28099 PyThreadState* __tstate = wxPyBeginAllowThreads();
28100 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28101 wxPyEndAllowThreads(__tstate);
28102 if (PyErr_Occurred()) SWIG_fail;
28103 }
28104 {
28105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28106 }
28107 return resultobj;
28108 fail:
28109 return NULL;
28110 }
28111
28112
28113 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28114 PyObject *resultobj = 0;
28115 wxDateTime *arg1 = (wxDateTime *) 0 ;
28116 wxDateTime *arg2 = (wxDateTime *) 0 ;
28117 bool result;
28118 void *argp1 = 0 ;
28119 int res1 = 0 ;
28120 void *argp2 = 0 ;
28121 int res2 = 0 ;
28122 PyObject * obj0 = 0 ;
28123 PyObject * obj1 = 0 ;
28124 char * kwnames[] = {
28125 (char *) "self",(char *) "other", NULL
28126 };
28127
28128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28130 if (!SWIG_IsOK(res1)) {
28131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28132 }
28133 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28134 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28135 if (!SWIG_IsOK(res2)) {
28136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28137 }
28138 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28139 {
28140 PyThreadState* __tstate = wxPyBeginAllowThreads();
28141 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28142 wxPyEndAllowThreads(__tstate);
28143 if (PyErr_Occurred()) SWIG_fail;
28144 }
28145 {
28146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28147 }
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28155 PyObject *resultobj = 0;
28156 wxDateTime *arg1 = (wxDateTime *) 0 ;
28157 wxDateTime *arg2 = (wxDateTime *) 0 ;
28158 bool result;
28159 void *argp1 = 0 ;
28160 int res1 = 0 ;
28161 void *argp2 = 0 ;
28162 int res2 = 0 ;
28163 PyObject * obj0 = 0 ;
28164 PyObject * obj1 = 0 ;
28165 char * kwnames[] = {
28166 (char *) "self",(char *) "other", NULL
28167 };
28168
28169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28171 if (!SWIG_IsOK(res1)) {
28172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28173 }
28174 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28176 if (!SWIG_IsOK(res2)) {
28177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28178 }
28179 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28183 wxPyEndAllowThreads(__tstate);
28184 if (PyErr_Occurred()) SWIG_fail;
28185 }
28186 {
28187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28188 }
28189 return resultobj;
28190 fail:
28191 return NULL;
28192 }
28193
28194
28195 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28196 PyObject *resultobj = 0;
28197 wxDateTime *arg1 = (wxDateTime *) 0 ;
28198 wxDateTime *arg2 = (wxDateTime *) 0 ;
28199 bool result;
28200 void *argp1 = 0 ;
28201 int res1 = 0 ;
28202 void *argp2 = 0 ;
28203 int res2 = 0 ;
28204 PyObject * obj0 = 0 ;
28205 PyObject * obj1 = 0 ;
28206 char * kwnames[] = {
28207 (char *) "self",(char *) "other", NULL
28208 };
28209
28210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28212 if (!SWIG_IsOK(res1)) {
28213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28214 }
28215 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28217 if (!SWIG_IsOK(res2)) {
28218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28219 }
28220 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28221 {
28222 PyThreadState* __tstate = wxPyBeginAllowThreads();
28223 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28224 wxPyEndAllowThreads(__tstate);
28225 if (PyErr_Occurred()) SWIG_fail;
28226 }
28227 {
28228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28229 }
28230 return resultobj;
28231 fail:
28232 return NULL;
28233 }
28234
28235
28236 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28237 PyObject *resultobj = 0;
28238 wxDateTime *arg1 = (wxDateTime *) 0 ;
28239 wxString *arg2 = 0 ;
28240 int result;
28241 void *argp1 = 0 ;
28242 int res1 = 0 ;
28243 bool temp2 = false ;
28244 PyObject * obj0 = 0 ;
28245 PyObject * obj1 = 0 ;
28246 char * kwnames[] = {
28247 (char *) "self",(char *) "date", NULL
28248 };
28249
28250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28252 if (!SWIG_IsOK(res1)) {
28253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28254 }
28255 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28256 {
28257 arg2 = wxString_in_helper(obj1);
28258 if (arg2 == NULL) SWIG_fail;
28259 temp2 = true;
28260 }
28261 {
28262 PyThreadState* __tstate = wxPyBeginAllowThreads();
28263 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28264 wxPyEndAllowThreads(__tstate);
28265 if (PyErr_Occurred()) SWIG_fail;
28266 }
28267 resultobj = SWIG_From_int(static_cast< int >(result));
28268 {
28269 if (temp2)
28270 delete arg2;
28271 }
28272 return resultobj;
28273 fail:
28274 {
28275 if (temp2)
28276 delete arg2;
28277 }
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 wxDateTime *arg1 = (wxDateTime *) 0 ;
28285 wxString *arg2 = 0 ;
28286 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28287 wxString *arg3 = (wxString *) &arg3_defvalue ;
28288 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28289 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28290 int result;
28291 void *argp1 = 0 ;
28292 int res1 = 0 ;
28293 bool temp2 = false ;
28294 bool temp3 = false ;
28295 void *argp4 = 0 ;
28296 int res4 = 0 ;
28297 PyObject * obj0 = 0 ;
28298 PyObject * obj1 = 0 ;
28299 PyObject * obj2 = 0 ;
28300 PyObject * obj3 = 0 ;
28301 char * kwnames[] = {
28302 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28303 };
28304
28305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28307 if (!SWIG_IsOK(res1)) {
28308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28309 }
28310 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28311 {
28312 arg2 = wxString_in_helper(obj1);
28313 if (arg2 == NULL) SWIG_fail;
28314 temp2 = true;
28315 }
28316 if (obj2) {
28317 {
28318 arg3 = wxString_in_helper(obj2);
28319 if (arg3 == NULL) SWIG_fail;
28320 temp3 = true;
28321 }
28322 }
28323 if (obj3) {
28324 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28325 if (!SWIG_IsOK(res4)) {
28326 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28327 }
28328 if (!argp4) {
28329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28330 }
28331 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28332 }
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28336 wxPyEndAllowThreads(__tstate);
28337 if (PyErr_Occurred()) SWIG_fail;
28338 }
28339 resultobj = SWIG_From_int(static_cast< int >(result));
28340 {
28341 if (temp2)
28342 delete arg2;
28343 }
28344 {
28345 if (temp3)
28346 delete arg3;
28347 }
28348 return resultobj;
28349 fail:
28350 {
28351 if (temp2)
28352 delete arg2;
28353 }
28354 {
28355 if (temp3)
28356 delete arg3;
28357 }
28358 return NULL;
28359 }
28360
28361
28362 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28363 PyObject *resultobj = 0;
28364 wxDateTime *arg1 = (wxDateTime *) 0 ;
28365 wxString *arg2 = 0 ;
28366 int result;
28367 void *argp1 = 0 ;
28368 int res1 = 0 ;
28369 bool temp2 = false ;
28370 PyObject * obj0 = 0 ;
28371 PyObject * obj1 = 0 ;
28372 char * kwnames[] = {
28373 (char *) "self",(char *) "datetime", NULL
28374 };
28375
28376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28378 if (!SWIG_IsOK(res1)) {
28379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28380 }
28381 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28382 {
28383 arg2 = wxString_in_helper(obj1);
28384 if (arg2 == NULL) SWIG_fail;
28385 temp2 = true;
28386 }
28387 {
28388 PyThreadState* __tstate = wxPyBeginAllowThreads();
28389 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 resultobj = SWIG_From_int(static_cast< int >(result));
28394 {
28395 if (temp2)
28396 delete arg2;
28397 }
28398 return resultobj;
28399 fail:
28400 {
28401 if (temp2)
28402 delete arg2;
28403 }
28404 return NULL;
28405 }
28406
28407
28408 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28409 PyObject *resultobj = 0;
28410 wxDateTime *arg1 = (wxDateTime *) 0 ;
28411 wxString *arg2 = 0 ;
28412 int result;
28413 void *argp1 = 0 ;
28414 int res1 = 0 ;
28415 bool temp2 = false ;
28416 PyObject * obj0 = 0 ;
28417 PyObject * obj1 = 0 ;
28418 char * kwnames[] = {
28419 (char *) "self",(char *) "date", NULL
28420 };
28421
28422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28424 if (!SWIG_IsOK(res1)) {
28425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28426 }
28427 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28428 {
28429 arg2 = wxString_in_helper(obj1);
28430 if (arg2 == NULL) SWIG_fail;
28431 temp2 = true;
28432 }
28433 {
28434 PyThreadState* __tstate = wxPyBeginAllowThreads();
28435 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 resultobj = SWIG_From_int(static_cast< int >(result));
28440 {
28441 if (temp2)
28442 delete arg2;
28443 }
28444 return resultobj;
28445 fail:
28446 {
28447 if (temp2)
28448 delete arg2;
28449 }
28450 return NULL;
28451 }
28452
28453
28454 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28455 PyObject *resultobj = 0;
28456 wxDateTime *arg1 = (wxDateTime *) 0 ;
28457 wxString *arg2 = 0 ;
28458 int result;
28459 void *argp1 = 0 ;
28460 int res1 = 0 ;
28461 bool temp2 = false ;
28462 PyObject * obj0 = 0 ;
28463 PyObject * obj1 = 0 ;
28464 char * kwnames[] = {
28465 (char *) "self",(char *) "time", NULL
28466 };
28467
28468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28470 if (!SWIG_IsOK(res1)) {
28471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28472 }
28473 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28474 {
28475 arg2 = wxString_in_helper(obj1);
28476 if (arg2 == NULL) SWIG_fail;
28477 temp2 = true;
28478 }
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_From_int(static_cast< int >(result));
28486 {
28487 if (temp2)
28488 delete arg2;
28489 }
28490 return resultobj;
28491 fail:
28492 {
28493 if (temp2)
28494 delete arg2;
28495 }
28496 return NULL;
28497 }
28498
28499
28500 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28501 PyObject *resultobj = 0;
28502 wxDateTime *arg1 = (wxDateTime *) 0 ;
28503 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28504 wxString *arg2 = (wxString *) &arg2_defvalue ;
28505 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28506 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28507 wxString result;
28508 void *argp1 = 0 ;
28509 int res1 = 0 ;
28510 bool temp2 = false ;
28511 bool temp3 = false ;
28512 PyObject * obj0 = 0 ;
28513 PyObject * obj1 = 0 ;
28514 PyObject * obj2 = 0 ;
28515 char * kwnames[] = {
28516 (char *) "self",(char *) "format",(char *) "tz", NULL
28517 };
28518
28519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28521 if (!SWIG_IsOK(res1)) {
28522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28523 }
28524 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28525 if (obj1) {
28526 {
28527 arg2 = wxString_in_helper(obj1);
28528 if (arg2 == NULL) SWIG_fail;
28529 temp2 = true;
28530 }
28531 }
28532 if (obj2) {
28533 {
28534 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28535 temp3 = true;
28536 }
28537 }
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 {
28545 #if wxUSE_UNICODE
28546 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28547 #else
28548 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28549 #endif
28550 }
28551 {
28552 if (temp2)
28553 delete arg2;
28554 }
28555 {
28556 if (temp3) delete arg3;
28557 }
28558 return resultobj;
28559 fail:
28560 {
28561 if (temp2)
28562 delete arg2;
28563 }
28564 {
28565 if (temp3) delete arg3;
28566 }
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28572 PyObject *resultobj = 0;
28573 wxDateTime *arg1 = (wxDateTime *) 0 ;
28574 wxString result;
28575 void *argp1 = 0 ;
28576 int res1 = 0 ;
28577 PyObject *swig_obj[1] ;
28578
28579 if (!args) SWIG_fail;
28580 swig_obj[0] = args;
28581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28582 if (!SWIG_IsOK(res1)) {
28583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28584 }
28585 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28586 {
28587 PyThreadState* __tstate = wxPyBeginAllowThreads();
28588 result = ((wxDateTime const *)arg1)->FormatDate();
28589 wxPyEndAllowThreads(__tstate);
28590 if (PyErr_Occurred()) SWIG_fail;
28591 }
28592 {
28593 #if wxUSE_UNICODE
28594 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28595 #else
28596 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28597 #endif
28598 }
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28606 PyObject *resultobj = 0;
28607 wxDateTime *arg1 = (wxDateTime *) 0 ;
28608 wxString result;
28609 void *argp1 = 0 ;
28610 int res1 = 0 ;
28611 PyObject *swig_obj[1] ;
28612
28613 if (!args) SWIG_fail;
28614 swig_obj[0] = args;
28615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28616 if (!SWIG_IsOK(res1)) {
28617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28618 }
28619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 result = ((wxDateTime const *)arg1)->FormatTime();
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 {
28627 #if wxUSE_UNICODE
28628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28629 #else
28630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28631 #endif
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28640 PyObject *resultobj = 0;
28641 wxDateTime *arg1 = (wxDateTime *) 0 ;
28642 wxString result;
28643 void *argp1 = 0 ;
28644 int res1 = 0 ;
28645 PyObject *swig_obj[1] ;
28646
28647 if (!args) SWIG_fail;
28648 swig_obj[0] = args;
28649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28650 if (!SWIG_IsOK(res1)) {
28651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28652 }
28653 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = ((wxDateTime const *)arg1)->FormatISODate();
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 {
28661 #if wxUSE_UNICODE
28662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28663 #else
28664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28665 #endif
28666 }
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28674 PyObject *resultobj = 0;
28675 wxDateTime *arg1 = (wxDateTime *) 0 ;
28676 wxString result;
28677 void *argp1 = 0 ;
28678 int res1 = 0 ;
28679 PyObject *swig_obj[1] ;
28680
28681 if (!args) SWIG_fail;
28682 swig_obj[0] = args;
28683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28684 if (!SWIG_IsOK(res1)) {
28685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28686 }
28687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 result = ((wxDateTime const *)arg1)->FormatISOTime();
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 {
28695 #if wxUSE_UNICODE
28696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28697 #else
28698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28699 #endif
28700 }
28701 return resultobj;
28702 fail:
28703 return NULL;
28704 }
28705
28706
28707 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28708 PyObject *obj;
28709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28710 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28711 return SWIG_Py_Void();
28712 }
28713
28714 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28715 return SWIG_Python_InitShadowInstance(args);
28716 }
28717
28718 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28719 PyObject *resultobj = 0;
28720 long arg1 ;
28721 wxTimeSpan result;
28722 long val1 ;
28723 int ecode1 = 0 ;
28724 PyObject * obj0 = 0 ;
28725 char * kwnames[] = {
28726 (char *) "ms", NULL
28727 };
28728
28729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28730 ecode1 = SWIG_AsVal_long(obj0, &val1);
28731 if (!SWIG_IsOK(ecode1)) {
28732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28733 }
28734 arg1 = static_cast< long >(val1);
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = wxTimeSpan::Milliseconds(arg1);
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28749 PyObject *resultobj = 0;
28750 wxTimeSpan result;
28751
28752 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28753 {
28754 PyThreadState* __tstate = wxPyBeginAllowThreads();
28755 result = wxTimeSpan::Millisecond();
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj = 0;
28768 long arg1 ;
28769 wxTimeSpan result;
28770 long val1 ;
28771 int ecode1 = 0 ;
28772 PyObject * obj0 = 0 ;
28773 char * kwnames[] = {
28774 (char *) "sec", NULL
28775 };
28776
28777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28778 ecode1 = SWIG_AsVal_long(obj0, &val1);
28779 if (!SWIG_IsOK(ecode1)) {
28780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28781 }
28782 arg1 = static_cast< long >(val1);
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = wxTimeSpan::Seconds(arg1);
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28797 PyObject *resultobj = 0;
28798 wxTimeSpan result;
28799
28800 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28801 {
28802 PyThreadState* __tstate = wxPyBeginAllowThreads();
28803 result = wxTimeSpan::Second();
28804 wxPyEndAllowThreads(__tstate);
28805 if (PyErr_Occurred()) SWIG_fail;
28806 }
28807 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28808 return resultobj;
28809 fail:
28810 return NULL;
28811 }
28812
28813
28814 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28815 PyObject *resultobj = 0;
28816 long arg1 ;
28817 wxTimeSpan result;
28818 long val1 ;
28819 int ecode1 = 0 ;
28820 PyObject * obj0 = 0 ;
28821 char * kwnames[] = {
28822 (char *) "min", NULL
28823 };
28824
28825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28826 ecode1 = SWIG_AsVal_long(obj0, &val1);
28827 if (!SWIG_IsOK(ecode1)) {
28828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28829 }
28830 arg1 = static_cast< long >(val1);
28831 {
28832 PyThreadState* __tstate = wxPyBeginAllowThreads();
28833 result = wxTimeSpan::Minutes(arg1);
28834 wxPyEndAllowThreads(__tstate);
28835 if (PyErr_Occurred()) SWIG_fail;
28836 }
28837 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28845 PyObject *resultobj = 0;
28846 wxTimeSpan result;
28847
28848 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 result = wxTimeSpan::Minute();
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28863 PyObject *resultobj = 0;
28864 long arg1 ;
28865 wxTimeSpan result;
28866 long val1 ;
28867 int ecode1 = 0 ;
28868 PyObject * obj0 = 0 ;
28869 char * kwnames[] = {
28870 (char *) "hours", NULL
28871 };
28872
28873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28874 ecode1 = SWIG_AsVal_long(obj0, &val1);
28875 if (!SWIG_IsOK(ecode1)) {
28876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28877 }
28878 arg1 = static_cast< long >(val1);
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 result = wxTimeSpan::Hours(arg1);
28882 wxPyEndAllowThreads(__tstate);
28883 if (PyErr_Occurred()) SWIG_fail;
28884 }
28885 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28886 return resultobj;
28887 fail:
28888 return NULL;
28889 }
28890
28891
28892 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28893 PyObject *resultobj = 0;
28894 wxTimeSpan result;
28895
28896 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 result = wxTimeSpan::Hour();
28900 wxPyEndAllowThreads(__tstate);
28901 if (PyErr_Occurred()) SWIG_fail;
28902 }
28903 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28911 PyObject *resultobj = 0;
28912 long arg1 ;
28913 wxTimeSpan result;
28914 long val1 ;
28915 int ecode1 = 0 ;
28916 PyObject * obj0 = 0 ;
28917 char * kwnames[] = {
28918 (char *) "days", NULL
28919 };
28920
28921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28922 ecode1 = SWIG_AsVal_long(obj0, &val1);
28923 if (!SWIG_IsOK(ecode1)) {
28924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28925 }
28926 arg1 = static_cast< long >(val1);
28927 {
28928 PyThreadState* __tstate = wxPyBeginAllowThreads();
28929 result = wxTimeSpan::Days(arg1);
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28941 PyObject *resultobj = 0;
28942 wxTimeSpan result;
28943
28944 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = wxTimeSpan::Day();
28948 wxPyEndAllowThreads(__tstate);
28949 if (PyErr_Occurred()) SWIG_fail;
28950 }
28951 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28959 PyObject *resultobj = 0;
28960 long arg1 ;
28961 wxTimeSpan result;
28962 long val1 ;
28963 int ecode1 = 0 ;
28964 PyObject * obj0 = 0 ;
28965 char * kwnames[] = {
28966 (char *) "days", NULL
28967 };
28968
28969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28970 ecode1 = SWIG_AsVal_long(obj0, &val1);
28971 if (!SWIG_IsOK(ecode1)) {
28972 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28973 }
28974 arg1 = static_cast< long >(val1);
28975 {
28976 PyThreadState* __tstate = wxPyBeginAllowThreads();
28977 result = wxTimeSpan::Weeks(arg1);
28978 wxPyEndAllowThreads(__tstate);
28979 if (PyErr_Occurred()) SWIG_fail;
28980 }
28981 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28982 return resultobj;
28983 fail:
28984 return NULL;
28985 }
28986
28987
28988 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28989 PyObject *resultobj = 0;
28990 wxTimeSpan result;
28991
28992 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28993 {
28994 PyThreadState* __tstate = wxPyBeginAllowThreads();
28995 result = wxTimeSpan::Week();
28996 wxPyEndAllowThreads(__tstate);
28997 if (PyErr_Occurred()) SWIG_fail;
28998 }
28999 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29000 return resultobj;
29001 fail:
29002 return NULL;
29003 }
29004
29005
29006 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29007 PyObject *resultobj = 0;
29008 long arg1 = (long) 0 ;
29009 long arg2 = (long) 0 ;
29010 long arg3 = (long) 0 ;
29011 long arg4 = (long) 0 ;
29012 wxTimeSpan *result = 0 ;
29013 long val1 ;
29014 int ecode1 = 0 ;
29015 long val2 ;
29016 int ecode2 = 0 ;
29017 long val3 ;
29018 int ecode3 = 0 ;
29019 long val4 ;
29020 int ecode4 = 0 ;
29021 PyObject * obj0 = 0 ;
29022 PyObject * obj1 = 0 ;
29023 PyObject * obj2 = 0 ;
29024 PyObject * obj3 = 0 ;
29025 char * kwnames[] = {
29026 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
29027 };
29028
29029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29030 if (obj0) {
29031 ecode1 = SWIG_AsVal_long(obj0, &val1);
29032 if (!SWIG_IsOK(ecode1)) {
29033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
29034 }
29035 arg1 = static_cast< long >(val1);
29036 }
29037 if (obj1) {
29038 ecode2 = SWIG_AsVal_long(obj1, &val2);
29039 if (!SWIG_IsOK(ecode2)) {
29040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
29041 }
29042 arg2 = static_cast< long >(val2);
29043 }
29044 if (obj2) {
29045 ecode3 = SWIG_AsVal_long(obj2, &val3);
29046 if (!SWIG_IsOK(ecode3)) {
29047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
29048 }
29049 arg3 = static_cast< long >(val3);
29050 }
29051 if (obj3) {
29052 ecode4 = SWIG_AsVal_long(obj3, &val4);
29053 if (!SWIG_IsOK(ecode4)) {
29054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
29055 }
29056 arg4 = static_cast< long >(val4);
29057 }
29058 {
29059 PyThreadState* __tstate = wxPyBeginAllowThreads();
29060 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29061 wxPyEndAllowThreads(__tstate);
29062 if (PyErr_Occurred()) SWIG_fail;
29063 }
29064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29072 PyObject *resultobj = 0;
29073 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29074 void *argp1 = 0 ;
29075 int res1 = 0 ;
29076 PyObject *swig_obj[1] ;
29077
29078 if (!args) SWIG_fail;
29079 swig_obj[0] = args;
29080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29081 if (!SWIG_IsOK(res1)) {
29082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29083 }
29084 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29085 {
29086 PyThreadState* __tstate = wxPyBeginAllowThreads();
29087 delete arg1;
29088
29089 wxPyEndAllowThreads(__tstate);
29090 if (PyErr_Occurred()) SWIG_fail;
29091 }
29092 resultobj = SWIG_Py_Void();
29093 return resultobj;
29094 fail:
29095 return NULL;
29096 }
29097
29098
29099 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29100 PyObject *resultobj = 0;
29101 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29102 wxTimeSpan *arg2 = 0 ;
29103 wxTimeSpan *result = 0 ;
29104 void *argp1 = 0 ;
29105 int res1 = 0 ;
29106 void *argp2 = 0 ;
29107 int res2 = 0 ;
29108 PyObject * obj0 = 0 ;
29109 PyObject * obj1 = 0 ;
29110 char * kwnames[] = {
29111 (char *) "self",(char *) "diff", NULL
29112 };
29113
29114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29116 if (!SWIG_IsOK(res1)) {
29117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29118 }
29119 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29120 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29121 if (!SWIG_IsOK(res2)) {
29122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29123 }
29124 if (!argp2) {
29125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29126 }
29127 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29128 {
29129 PyThreadState* __tstate = wxPyBeginAllowThreads();
29130 {
29131 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29132 result = (wxTimeSpan *) &_result_ref;
29133 }
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj = 0;
29146 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29147 wxTimeSpan *arg2 = 0 ;
29148 wxTimeSpan *result = 0 ;
29149 void *argp1 = 0 ;
29150 int res1 = 0 ;
29151 void *argp2 = 0 ;
29152 int res2 = 0 ;
29153 PyObject * obj0 = 0 ;
29154 PyObject * obj1 = 0 ;
29155 char * kwnames[] = {
29156 (char *) "self",(char *) "diff", NULL
29157 };
29158
29159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29161 if (!SWIG_IsOK(res1)) {
29162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29163 }
29164 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29165 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29166 if (!SWIG_IsOK(res2)) {
29167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29168 }
29169 if (!argp2) {
29170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29171 }
29172 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29173 {
29174 PyThreadState* __tstate = wxPyBeginAllowThreads();
29175 {
29176 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29177 result = (wxTimeSpan *) &_result_ref;
29178 }
29179 wxPyEndAllowThreads(__tstate);
29180 if (PyErr_Occurred()) SWIG_fail;
29181 }
29182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29183 return resultobj;
29184 fail:
29185 return NULL;
29186 }
29187
29188
29189 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29190 PyObject *resultobj = 0;
29191 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29192 int arg2 ;
29193 wxTimeSpan *result = 0 ;
29194 void *argp1 = 0 ;
29195 int res1 = 0 ;
29196 int val2 ;
29197 int ecode2 = 0 ;
29198 PyObject * obj0 = 0 ;
29199 PyObject * obj1 = 0 ;
29200 char * kwnames[] = {
29201 (char *) "self",(char *) "n", NULL
29202 };
29203
29204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29206 if (!SWIG_IsOK(res1)) {
29207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29208 }
29209 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29210 ecode2 = SWIG_AsVal_int(obj1, &val2);
29211 if (!SWIG_IsOK(ecode2)) {
29212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29213 }
29214 arg2 = static_cast< int >(val2);
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 {
29218 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29219 result = (wxTimeSpan *) &_result_ref;
29220 }
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 PyObject *resultobj = 0;
29233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29234 wxTimeSpan *result = 0 ;
29235 void *argp1 = 0 ;
29236 int res1 = 0 ;
29237 PyObject *swig_obj[1] ;
29238
29239 if (!args) SWIG_fail;
29240 swig_obj[0] = args;
29241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29242 if (!SWIG_IsOK(res1)) {
29243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29244 }
29245 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 {
29249 wxTimeSpan &_result_ref = (arg1)->Neg();
29250 result = (wxTimeSpan *) &_result_ref;
29251 }
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29263 PyObject *resultobj = 0;
29264 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29265 wxTimeSpan result;
29266 void *argp1 = 0 ;
29267 int res1 = 0 ;
29268 PyObject *swig_obj[1] ;
29269
29270 if (!args) SWIG_fail;
29271 swig_obj[0] = args;
29272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29273 if (!SWIG_IsOK(res1)) {
29274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29275 }
29276 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29277 {
29278 PyThreadState* __tstate = wxPyBeginAllowThreads();
29279 result = ((wxTimeSpan const *)arg1)->Abs();
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj = 0;
29292 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29293 wxTimeSpan *arg2 = 0 ;
29294 wxTimeSpan *result = 0 ;
29295 void *argp1 = 0 ;
29296 int res1 = 0 ;
29297 void *argp2 = 0 ;
29298 int res2 = 0 ;
29299 PyObject * obj0 = 0 ;
29300 PyObject * obj1 = 0 ;
29301 char * kwnames[] = {
29302 (char *) "self",(char *) "diff", NULL
29303 };
29304
29305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29307 if (!SWIG_IsOK(res1)) {
29308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29309 }
29310 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29311 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29312 if (!SWIG_IsOK(res2)) {
29313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29314 }
29315 if (!argp2) {
29316 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29317 }
29318 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29319 {
29320 PyThreadState* __tstate = wxPyBeginAllowThreads();
29321 {
29322 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29323 result = (wxTimeSpan *) &_result_ref;
29324 }
29325 wxPyEndAllowThreads(__tstate);
29326 if (PyErr_Occurred()) SWIG_fail;
29327 }
29328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29329 return resultobj;
29330 fail:
29331 return NULL;
29332 }
29333
29334
29335 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29336 PyObject *resultobj = 0;
29337 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29338 wxTimeSpan *arg2 = 0 ;
29339 wxTimeSpan *result = 0 ;
29340 void *argp1 = 0 ;
29341 int res1 = 0 ;
29342 void *argp2 = 0 ;
29343 int res2 = 0 ;
29344 PyObject * obj0 = 0 ;
29345 PyObject * obj1 = 0 ;
29346 char * kwnames[] = {
29347 (char *) "self",(char *) "diff", NULL
29348 };
29349
29350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29352 if (!SWIG_IsOK(res1)) {
29353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29354 }
29355 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29357 if (!SWIG_IsOK(res2)) {
29358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29359 }
29360 if (!argp2) {
29361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29362 }
29363 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 {
29367 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29368 result = (wxTimeSpan *) &_result_ref;
29369 }
29370 wxPyEndAllowThreads(__tstate);
29371 if (PyErr_Occurred()) SWIG_fail;
29372 }
29373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29374 return resultobj;
29375 fail:
29376 return NULL;
29377 }
29378
29379
29380 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29381 PyObject *resultobj = 0;
29382 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29383 int arg2 ;
29384 wxTimeSpan *result = 0 ;
29385 void *argp1 = 0 ;
29386 int res1 = 0 ;
29387 int val2 ;
29388 int ecode2 = 0 ;
29389 PyObject * obj0 = 0 ;
29390 PyObject * obj1 = 0 ;
29391 char * kwnames[] = {
29392 (char *) "self",(char *) "n", NULL
29393 };
29394
29395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29397 if (!SWIG_IsOK(res1)) {
29398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29399 }
29400 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29401 ecode2 = SWIG_AsVal_int(obj1, &val2);
29402 if (!SWIG_IsOK(ecode2)) {
29403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29404 }
29405 arg2 = static_cast< int >(val2);
29406 {
29407 PyThreadState* __tstate = wxPyBeginAllowThreads();
29408 {
29409 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29410 result = (wxTimeSpan *) &_result_ref;
29411 }
29412 wxPyEndAllowThreads(__tstate);
29413 if (PyErr_Occurred()) SWIG_fail;
29414 }
29415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29416 return resultobj;
29417 fail:
29418 return NULL;
29419 }
29420
29421
29422 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29423 PyObject *resultobj = 0;
29424 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29425 wxTimeSpan *result = 0 ;
29426 void *argp1 = 0 ;
29427 int res1 = 0 ;
29428 PyObject *swig_obj[1] ;
29429
29430 if (!args) SWIG_fail;
29431 swig_obj[0] = args;
29432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29433 if (!SWIG_IsOK(res1)) {
29434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29435 }
29436 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29437 {
29438 PyThreadState* __tstate = wxPyBeginAllowThreads();
29439 {
29440 wxTimeSpan &_result_ref = (arg1)->operator -();
29441 result = (wxTimeSpan *) &_result_ref;
29442 }
29443 wxPyEndAllowThreads(__tstate);
29444 if (PyErr_Occurred()) SWIG_fail;
29445 }
29446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29447 return resultobj;
29448 fail:
29449 return NULL;
29450 }
29451
29452
29453 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29454 PyObject *resultobj = 0;
29455 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29456 wxTimeSpan *arg2 = 0 ;
29457 wxTimeSpan result;
29458 void *argp1 = 0 ;
29459 int res1 = 0 ;
29460 void *argp2 = 0 ;
29461 int res2 = 0 ;
29462 PyObject * obj0 = 0 ;
29463 PyObject * obj1 = 0 ;
29464 char * kwnames[] = {
29465 (char *) "self",(char *) "other", NULL
29466 };
29467
29468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29470 if (!SWIG_IsOK(res1)) {
29471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29472 }
29473 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29474 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29475 if (!SWIG_IsOK(res2)) {
29476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29477 }
29478 if (!argp2) {
29479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29480 }
29481 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29482 {
29483 PyThreadState* __tstate = wxPyBeginAllowThreads();
29484 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29485 wxPyEndAllowThreads(__tstate);
29486 if (PyErr_Occurred()) SWIG_fail;
29487 }
29488 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29489 return resultobj;
29490 fail:
29491 return NULL;
29492 }
29493
29494
29495 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29496 PyObject *resultobj = 0;
29497 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29498 wxTimeSpan *arg2 = 0 ;
29499 wxTimeSpan result;
29500 void *argp1 = 0 ;
29501 int res1 = 0 ;
29502 void *argp2 = 0 ;
29503 int res2 = 0 ;
29504 PyObject * obj0 = 0 ;
29505 PyObject * obj1 = 0 ;
29506 char * kwnames[] = {
29507 (char *) "self",(char *) "other", NULL
29508 };
29509
29510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29512 if (!SWIG_IsOK(res1)) {
29513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29514 }
29515 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29516 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29517 if (!SWIG_IsOK(res2)) {
29518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29519 }
29520 if (!argp2) {
29521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29522 }
29523 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29524 {
29525 PyThreadState* __tstate = wxPyBeginAllowThreads();
29526 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29527 wxPyEndAllowThreads(__tstate);
29528 if (PyErr_Occurred()) SWIG_fail;
29529 }
29530 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29531 return resultobj;
29532 fail:
29533 return NULL;
29534 }
29535
29536
29537 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29538 PyObject *resultobj = 0;
29539 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29540 int arg2 ;
29541 wxTimeSpan result;
29542 void *argp1 = 0 ;
29543 int res1 = 0 ;
29544 int val2 ;
29545 int ecode2 = 0 ;
29546 PyObject * obj0 = 0 ;
29547 PyObject * obj1 = 0 ;
29548 char * kwnames[] = {
29549 (char *) "self",(char *) "n", NULL
29550 };
29551
29552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29554 if (!SWIG_IsOK(res1)) {
29555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29556 }
29557 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29558 ecode2 = SWIG_AsVal_int(obj1, &val2);
29559 if (!SWIG_IsOK(ecode2)) {
29560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29561 }
29562 arg2 = static_cast< int >(val2);
29563 {
29564 PyThreadState* __tstate = wxPyBeginAllowThreads();
29565 result = wxTimeSpan___mul__(arg1,arg2);
29566 wxPyEndAllowThreads(__tstate);
29567 if (PyErr_Occurred()) SWIG_fail;
29568 }
29569 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29570 return resultobj;
29571 fail:
29572 return NULL;
29573 }
29574
29575
29576 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29577 PyObject *resultobj = 0;
29578 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29579 int arg2 ;
29580 wxTimeSpan result;
29581 void *argp1 = 0 ;
29582 int res1 = 0 ;
29583 int val2 ;
29584 int ecode2 = 0 ;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 char * kwnames[] = {
29588 (char *) "self",(char *) "n", NULL
29589 };
29590
29591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29593 if (!SWIG_IsOK(res1)) {
29594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29595 }
29596 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29597 ecode2 = SWIG_AsVal_int(obj1, &val2);
29598 if (!SWIG_IsOK(ecode2)) {
29599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29600 }
29601 arg2 = static_cast< int >(val2);
29602 {
29603 PyThreadState* __tstate = wxPyBeginAllowThreads();
29604 result = wxTimeSpan___rmul__(arg1,arg2);
29605 wxPyEndAllowThreads(__tstate);
29606 if (PyErr_Occurred()) SWIG_fail;
29607 }
29608 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29616 PyObject *resultobj = 0;
29617 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29618 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29619 bool result;
29620 void *argp1 = 0 ;
29621 int res1 = 0 ;
29622 void *argp2 = 0 ;
29623 int res2 = 0 ;
29624 PyObject * obj0 = 0 ;
29625 PyObject * obj1 = 0 ;
29626 char * kwnames[] = {
29627 (char *) "self",(char *) "other", NULL
29628 };
29629
29630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29632 if (!SWIG_IsOK(res1)) {
29633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29634 }
29635 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29636 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29637 if (!SWIG_IsOK(res2)) {
29638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29639 }
29640 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 {
29648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29649 }
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29657 PyObject *resultobj = 0;
29658 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29659 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29660 bool result;
29661 void *argp1 = 0 ;
29662 int res1 = 0 ;
29663 void *argp2 = 0 ;
29664 int res2 = 0 ;
29665 PyObject * obj0 = 0 ;
29666 PyObject * obj1 = 0 ;
29667 char * kwnames[] = {
29668 (char *) "self",(char *) "other", NULL
29669 };
29670
29671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29673 if (!SWIG_IsOK(res1)) {
29674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29675 }
29676 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29678 if (!SWIG_IsOK(res2)) {
29679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29680 }
29681 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29682 {
29683 PyThreadState* __tstate = wxPyBeginAllowThreads();
29684 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29685 wxPyEndAllowThreads(__tstate);
29686 if (PyErr_Occurred()) SWIG_fail;
29687 }
29688 {
29689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29690 }
29691 return resultobj;
29692 fail:
29693 return NULL;
29694 }
29695
29696
29697 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29698 PyObject *resultobj = 0;
29699 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29700 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29701 bool result;
29702 void *argp1 = 0 ;
29703 int res1 = 0 ;
29704 void *argp2 = 0 ;
29705 int res2 = 0 ;
29706 PyObject * obj0 = 0 ;
29707 PyObject * obj1 = 0 ;
29708 char * kwnames[] = {
29709 (char *) "self",(char *) "other", NULL
29710 };
29711
29712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29714 if (!SWIG_IsOK(res1)) {
29715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29716 }
29717 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29719 if (!SWIG_IsOK(res2)) {
29720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29721 }
29722 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29723 {
29724 PyThreadState* __tstate = wxPyBeginAllowThreads();
29725 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29726 wxPyEndAllowThreads(__tstate);
29727 if (PyErr_Occurred()) SWIG_fail;
29728 }
29729 {
29730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29731 }
29732 return resultobj;
29733 fail:
29734 return NULL;
29735 }
29736
29737
29738 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29739 PyObject *resultobj = 0;
29740 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29741 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29742 bool result;
29743 void *argp1 = 0 ;
29744 int res1 = 0 ;
29745 void *argp2 = 0 ;
29746 int res2 = 0 ;
29747 PyObject * obj0 = 0 ;
29748 PyObject * obj1 = 0 ;
29749 char * kwnames[] = {
29750 (char *) "self",(char *) "other", NULL
29751 };
29752
29753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29755 if (!SWIG_IsOK(res1)) {
29756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29757 }
29758 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29760 if (!SWIG_IsOK(res2)) {
29761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29762 }
29763 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29764 {
29765 PyThreadState* __tstate = wxPyBeginAllowThreads();
29766 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29767 wxPyEndAllowThreads(__tstate);
29768 if (PyErr_Occurred()) SWIG_fail;
29769 }
29770 {
29771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29772 }
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29780 PyObject *resultobj = 0;
29781 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29782 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29783 bool result;
29784 void *argp1 = 0 ;
29785 int res1 = 0 ;
29786 void *argp2 = 0 ;
29787 int res2 = 0 ;
29788 PyObject * obj0 = 0 ;
29789 PyObject * obj1 = 0 ;
29790 char * kwnames[] = {
29791 (char *) "self",(char *) "other", NULL
29792 };
29793
29794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29796 if (!SWIG_IsOK(res1)) {
29797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29798 }
29799 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29801 if (!SWIG_IsOK(res2)) {
29802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29803 }
29804 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29805 {
29806 PyThreadState* __tstate = wxPyBeginAllowThreads();
29807 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29808 wxPyEndAllowThreads(__tstate);
29809 if (PyErr_Occurred()) SWIG_fail;
29810 }
29811 {
29812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29813 }
29814 return resultobj;
29815 fail:
29816 return NULL;
29817 }
29818
29819
29820 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29821 PyObject *resultobj = 0;
29822 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29823 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29824 bool result;
29825 void *argp1 = 0 ;
29826 int res1 = 0 ;
29827 void *argp2 = 0 ;
29828 int res2 = 0 ;
29829 PyObject * obj0 = 0 ;
29830 PyObject * obj1 = 0 ;
29831 char * kwnames[] = {
29832 (char *) "self",(char *) "other", NULL
29833 };
29834
29835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29837 if (!SWIG_IsOK(res1)) {
29838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29839 }
29840 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29842 if (!SWIG_IsOK(res2)) {
29843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29844 }
29845 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29846 {
29847 PyThreadState* __tstate = wxPyBeginAllowThreads();
29848 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29849 wxPyEndAllowThreads(__tstate);
29850 if (PyErr_Occurred()) SWIG_fail;
29851 }
29852 {
29853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29854 }
29855 return resultobj;
29856 fail:
29857 return NULL;
29858 }
29859
29860
29861 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29862 PyObject *resultobj = 0;
29863 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29864 bool result;
29865 void *argp1 = 0 ;
29866 int res1 = 0 ;
29867 PyObject *swig_obj[1] ;
29868
29869 if (!args) SWIG_fail;
29870 swig_obj[0] = args;
29871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29872 if (!SWIG_IsOK(res1)) {
29873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29874 }
29875 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29876 {
29877 PyThreadState* __tstate = wxPyBeginAllowThreads();
29878 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 {
29883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29884 }
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29892 PyObject *resultobj = 0;
29893 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29894 bool result;
29895 void *argp1 = 0 ;
29896 int res1 = 0 ;
29897 PyObject *swig_obj[1] ;
29898
29899 if (!args) SWIG_fail;
29900 swig_obj[0] = args;
29901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29904 }
29905 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 {
29913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29914 }
29915 return resultobj;
29916 fail:
29917 return NULL;
29918 }
29919
29920
29921 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29922 PyObject *resultobj = 0;
29923 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29924 bool result;
29925 void *argp1 = 0 ;
29926 int res1 = 0 ;
29927 PyObject *swig_obj[1] ;
29928
29929 if (!args) SWIG_fail;
29930 swig_obj[0] = args;
29931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29932 if (!SWIG_IsOK(res1)) {
29933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29934 }
29935 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 {
29943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29944 }
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29952 PyObject *resultobj = 0;
29953 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29954 wxTimeSpan *arg2 = 0 ;
29955 bool result;
29956 void *argp1 = 0 ;
29957 int res1 = 0 ;
29958 void *argp2 = 0 ;
29959 int res2 = 0 ;
29960 PyObject * obj0 = 0 ;
29961 PyObject * obj1 = 0 ;
29962 char * kwnames[] = {
29963 (char *) "self",(char *) "ts", NULL
29964 };
29965
29966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29968 if (!SWIG_IsOK(res1)) {
29969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29970 }
29971 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29972 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29973 if (!SWIG_IsOK(res2)) {
29974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29975 }
29976 if (!argp2) {
29977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29978 }
29979 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29980 {
29981 PyThreadState* __tstate = wxPyBeginAllowThreads();
29982 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29983 wxPyEndAllowThreads(__tstate);
29984 if (PyErr_Occurred()) SWIG_fail;
29985 }
29986 {
29987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29988 }
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29996 PyObject *resultobj = 0;
29997 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29998 wxTimeSpan *arg2 = 0 ;
29999 bool result;
30000 void *argp1 = 0 ;
30001 int res1 = 0 ;
30002 void *argp2 = 0 ;
30003 int res2 = 0 ;
30004 PyObject * obj0 = 0 ;
30005 PyObject * obj1 = 0 ;
30006 char * kwnames[] = {
30007 (char *) "self",(char *) "ts", NULL
30008 };
30009
30010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
30011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30012 if (!SWIG_IsOK(res1)) {
30013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30014 }
30015 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30016 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30017 if (!SWIG_IsOK(res2)) {
30018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30019 }
30020 if (!argp2) {
30021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30022 }
30023 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30024 {
30025 PyThreadState* __tstate = wxPyBeginAllowThreads();
30026 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
30027 wxPyEndAllowThreads(__tstate);
30028 if (PyErr_Occurred()) SWIG_fail;
30029 }
30030 {
30031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30032 }
30033 return resultobj;
30034 fail:
30035 return NULL;
30036 }
30037
30038
30039 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30040 PyObject *resultobj = 0;
30041 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30042 wxTimeSpan *arg2 = 0 ;
30043 bool result;
30044 void *argp1 = 0 ;
30045 int res1 = 0 ;
30046 void *argp2 = 0 ;
30047 int res2 = 0 ;
30048 PyObject * obj0 = 0 ;
30049 PyObject * obj1 = 0 ;
30050 char * kwnames[] = {
30051 (char *) "self",(char *) "t", NULL
30052 };
30053
30054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
30055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30056 if (!SWIG_IsOK(res1)) {
30057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30058 }
30059 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30061 if (!SWIG_IsOK(res2)) {
30062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30063 }
30064 if (!argp2) {
30065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30066 }
30067 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30071 wxPyEndAllowThreads(__tstate);
30072 if (PyErr_Occurred()) SWIG_fail;
30073 }
30074 {
30075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30076 }
30077 return resultobj;
30078 fail:
30079 return NULL;
30080 }
30081
30082
30083 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30084 PyObject *resultobj = 0;
30085 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30086 int result;
30087 void *argp1 = 0 ;
30088 int res1 = 0 ;
30089 PyObject *swig_obj[1] ;
30090
30091 if (!args) SWIG_fail;
30092 swig_obj[0] = args;
30093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30094 if (!SWIG_IsOK(res1)) {
30095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30096 }
30097 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 resultobj = SWIG_From_int(static_cast< int >(result));
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30112 PyObject *resultobj = 0;
30113 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30114 int result;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 PyObject *swig_obj[1] ;
30118
30119 if (!args) SWIG_fail;
30120 swig_obj[0] = args;
30121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30122 if (!SWIG_IsOK(res1)) {
30123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30124 }
30125 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30126 {
30127 PyThreadState* __tstate = wxPyBeginAllowThreads();
30128 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 resultobj = SWIG_From_int(static_cast< int >(result));
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30140 PyObject *resultobj = 0;
30141 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30142 int result;
30143 void *argp1 = 0 ;
30144 int res1 = 0 ;
30145 PyObject *swig_obj[1] ;
30146
30147 if (!args) SWIG_fail;
30148 swig_obj[0] = args;
30149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30150 if (!SWIG_IsOK(res1)) {
30151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30152 }
30153 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30154 {
30155 PyThreadState* __tstate = wxPyBeginAllowThreads();
30156 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30157 wxPyEndAllowThreads(__tstate);
30158 if (PyErr_Occurred()) SWIG_fail;
30159 }
30160 resultobj = SWIG_From_int(static_cast< int >(result));
30161 return resultobj;
30162 fail:
30163 return NULL;
30164 }
30165
30166
30167 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30168 PyObject *resultobj = 0;
30169 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30170 int result;
30171 void *argp1 = 0 ;
30172 int res1 = 0 ;
30173 PyObject *swig_obj[1] ;
30174
30175 if (!args) SWIG_fail;
30176 swig_obj[0] = args;
30177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30178 if (!SWIG_IsOK(res1)) {
30179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30180 }
30181 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 resultobj = SWIG_From_int(static_cast< int >(result));
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30196 PyObject *resultobj = 0;
30197 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30198 wxLongLong result;
30199 void *argp1 = 0 ;
30200 int res1 = 0 ;
30201 PyObject *swig_obj[1] ;
30202
30203 if (!args) SWIG_fail;
30204 swig_obj[0] = args;
30205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30206 if (!SWIG_IsOK(res1)) {
30207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30208 }
30209 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30210 {
30211 PyThreadState* __tstate = wxPyBeginAllowThreads();
30212 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30213 wxPyEndAllowThreads(__tstate);
30214 if (PyErr_Occurred()) SWIG_fail;
30215 }
30216 {
30217 PyObject *hi, *lo, *shifter, *shifted;
30218 hi = PyLong_FromLong( (&result)->GetHi() );
30219 lo = PyLong_FromLong( (&result)->GetLo() );
30220 shifter = PyLong_FromLong(32);
30221 shifted = PyNumber_Lshift(hi, shifter);
30222 resultobj = PyNumber_Or(shifted, lo);
30223 Py_DECREF(hi);
30224 Py_DECREF(lo);
30225 Py_DECREF(shifter);
30226 Py_DECREF(shifted);
30227 }
30228 return resultobj;
30229 fail:
30230 return NULL;
30231 }
30232
30233
30234 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30235 PyObject *resultobj = 0;
30236 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30237 wxLongLong result;
30238 void *argp1 = 0 ;
30239 int res1 = 0 ;
30240 PyObject *swig_obj[1] ;
30241
30242 if (!args) SWIG_fail;
30243 swig_obj[0] = args;
30244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30245 if (!SWIG_IsOK(res1)) {
30246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30247 }
30248 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30249 {
30250 PyThreadState* __tstate = wxPyBeginAllowThreads();
30251 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 {
30256 PyObject *hi, *lo, *shifter, *shifted;
30257 hi = PyLong_FromLong( (&result)->GetHi() );
30258 lo = PyLong_FromLong( (&result)->GetLo() );
30259 shifter = PyLong_FromLong(32);
30260 shifted = PyNumber_Lshift(hi, shifter);
30261 resultobj = PyNumber_Or(shifted, lo);
30262 Py_DECREF(hi);
30263 Py_DECREF(lo);
30264 Py_DECREF(shifter);
30265 Py_DECREF(shifted);
30266 }
30267 return resultobj;
30268 fail:
30269 return NULL;
30270 }
30271
30272
30273 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30274 PyObject *resultobj = 0;
30275 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30276 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30277 wxString *arg2 = (wxString *) &arg2_defvalue ;
30278 wxString result;
30279 void *argp1 = 0 ;
30280 int res1 = 0 ;
30281 bool temp2 = false ;
30282 PyObject * obj0 = 0 ;
30283 PyObject * obj1 = 0 ;
30284 char * kwnames[] = {
30285 (char *) "self",(char *) "format", NULL
30286 };
30287
30288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30290 if (!SWIG_IsOK(res1)) {
30291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30292 }
30293 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30294 if (obj1) {
30295 {
30296 arg2 = wxString_in_helper(obj1);
30297 if (arg2 == NULL) SWIG_fail;
30298 temp2 = true;
30299 }
30300 }
30301 {
30302 PyThreadState* __tstate = wxPyBeginAllowThreads();
30303 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30304 wxPyEndAllowThreads(__tstate);
30305 if (PyErr_Occurred()) SWIG_fail;
30306 }
30307 {
30308 #if wxUSE_UNICODE
30309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30310 #else
30311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30312 #endif
30313 }
30314 {
30315 if (temp2)
30316 delete arg2;
30317 }
30318 return resultobj;
30319 fail:
30320 {
30321 if (temp2)
30322 delete arg2;
30323 }
30324 return NULL;
30325 }
30326
30327
30328 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30329 PyObject *obj;
30330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30331 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30332 return SWIG_Py_Void();
30333 }
30334
30335 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30336 return SWIG_Python_InitShadowInstance(args);
30337 }
30338
30339 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj = 0;
30341 int arg1 = (int) 0 ;
30342 int arg2 = (int) 0 ;
30343 int arg3 = (int) 0 ;
30344 int arg4 = (int) 0 ;
30345 wxDateSpan *result = 0 ;
30346 int val1 ;
30347 int ecode1 = 0 ;
30348 int val2 ;
30349 int ecode2 = 0 ;
30350 int val3 ;
30351 int ecode3 = 0 ;
30352 int val4 ;
30353 int ecode4 = 0 ;
30354 PyObject * obj0 = 0 ;
30355 PyObject * obj1 = 0 ;
30356 PyObject * obj2 = 0 ;
30357 PyObject * obj3 = 0 ;
30358 char * kwnames[] = {
30359 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30360 };
30361
30362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30363 if (obj0) {
30364 ecode1 = SWIG_AsVal_int(obj0, &val1);
30365 if (!SWIG_IsOK(ecode1)) {
30366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30367 }
30368 arg1 = static_cast< int >(val1);
30369 }
30370 if (obj1) {
30371 ecode2 = SWIG_AsVal_int(obj1, &val2);
30372 if (!SWIG_IsOK(ecode2)) {
30373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30374 }
30375 arg2 = static_cast< int >(val2);
30376 }
30377 if (obj2) {
30378 ecode3 = SWIG_AsVal_int(obj2, &val3);
30379 if (!SWIG_IsOK(ecode3)) {
30380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30381 }
30382 arg3 = static_cast< int >(val3);
30383 }
30384 if (obj3) {
30385 ecode4 = SWIG_AsVal_int(obj3, &val4);
30386 if (!SWIG_IsOK(ecode4)) {
30387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30388 }
30389 arg4 = static_cast< int >(val4);
30390 }
30391 {
30392 PyThreadState* __tstate = wxPyBeginAllowThreads();
30393 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30394 wxPyEndAllowThreads(__tstate);
30395 if (PyErr_Occurred()) SWIG_fail;
30396 }
30397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30398 return resultobj;
30399 fail:
30400 return NULL;
30401 }
30402
30403
30404 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30405 PyObject *resultobj = 0;
30406 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30407 void *argp1 = 0 ;
30408 int res1 = 0 ;
30409 PyObject *swig_obj[1] ;
30410
30411 if (!args) SWIG_fail;
30412 swig_obj[0] = args;
30413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30414 if (!SWIG_IsOK(res1)) {
30415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30416 }
30417 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30418 {
30419 PyThreadState* __tstate = wxPyBeginAllowThreads();
30420 delete arg1;
30421
30422 wxPyEndAllowThreads(__tstate);
30423 if (PyErr_Occurred()) SWIG_fail;
30424 }
30425 resultobj = SWIG_Py_Void();
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj = 0;
30434 int arg1 ;
30435 wxDateSpan result;
30436 int val1 ;
30437 int ecode1 = 0 ;
30438 PyObject * obj0 = 0 ;
30439 char * kwnames[] = {
30440 (char *) "days", NULL
30441 };
30442
30443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30444 ecode1 = SWIG_AsVal_int(obj0, &val1);
30445 if (!SWIG_IsOK(ecode1)) {
30446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30447 }
30448 arg1 = static_cast< int >(val1);
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 result = wxDateSpan::Days(arg1);
30452 wxPyEndAllowThreads(__tstate);
30453 if (PyErr_Occurred()) SWIG_fail;
30454 }
30455 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30463 PyObject *resultobj = 0;
30464 wxDateSpan result;
30465
30466 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30467 {
30468 PyThreadState* __tstate = wxPyBeginAllowThreads();
30469 result = wxDateSpan::Day();
30470 wxPyEndAllowThreads(__tstate);
30471 if (PyErr_Occurred()) SWIG_fail;
30472 }
30473 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30474 return resultobj;
30475 fail:
30476 return NULL;
30477 }
30478
30479
30480 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30481 PyObject *resultobj = 0;
30482 int arg1 ;
30483 wxDateSpan result;
30484 int val1 ;
30485 int ecode1 = 0 ;
30486 PyObject * obj0 = 0 ;
30487 char * kwnames[] = {
30488 (char *) "weeks", NULL
30489 };
30490
30491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30492 ecode1 = SWIG_AsVal_int(obj0, &val1);
30493 if (!SWIG_IsOK(ecode1)) {
30494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30495 }
30496 arg1 = static_cast< int >(val1);
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 result = wxDateSpan::Weeks(arg1);
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxDateSpan result;
30513
30514 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30515 {
30516 PyThreadState* __tstate = wxPyBeginAllowThreads();
30517 result = wxDateSpan::Week();
30518 wxPyEndAllowThreads(__tstate);
30519 if (PyErr_Occurred()) SWIG_fail;
30520 }
30521 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30522 return resultobj;
30523 fail:
30524 return NULL;
30525 }
30526
30527
30528 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30529 PyObject *resultobj = 0;
30530 int arg1 ;
30531 wxDateSpan result;
30532 int val1 ;
30533 int ecode1 = 0 ;
30534 PyObject * obj0 = 0 ;
30535 char * kwnames[] = {
30536 (char *) "mon", NULL
30537 };
30538
30539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30540 ecode1 = SWIG_AsVal_int(obj0, &val1);
30541 if (!SWIG_IsOK(ecode1)) {
30542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30543 }
30544 arg1 = static_cast< int >(val1);
30545 {
30546 PyThreadState* __tstate = wxPyBeginAllowThreads();
30547 result = wxDateSpan::Months(arg1);
30548 wxPyEndAllowThreads(__tstate);
30549 if (PyErr_Occurred()) SWIG_fail;
30550 }
30551 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30552 return resultobj;
30553 fail:
30554 return NULL;
30555 }
30556
30557
30558 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30559 PyObject *resultobj = 0;
30560 wxDateSpan result;
30561
30562 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30563 {
30564 PyThreadState* __tstate = wxPyBeginAllowThreads();
30565 result = wxDateSpan::Month();
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj = 0;
30578 int arg1 ;
30579 wxDateSpan result;
30580 int val1 ;
30581 int ecode1 = 0 ;
30582 PyObject * obj0 = 0 ;
30583 char * kwnames[] = {
30584 (char *) "years", NULL
30585 };
30586
30587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30588 ecode1 = SWIG_AsVal_int(obj0, &val1);
30589 if (!SWIG_IsOK(ecode1)) {
30590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30591 }
30592 arg1 = static_cast< int >(val1);
30593 {
30594 PyThreadState* __tstate = wxPyBeginAllowThreads();
30595 result = wxDateSpan::Years(arg1);
30596 wxPyEndAllowThreads(__tstate);
30597 if (PyErr_Occurred()) SWIG_fail;
30598 }
30599 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30607 PyObject *resultobj = 0;
30608 wxDateSpan result;
30609
30610 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30611 {
30612 PyThreadState* __tstate = wxPyBeginAllowThreads();
30613 result = wxDateSpan::Year();
30614 wxPyEndAllowThreads(__tstate);
30615 if (PyErr_Occurred()) SWIG_fail;
30616 }
30617 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30618 return resultobj;
30619 fail:
30620 return NULL;
30621 }
30622
30623
30624 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30625 PyObject *resultobj = 0;
30626 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30627 int arg2 ;
30628 wxDateSpan *result = 0 ;
30629 void *argp1 = 0 ;
30630 int res1 = 0 ;
30631 int val2 ;
30632 int ecode2 = 0 ;
30633 PyObject * obj0 = 0 ;
30634 PyObject * obj1 = 0 ;
30635 char * kwnames[] = {
30636 (char *) "self",(char *) "n", NULL
30637 };
30638
30639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30641 if (!SWIG_IsOK(res1)) {
30642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30643 }
30644 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30645 ecode2 = SWIG_AsVal_int(obj1, &val2);
30646 if (!SWIG_IsOK(ecode2)) {
30647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30648 }
30649 arg2 = static_cast< int >(val2);
30650 {
30651 PyThreadState* __tstate = wxPyBeginAllowThreads();
30652 {
30653 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30654 result = (wxDateSpan *) &_result_ref;
30655 }
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30660 return resultobj;
30661 fail:
30662 return NULL;
30663 }
30664
30665
30666 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30667 PyObject *resultobj = 0;
30668 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30669 int arg2 ;
30670 wxDateSpan *result = 0 ;
30671 void *argp1 = 0 ;
30672 int res1 = 0 ;
30673 int val2 ;
30674 int ecode2 = 0 ;
30675 PyObject * obj0 = 0 ;
30676 PyObject * obj1 = 0 ;
30677 char * kwnames[] = {
30678 (char *) "self",(char *) "n", NULL
30679 };
30680
30681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30683 if (!SWIG_IsOK(res1)) {
30684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30685 }
30686 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30687 ecode2 = SWIG_AsVal_int(obj1, &val2);
30688 if (!SWIG_IsOK(ecode2)) {
30689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30690 }
30691 arg2 = static_cast< int >(val2);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 {
30695 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30696 result = (wxDateSpan *) &_result_ref;
30697 }
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj = 0;
30710 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30711 int arg2 ;
30712 wxDateSpan *result = 0 ;
30713 void *argp1 = 0 ;
30714 int res1 = 0 ;
30715 int val2 ;
30716 int ecode2 = 0 ;
30717 PyObject * obj0 = 0 ;
30718 PyObject * obj1 = 0 ;
30719 char * kwnames[] = {
30720 (char *) "self",(char *) "n", NULL
30721 };
30722
30723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30725 if (!SWIG_IsOK(res1)) {
30726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30727 }
30728 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30729 ecode2 = SWIG_AsVal_int(obj1, &val2);
30730 if (!SWIG_IsOK(ecode2)) {
30731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30732 }
30733 arg2 = static_cast< int >(val2);
30734 {
30735 PyThreadState* __tstate = wxPyBeginAllowThreads();
30736 {
30737 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30738 result = (wxDateSpan *) &_result_ref;
30739 }
30740 wxPyEndAllowThreads(__tstate);
30741 if (PyErr_Occurred()) SWIG_fail;
30742 }
30743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30751 PyObject *resultobj = 0;
30752 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30753 int arg2 ;
30754 wxDateSpan *result = 0 ;
30755 void *argp1 = 0 ;
30756 int res1 = 0 ;
30757 int val2 ;
30758 int ecode2 = 0 ;
30759 PyObject * obj0 = 0 ;
30760 PyObject * obj1 = 0 ;
30761 char * kwnames[] = {
30762 (char *) "self",(char *) "n", NULL
30763 };
30764
30765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30767 if (!SWIG_IsOK(res1)) {
30768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30769 }
30770 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30771 ecode2 = SWIG_AsVal_int(obj1, &val2);
30772 if (!SWIG_IsOK(ecode2)) {
30773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30774 }
30775 arg2 = static_cast< int >(val2);
30776 {
30777 PyThreadState* __tstate = wxPyBeginAllowThreads();
30778 {
30779 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30780 result = (wxDateSpan *) &_result_ref;
30781 }
30782 wxPyEndAllowThreads(__tstate);
30783 if (PyErr_Occurred()) SWIG_fail;
30784 }
30785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30786 return resultobj;
30787 fail:
30788 return NULL;
30789 }
30790
30791
30792 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30793 PyObject *resultobj = 0;
30794 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30795 int result;
30796 void *argp1 = 0 ;
30797 int res1 = 0 ;
30798 PyObject *swig_obj[1] ;
30799
30800 if (!args) SWIG_fail;
30801 swig_obj[0] = args;
30802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30803 if (!SWIG_IsOK(res1)) {
30804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30805 }
30806 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30807 {
30808 PyThreadState* __tstate = wxPyBeginAllowThreads();
30809 result = (int)((wxDateSpan const *)arg1)->GetYears();
30810 wxPyEndAllowThreads(__tstate);
30811 if (PyErr_Occurred()) SWIG_fail;
30812 }
30813 resultobj = SWIG_From_int(static_cast< int >(result));
30814 return resultobj;
30815 fail:
30816 return NULL;
30817 }
30818
30819
30820 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30821 PyObject *resultobj = 0;
30822 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30823 int result;
30824 void *argp1 = 0 ;
30825 int res1 = 0 ;
30826 PyObject *swig_obj[1] ;
30827
30828 if (!args) SWIG_fail;
30829 swig_obj[0] = args;
30830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30831 if (!SWIG_IsOK(res1)) {
30832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30833 }
30834 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 resultobj = SWIG_From_int(static_cast< int >(result));
30842 return resultobj;
30843 fail:
30844 return NULL;
30845 }
30846
30847
30848 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30849 PyObject *resultobj = 0;
30850 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30851 int result;
30852 void *argp1 = 0 ;
30853 int res1 = 0 ;
30854 PyObject *swig_obj[1] ;
30855
30856 if (!args) SWIG_fail;
30857 swig_obj[0] = args;
30858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30859 if (!SWIG_IsOK(res1)) {
30860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30861 }
30862 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30863 {
30864 PyThreadState* __tstate = wxPyBeginAllowThreads();
30865 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 resultobj = SWIG_From_int(static_cast< int >(result));
30870 return resultobj;
30871 fail:
30872 return NULL;
30873 }
30874
30875
30876 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30877 PyObject *resultobj = 0;
30878 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30879 int result;
30880 void *argp1 = 0 ;
30881 int res1 = 0 ;
30882 PyObject *swig_obj[1] ;
30883
30884 if (!args) SWIG_fail;
30885 swig_obj[0] = args;
30886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30887 if (!SWIG_IsOK(res1)) {
30888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30889 }
30890 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 result = (int)((wxDateSpan const *)arg1)->GetDays();
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 resultobj = SWIG_From_int(static_cast< int >(result));
30898 return resultobj;
30899 fail:
30900 return NULL;
30901 }
30902
30903
30904 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30905 PyObject *resultobj = 0;
30906 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30907 int result;
30908 void *argp1 = 0 ;
30909 int res1 = 0 ;
30910 PyObject *swig_obj[1] ;
30911
30912 if (!args) SWIG_fail;
30913 swig_obj[0] = args;
30914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30915 if (!SWIG_IsOK(res1)) {
30916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30917 }
30918 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30919 {
30920 PyThreadState* __tstate = wxPyBeginAllowThreads();
30921 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30922 wxPyEndAllowThreads(__tstate);
30923 if (PyErr_Occurred()) SWIG_fail;
30924 }
30925 resultobj = SWIG_From_int(static_cast< int >(result));
30926 return resultobj;
30927 fail:
30928 return NULL;
30929 }
30930
30931
30932 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30933 PyObject *resultobj = 0;
30934 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30935 wxDateSpan *arg2 = 0 ;
30936 wxDateSpan *result = 0 ;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 void *argp2 = 0 ;
30940 int res2 = 0 ;
30941 PyObject * obj0 = 0 ;
30942 PyObject * obj1 = 0 ;
30943 char * kwnames[] = {
30944 (char *) "self",(char *) "other", NULL
30945 };
30946
30947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30949 if (!SWIG_IsOK(res1)) {
30950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30951 }
30952 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30954 if (!SWIG_IsOK(res2)) {
30955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30956 }
30957 if (!argp2) {
30958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30959 }
30960 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 {
30964 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30965 result = (wxDateSpan *) &_result_ref;
30966 }
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30971 return resultobj;
30972 fail:
30973 return NULL;
30974 }
30975
30976
30977 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30978 PyObject *resultobj = 0;
30979 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30980 wxDateSpan *arg2 = 0 ;
30981 wxDateSpan *result = 0 ;
30982 void *argp1 = 0 ;
30983 int res1 = 0 ;
30984 void *argp2 = 0 ;
30985 int res2 = 0 ;
30986 PyObject * obj0 = 0 ;
30987 PyObject * obj1 = 0 ;
30988 char * kwnames[] = {
30989 (char *) "self",(char *) "other", NULL
30990 };
30991
30992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30994 if (!SWIG_IsOK(res1)) {
30995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30996 }
30997 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30998 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30999 if (!SWIG_IsOK(res2)) {
31000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31001 }
31002 if (!argp2) {
31003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31004 }
31005 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 {
31009 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
31010 result = (wxDateSpan *) &_result_ref;
31011 }
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31023 PyObject *resultobj = 0;
31024 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31025 wxDateSpan *result = 0 ;
31026 void *argp1 = 0 ;
31027 int res1 = 0 ;
31028 PyObject *swig_obj[1] ;
31029
31030 if (!args) SWIG_fail;
31031 swig_obj[0] = args;
31032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31033 if (!SWIG_IsOK(res1)) {
31034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31035 }
31036 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 {
31040 wxDateSpan &_result_ref = (arg1)->Neg();
31041 result = (wxDateSpan *) &_result_ref;
31042 }
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31054 PyObject *resultobj = 0;
31055 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31056 int arg2 ;
31057 wxDateSpan *result = 0 ;
31058 void *argp1 = 0 ;
31059 int res1 = 0 ;
31060 int val2 ;
31061 int ecode2 = 0 ;
31062 PyObject * obj0 = 0 ;
31063 PyObject * obj1 = 0 ;
31064 char * kwnames[] = {
31065 (char *) "self",(char *) "factor", NULL
31066 };
31067
31068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31070 if (!SWIG_IsOK(res1)) {
31071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31072 }
31073 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31074 ecode2 = SWIG_AsVal_int(obj1, &val2);
31075 if (!SWIG_IsOK(ecode2)) {
31076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31077 }
31078 arg2 = static_cast< int >(val2);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 {
31082 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31083 result = (wxDateSpan *) &_result_ref;
31084 }
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31089 return resultobj;
31090 fail:
31091 return NULL;
31092 }
31093
31094
31095 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31096 PyObject *resultobj = 0;
31097 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31098 wxDateSpan *arg2 = 0 ;
31099 wxDateSpan *result = 0 ;
31100 void *argp1 = 0 ;
31101 int res1 = 0 ;
31102 void *argp2 = 0 ;
31103 int res2 = 0 ;
31104 PyObject * obj0 = 0 ;
31105 PyObject * obj1 = 0 ;
31106 char * kwnames[] = {
31107 (char *) "self",(char *) "other", NULL
31108 };
31109
31110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31112 if (!SWIG_IsOK(res1)) {
31113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31114 }
31115 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31117 if (!SWIG_IsOK(res2)) {
31118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31119 }
31120 if (!argp2) {
31121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31122 }
31123 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 {
31127 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31128 result = (wxDateSpan *) &_result_ref;
31129 }
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj = 0;
31142 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31143 wxDateSpan *arg2 = 0 ;
31144 wxDateSpan *result = 0 ;
31145 void *argp1 = 0 ;
31146 int res1 = 0 ;
31147 void *argp2 = 0 ;
31148 int res2 = 0 ;
31149 PyObject * obj0 = 0 ;
31150 PyObject * obj1 = 0 ;
31151 char * kwnames[] = {
31152 (char *) "self",(char *) "other", NULL
31153 };
31154
31155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31157 if (!SWIG_IsOK(res1)) {
31158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31159 }
31160 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31162 if (!SWIG_IsOK(res2)) {
31163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31164 }
31165 if (!argp2) {
31166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31167 }
31168 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 {
31172 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31173 result = (wxDateSpan *) &_result_ref;
31174 }
31175 wxPyEndAllowThreads(__tstate);
31176 if (PyErr_Occurred()) SWIG_fail;
31177 }
31178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31179 return resultobj;
31180 fail:
31181 return NULL;
31182 }
31183
31184
31185 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31186 PyObject *resultobj = 0;
31187 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31188 wxDateSpan *result = 0 ;
31189 void *argp1 = 0 ;
31190 int res1 = 0 ;
31191 PyObject *swig_obj[1] ;
31192
31193 if (!args) SWIG_fail;
31194 swig_obj[0] = args;
31195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31196 if (!SWIG_IsOK(res1)) {
31197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31198 }
31199 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31200 {
31201 PyThreadState* __tstate = wxPyBeginAllowThreads();
31202 {
31203 wxDateSpan &_result_ref = (arg1)->operator -();
31204 result = (wxDateSpan *) &_result_ref;
31205 }
31206 wxPyEndAllowThreads(__tstate);
31207 if (PyErr_Occurred()) SWIG_fail;
31208 }
31209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31210 return resultobj;
31211 fail:
31212 return NULL;
31213 }
31214
31215
31216 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31217 PyObject *resultobj = 0;
31218 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31219 int arg2 ;
31220 wxDateSpan *result = 0 ;
31221 void *argp1 = 0 ;
31222 int res1 = 0 ;
31223 int val2 ;
31224 int ecode2 = 0 ;
31225 PyObject * obj0 = 0 ;
31226 PyObject * obj1 = 0 ;
31227 char * kwnames[] = {
31228 (char *) "self",(char *) "factor", NULL
31229 };
31230
31231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31233 if (!SWIG_IsOK(res1)) {
31234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31235 }
31236 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31237 ecode2 = SWIG_AsVal_int(obj1, &val2);
31238 if (!SWIG_IsOK(ecode2)) {
31239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31240 }
31241 arg2 = static_cast< int >(val2);
31242 {
31243 PyThreadState* __tstate = wxPyBeginAllowThreads();
31244 {
31245 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31246 result = (wxDateSpan *) &_result_ref;
31247 }
31248 wxPyEndAllowThreads(__tstate);
31249 if (PyErr_Occurred()) SWIG_fail;
31250 }
31251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31252 return resultobj;
31253 fail:
31254 return NULL;
31255 }
31256
31257
31258 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31259 PyObject *resultobj = 0;
31260 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31261 wxDateSpan *arg2 = 0 ;
31262 wxDateSpan result;
31263 void *argp1 = 0 ;
31264 int res1 = 0 ;
31265 void *argp2 = 0 ;
31266 int res2 = 0 ;
31267 PyObject * obj0 = 0 ;
31268 PyObject * obj1 = 0 ;
31269 char * kwnames[] = {
31270 (char *) "self",(char *) "other", NULL
31271 };
31272
31273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31275 if (!SWIG_IsOK(res1)) {
31276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31277 }
31278 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31279 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31280 if (!SWIG_IsOK(res2)) {
31281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31282 }
31283 if (!argp2) {
31284 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31285 }
31286 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31290 wxPyEndAllowThreads(__tstate);
31291 if (PyErr_Occurred()) SWIG_fail;
31292 }
31293 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31294 return resultobj;
31295 fail:
31296 return NULL;
31297 }
31298
31299
31300 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31301 PyObject *resultobj = 0;
31302 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31303 wxDateSpan *arg2 = 0 ;
31304 wxDateSpan result;
31305 void *argp1 = 0 ;
31306 int res1 = 0 ;
31307 void *argp2 = 0 ;
31308 int res2 = 0 ;
31309 PyObject * obj0 = 0 ;
31310 PyObject * obj1 = 0 ;
31311 char * kwnames[] = {
31312 (char *) "self",(char *) "other", NULL
31313 };
31314
31315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31317 if (!SWIG_IsOK(res1)) {
31318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31319 }
31320 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31322 if (!SWIG_IsOK(res2)) {
31323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31324 }
31325 if (!argp2) {
31326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31327 }
31328 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31332 wxPyEndAllowThreads(__tstate);
31333 if (PyErr_Occurred()) SWIG_fail;
31334 }
31335 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31343 PyObject *resultobj = 0;
31344 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31345 int arg2 ;
31346 wxDateSpan result;
31347 void *argp1 = 0 ;
31348 int res1 = 0 ;
31349 int val2 ;
31350 int ecode2 = 0 ;
31351 PyObject * obj0 = 0 ;
31352 PyObject * obj1 = 0 ;
31353 char * kwnames[] = {
31354 (char *) "self",(char *) "n", NULL
31355 };
31356
31357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31359 if (!SWIG_IsOK(res1)) {
31360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31361 }
31362 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31363 ecode2 = SWIG_AsVal_int(obj1, &val2);
31364 if (!SWIG_IsOK(ecode2)) {
31365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31366 }
31367 arg2 = static_cast< int >(val2);
31368 {
31369 PyThreadState* __tstate = wxPyBeginAllowThreads();
31370 result = wxDateSpan___mul__(arg1,arg2);
31371 wxPyEndAllowThreads(__tstate);
31372 if (PyErr_Occurred()) SWIG_fail;
31373 }
31374 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31375 return resultobj;
31376 fail:
31377 return NULL;
31378 }
31379
31380
31381 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31382 PyObject *resultobj = 0;
31383 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31384 int arg2 ;
31385 wxDateSpan result;
31386 void *argp1 = 0 ;
31387 int res1 = 0 ;
31388 int val2 ;
31389 int ecode2 = 0 ;
31390 PyObject * obj0 = 0 ;
31391 PyObject * obj1 = 0 ;
31392 char * kwnames[] = {
31393 (char *) "self",(char *) "n", NULL
31394 };
31395
31396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31398 if (!SWIG_IsOK(res1)) {
31399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31400 }
31401 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31402 ecode2 = SWIG_AsVal_int(obj1, &val2);
31403 if (!SWIG_IsOK(ecode2)) {
31404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31405 }
31406 arg2 = static_cast< int >(val2);
31407 {
31408 PyThreadState* __tstate = wxPyBeginAllowThreads();
31409 result = wxDateSpan___rmul__(arg1,arg2);
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31414 return resultobj;
31415 fail:
31416 return NULL;
31417 }
31418
31419
31420 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31421 PyObject *resultobj = 0;
31422 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31423 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31424 bool result;
31425 void *argp1 = 0 ;
31426 int res1 = 0 ;
31427 void *argp2 = 0 ;
31428 int res2 = 0 ;
31429 PyObject * obj0 = 0 ;
31430 PyObject * obj1 = 0 ;
31431 char * kwnames[] = {
31432 (char *) "self",(char *) "other", NULL
31433 };
31434
31435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31437 if (!SWIG_IsOK(res1)) {
31438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31439 }
31440 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31442 if (!SWIG_IsOK(res2)) {
31443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31444 }
31445 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31449 wxPyEndAllowThreads(__tstate);
31450 if (PyErr_Occurred()) SWIG_fail;
31451 }
31452 {
31453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31454 }
31455 return resultobj;
31456 fail:
31457 return NULL;
31458 }
31459
31460
31461 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31462 PyObject *resultobj = 0;
31463 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31464 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31465 bool result;
31466 void *argp1 = 0 ;
31467 int res1 = 0 ;
31468 void *argp2 = 0 ;
31469 int res2 = 0 ;
31470 PyObject * obj0 = 0 ;
31471 PyObject * obj1 = 0 ;
31472 char * kwnames[] = {
31473 (char *) "self",(char *) "other", NULL
31474 };
31475
31476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31478 if (!SWIG_IsOK(res1)) {
31479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31480 }
31481 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31483 if (!SWIG_IsOK(res2)) {
31484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31485 }
31486 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31487 {
31488 PyThreadState* __tstate = wxPyBeginAllowThreads();
31489 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 {
31494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31495 }
31496 return resultobj;
31497 fail:
31498 return NULL;
31499 }
31500
31501
31502 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31503 PyObject *obj;
31504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31505 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31506 return SWIG_Py_Void();
31507 }
31508
31509 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31510 return SWIG_Python_InitShadowInstance(args);
31511 }
31512
31513 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31514 PyObject *resultobj = 0;
31515 long result;
31516
31517 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31518 {
31519 PyThreadState* __tstate = wxPyBeginAllowThreads();
31520 result = (long)wxGetLocalTime();
31521 wxPyEndAllowThreads(__tstate);
31522 if (PyErr_Occurred()) SWIG_fail;
31523 }
31524 resultobj = SWIG_From_long(static_cast< long >(result));
31525 return resultobj;
31526 fail:
31527 return NULL;
31528 }
31529
31530
31531 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31532 PyObject *resultobj = 0;
31533 long result;
31534
31535 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31536 {
31537 PyThreadState* __tstate = wxPyBeginAllowThreads();
31538 result = (long)wxGetUTCTime();
31539 wxPyEndAllowThreads(__tstate);
31540 if (PyErr_Occurred()) SWIG_fail;
31541 }
31542 resultobj = SWIG_From_long(static_cast< long >(result));
31543 return resultobj;
31544 fail:
31545 return NULL;
31546 }
31547
31548
31549 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31550 PyObject *resultobj = 0;
31551 long result;
31552
31553 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 result = (long)wxGetCurrentTime();
31557 wxPyEndAllowThreads(__tstate);
31558 if (PyErr_Occurred()) SWIG_fail;
31559 }
31560 resultobj = SWIG_From_long(static_cast< long >(result));
31561 return resultobj;
31562 fail:
31563 return NULL;
31564 }
31565
31566
31567 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31568 PyObject *resultobj = 0;
31569 wxLongLong result;
31570
31571 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 result = wxGetLocalTimeMillis();
31575 wxPyEndAllowThreads(__tstate);
31576 if (PyErr_Occurred()) SWIG_fail;
31577 }
31578 {
31579 PyObject *hi, *lo, *shifter, *shifted;
31580 hi = PyLong_FromLong( (&result)->GetHi() );
31581 lo = PyLong_FromLong( (&result)->GetLo() );
31582 shifter = PyLong_FromLong(32);
31583 shifted = PyNumber_Lshift(hi, shifter);
31584 resultobj = PyNumber_Or(shifted, lo);
31585 Py_DECREF(hi);
31586 Py_DECREF(lo);
31587 Py_DECREF(shifter);
31588 Py_DECREF(shifted);
31589 }
31590 return resultobj;
31591 fail:
31592 return NULL;
31593 }
31594
31595
31596 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31597 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31598 return 1;
31599 }
31600
31601
31602 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31603 PyObject *pyobj = 0;
31604
31605 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31606 return pyobj;
31607 }
31608
31609
31610 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31611 PyObject *resultobj = 0;
31612 wxDataFormatId arg1 ;
31613 wxDataFormat *result = 0 ;
31614 int val1 ;
31615 int ecode1 = 0 ;
31616 PyObject * obj0 = 0 ;
31617 char * kwnames[] = {
31618 (char *) "type", NULL
31619 };
31620
31621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31622 ecode1 = SWIG_AsVal_int(obj0, &val1);
31623 if (!SWIG_IsOK(ecode1)) {
31624 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31625 }
31626 arg1 = static_cast< wxDataFormatId >(val1);
31627 {
31628 PyThreadState* __tstate = wxPyBeginAllowThreads();
31629 result = (wxDataFormat *)new wxDataFormat(arg1);
31630 wxPyEndAllowThreads(__tstate);
31631 if (PyErr_Occurred()) SWIG_fail;
31632 }
31633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31634 return resultobj;
31635 fail:
31636 return NULL;
31637 }
31638
31639
31640 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31641 PyObject *resultobj = 0;
31642 wxString *arg1 = 0 ;
31643 wxDataFormat *result = 0 ;
31644 bool temp1 = false ;
31645 PyObject * obj0 = 0 ;
31646 char * kwnames[] = {
31647 (char *) "format", NULL
31648 };
31649
31650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31651 {
31652 arg1 = wxString_in_helper(obj0);
31653 if (arg1 == NULL) SWIG_fail;
31654 temp1 = true;
31655 }
31656 {
31657 PyThreadState* __tstate = wxPyBeginAllowThreads();
31658 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31659 wxPyEndAllowThreads(__tstate);
31660 if (PyErr_Occurred()) SWIG_fail;
31661 }
31662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31663 {
31664 if (temp1)
31665 delete arg1;
31666 }
31667 return resultobj;
31668 fail:
31669 {
31670 if (temp1)
31671 delete arg1;
31672 }
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31678 PyObject *resultobj = 0;
31679 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 PyObject *swig_obj[1] ;
31683
31684 if (!args) SWIG_fail;
31685 swig_obj[0] = args;
31686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31689 }
31690 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 delete arg1;
31694
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 resultobj = SWIG_Py_Void();
31699 return resultobj;
31700 fail:
31701 return NULL;
31702 }
31703
31704
31705 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31706 PyObject *resultobj = 0;
31707 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31708 wxDataFormatId arg2 ;
31709 bool result;
31710 void *argp1 = 0 ;
31711 int res1 = 0 ;
31712 int val2 ;
31713 int ecode2 = 0 ;
31714
31715 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31717 if (!SWIG_IsOK(res1)) {
31718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31719 }
31720 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31721 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31722 if (!SWIG_IsOK(ecode2)) {
31723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31724 }
31725 arg2 = static_cast< wxDataFormatId >(val2);
31726 {
31727 PyThreadState* __tstate = wxPyBeginAllowThreads();
31728 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31729 wxPyEndAllowThreads(__tstate);
31730 if (PyErr_Occurred()) SWIG_fail;
31731 }
31732 {
31733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31734 }
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31742 PyObject *resultobj = 0;
31743 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31744 wxDataFormatId arg2 ;
31745 bool result;
31746 void *argp1 = 0 ;
31747 int res1 = 0 ;
31748 int val2 ;
31749 int ecode2 = 0 ;
31750
31751 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31753 if (!SWIG_IsOK(res1)) {
31754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31755 }
31756 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31757 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31758 if (!SWIG_IsOK(ecode2)) {
31759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31760 }
31761 arg2 = static_cast< wxDataFormatId >(val2);
31762 {
31763 PyThreadState* __tstate = wxPyBeginAllowThreads();
31764 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31765 wxPyEndAllowThreads(__tstate);
31766 if (PyErr_Occurred()) SWIG_fail;
31767 }
31768 {
31769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31770 }
31771 return resultobj;
31772 fail:
31773 return NULL;
31774 }
31775
31776
31777 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31778 PyObject *resultobj = 0;
31779 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31780 wxDataFormat *arg2 = 0 ;
31781 bool result;
31782 void *argp1 = 0 ;
31783 int res1 = 0 ;
31784 void *argp2 = 0 ;
31785 int res2 = 0 ;
31786
31787 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31789 if (!SWIG_IsOK(res1)) {
31790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31791 }
31792 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31793 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31794 if (!SWIG_IsOK(res2)) {
31795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31796 }
31797 if (!argp2) {
31798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31799 }
31800 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 {
31808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31809 }
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31817 int argc;
31818 PyObject *argv[3];
31819
31820 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31821 --argc;
31822 if (argc == 2) {
31823 int _v = 0;
31824 {
31825 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31826 _v = SWIG_CheckState(res);
31827 }
31828 if (!_v) goto check_1;
31829 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31830 }
31831 check_1:
31832
31833 if (argc == 2) {
31834 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31835 }
31836
31837 fail:
31838 Py_INCREF(Py_NotImplemented);
31839 return Py_NotImplemented;
31840 }
31841
31842
31843 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31844 PyObject *resultobj = 0;
31845 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31846 wxDataFormat *arg2 = 0 ;
31847 bool result;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 void *argp2 = 0 ;
31851 int res2 = 0 ;
31852
31853 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31855 if (!SWIG_IsOK(res1)) {
31856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31857 }
31858 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31859 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31860 if (!SWIG_IsOK(res2)) {
31861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31862 }
31863 if (!argp2) {
31864 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31865 }
31866 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 {
31874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31875 }
31876 return resultobj;
31877 fail:
31878 return NULL;
31879 }
31880
31881
31882 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31883 int argc;
31884 PyObject *argv[3];
31885
31886 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31887 --argc;
31888 if (argc == 2) {
31889 int _v = 0;
31890 {
31891 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31892 _v = SWIG_CheckState(res);
31893 }
31894 if (!_v) goto check_1;
31895 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31896 }
31897 check_1:
31898
31899 if (argc == 2) {
31900 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31901 }
31902
31903 fail:
31904 Py_INCREF(Py_NotImplemented);
31905 return Py_NotImplemented;
31906 }
31907
31908
31909 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31910 PyObject *resultobj = 0;
31911 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31912 wxDataFormatId arg2 ;
31913 void *argp1 = 0 ;
31914 int res1 = 0 ;
31915 int val2 ;
31916 int ecode2 = 0 ;
31917 PyObject * obj0 = 0 ;
31918 PyObject * obj1 = 0 ;
31919 char * kwnames[] = {
31920 (char *) "self",(char *) "format", NULL
31921 };
31922
31923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31925 if (!SWIG_IsOK(res1)) {
31926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31927 }
31928 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31929 ecode2 = SWIG_AsVal_int(obj1, &val2);
31930 if (!SWIG_IsOK(ecode2)) {
31931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31932 }
31933 arg2 = static_cast< wxDataFormatId >(val2);
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 (arg1)->SetType(arg2);
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 resultobj = SWIG_Py_Void();
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31948 PyObject *resultobj = 0;
31949 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31950 wxDataFormatId result;
31951 void *argp1 = 0 ;
31952 int res1 = 0 ;
31953 PyObject *swig_obj[1] ;
31954
31955 if (!args) SWIG_fail;
31956 swig_obj[0] = args;
31957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31958 if (!SWIG_IsOK(res1)) {
31959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31960 }
31961 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31962 {
31963 PyThreadState* __tstate = wxPyBeginAllowThreads();
31964 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31965 wxPyEndAllowThreads(__tstate);
31966 if (PyErr_Occurred()) SWIG_fail;
31967 }
31968 resultobj = SWIG_From_int(static_cast< int >(result));
31969 return resultobj;
31970 fail:
31971 return NULL;
31972 }
31973
31974
31975 SWIGINTERN PyObject *_wrap_DataFormat__GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31976 PyObject *resultobj = 0;
31977 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31978 wxString result;
31979 void *argp1 = 0 ;
31980 int res1 = 0 ;
31981 PyObject *swig_obj[1] ;
31982
31983 if (!args) SWIG_fail;
31984 swig_obj[0] = args;
31985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31986 if (!SWIG_IsOK(res1)) {
31987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat__GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31988 }
31989 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31990 {
31991 PyThreadState* __tstate = wxPyBeginAllowThreads();
31992 result = ((wxDataFormat const *)arg1)->GetId();
31993 wxPyEndAllowThreads(__tstate);
31994 if (PyErr_Occurred()) SWIG_fail;
31995 }
31996 {
31997 #if wxUSE_UNICODE
31998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31999 #else
32000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32001 #endif
32002 }
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32010 PyObject *resultobj = 0;
32011 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
32012 wxString *arg2 = 0 ;
32013 void *argp1 = 0 ;
32014 int res1 = 0 ;
32015 bool temp2 = false ;
32016 PyObject * obj0 = 0 ;
32017 PyObject * obj1 = 0 ;
32018 char * kwnames[] = {
32019 (char *) "self",(char *) "format", NULL
32020 };
32021
32022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
32023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
32024 if (!SWIG_IsOK(res1)) {
32025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
32026 }
32027 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32028 {
32029 arg2 = wxString_in_helper(obj1);
32030 if (arg2 == NULL) SWIG_fail;
32031 temp2 = true;
32032 }
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 (arg1)->SetId((wxString const &)*arg2);
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_Py_Void();
32040 {
32041 if (temp2)
32042 delete arg2;
32043 }
32044 return resultobj;
32045 fail:
32046 {
32047 if (temp2)
32048 delete arg2;
32049 }
32050 return NULL;
32051 }
32052
32053
32054 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32055 PyObject *obj;
32056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32057 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32058 return SWIG_Py_Void();
32059 }
32060
32061 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32062 return SWIG_Python_InitShadowInstance(args);
32063 }
32064
32065 SWIGINTERN int FormatInvalid_set(PyObject *) {
32066 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32067 return 1;
32068 }
32069
32070
32071 SWIGINTERN PyObject *FormatInvalid_get(void) {
32072 PyObject *pyobj = 0;
32073
32074 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32075 return pyobj;
32076 }
32077
32078
32079 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32080 PyObject *resultobj = 0;
32081 wxDataObject *arg1 = (wxDataObject *) 0 ;
32082 void *argp1 = 0 ;
32083 int res1 = 0 ;
32084 PyObject *swig_obj[1] ;
32085
32086 if (!args) SWIG_fail;
32087 swig_obj[0] = args;
32088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32089 if (!SWIG_IsOK(res1)) {
32090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32091 }
32092 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 delete arg1;
32096
32097 wxPyEndAllowThreads(__tstate);
32098 if (PyErr_Occurred()) SWIG_fail;
32099 }
32100 resultobj = SWIG_Py_Void();
32101 return resultobj;
32102 fail:
32103 return NULL;
32104 }
32105
32106
32107 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32108 PyObject *resultobj = 0;
32109 wxDataObject *arg1 = (wxDataObject *) 0 ;
32110 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32111 SwigValueWrapper<wxDataFormat > result;
32112 void *argp1 = 0 ;
32113 int res1 = 0 ;
32114 int val2 ;
32115 int ecode2 = 0 ;
32116 PyObject * obj0 = 0 ;
32117 PyObject * obj1 = 0 ;
32118 char * kwnames[] = {
32119 (char *) "self",(char *) "dir", NULL
32120 };
32121
32122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32124 if (!SWIG_IsOK(res1)) {
32125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32126 }
32127 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32128 if (obj1) {
32129 ecode2 = SWIG_AsVal_int(obj1, &val2);
32130 if (!SWIG_IsOK(ecode2)) {
32131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32132 }
32133 arg2 = static_cast< wxDataObject::Direction >(val2);
32134 }
32135 {
32136 PyThreadState* __tstate = wxPyBeginAllowThreads();
32137 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32138 wxPyEndAllowThreads(__tstate);
32139 if (PyErr_Occurred()) SWIG_fail;
32140 }
32141 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32142 return resultobj;
32143 fail:
32144 return NULL;
32145 }
32146
32147
32148 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32149 PyObject *resultobj = 0;
32150 wxDataObject *arg1 = (wxDataObject *) 0 ;
32151 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32152 size_t result;
32153 void *argp1 = 0 ;
32154 int res1 = 0 ;
32155 int val2 ;
32156 int ecode2 = 0 ;
32157 PyObject * obj0 = 0 ;
32158 PyObject * obj1 = 0 ;
32159 char * kwnames[] = {
32160 (char *) "self",(char *) "dir", NULL
32161 };
32162
32163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32165 if (!SWIG_IsOK(res1)) {
32166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32167 }
32168 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32169 if (obj1) {
32170 ecode2 = SWIG_AsVal_int(obj1, &val2);
32171 if (!SWIG_IsOK(ecode2)) {
32172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32173 }
32174 arg2 = static_cast< wxDataObject::Direction >(val2);
32175 }
32176 {
32177 PyThreadState* __tstate = wxPyBeginAllowThreads();
32178 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32179 wxPyEndAllowThreads(__tstate);
32180 if (PyErr_Occurred()) SWIG_fail;
32181 }
32182 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32183 return resultobj;
32184 fail:
32185 return NULL;
32186 }
32187
32188
32189 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32190 PyObject *resultobj = 0;
32191 wxDataObject *arg1 = (wxDataObject *) 0 ;
32192 wxDataFormat *arg2 = 0 ;
32193 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32194 bool result;
32195 void *argp1 = 0 ;
32196 int res1 = 0 ;
32197 void *argp2 = 0 ;
32198 int res2 = 0 ;
32199 int val3 ;
32200 int ecode3 = 0 ;
32201 PyObject * obj0 = 0 ;
32202 PyObject * obj1 = 0 ;
32203 PyObject * obj2 = 0 ;
32204 char * kwnames[] = {
32205 (char *) "self",(char *) "format",(char *) "dir", NULL
32206 };
32207
32208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32210 if (!SWIG_IsOK(res1)) {
32211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32212 }
32213 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32214 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32215 if (!SWIG_IsOK(res2)) {
32216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32217 }
32218 if (!argp2) {
32219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32220 }
32221 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32222 if (obj2) {
32223 ecode3 = SWIG_AsVal_int(obj2, &val3);
32224 if (!SWIG_IsOK(ecode3)) {
32225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32226 }
32227 arg3 = static_cast< wxDataObject::Direction >(val3);
32228 }
32229 {
32230 PyThreadState* __tstate = wxPyBeginAllowThreads();
32231 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32232 wxPyEndAllowThreads(__tstate);
32233 if (PyErr_Occurred()) SWIG_fail;
32234 }
32235 {
32236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32237 }
32238 return resultobj;
32239 fail:
32240 return NULL;
32241 }
32242
32243
32244 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32245 PyObject *resultobj = 0;
32246 wxDataObject *arg1 = (wxDataObject *) 0 ;
32247 wxDataFormat *arg2 = 0 ;
32248 size_t result;
32249 void *argp1 = 0 ;
32250 int res1 = 0 ;
32251 void *argp2 = 0 ;
32252 int res2 = 0 ;
32253 PyObject * obj0 = 0 ;
32254 PyObject * obj1 = 0 ;
32255 char * kwnames[] = {
32256 (char *) "self",(char *) "format", NULL
32257 };
32258
32259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32261 if (!SWIG_IsOK(res1)) {
32262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32263 }
32264 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32265 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32266 if (!SWIG_IsOK(res2)) {
32267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32268 }
32269 if (!argp2) {
32270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32271 }
32272 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32273 {
32274 PyThreadState* __tstate = wxPyBeginAllowThreads();
32275 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32276 wxPyEndAllowThreads(__tstate);
32277 if (PyErr_Occurred()) SWIG_fail;
32278 }
32279 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32280 return resultobj;
32281 fail:
32282 return NULL;
32283 }
32284
32285
32286 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32287 PyObject *resultobj = 0;
32288 wxDataObject *arg1 = (wxDataObject *) 0 ;
32289 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32290 PyObject *result = 0 ;
32291 void *argp1 = 0 ;
32292 int res1 = 0 ;
32293 int val2 ;
32294 int ecode2 = 0 ;
32295 PyObject * obj0 = 0 ;
32296 PyObject * obj1 = 0 ;
32297 char * kwnames[] = {
32298 (char *) "self",(char *) "dir", NULL
32299 };
32300
32301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32303 if (!SWIG_IsOK(res1)) {
32304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32305 }
32306 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32307 if (obj1) {
32308 ecode2 = SWIG_AsVal_int(obj1, &val2);
32309 if (!SWIG_IsOK(ecode2)) {
32310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32311 }
32312 arg2 = static_cast< wxDataObject::Direction >(val2);
32313 }
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 resultobj = result;
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32328 PyObject *resultobj = 0;
32329 wxDataObject *arg1 = (wxDataObject *) 0 ;
32330 wxDataFormat *arg2 = 0 ;
32331 PyObject *result = 0 ;
32332 void *argp1 = 0 ;
32333 int res1 = 0 ;
32334 void *argp2 = 0 ;
32335 int res2 = 0 ;
32336 PyObject * obj0 = 0 ;
32337 PyObject * obj1 = 0 ;
32338 char * kwnames[] = {
32339 (char *) "self",(char *) "format", NULL
32340 };
32341
32342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32344 if (!SWIG_IsOK(res1)) {
32345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32346 }
32347 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32349 if (!SWIG_IsOK(res2)) {
32350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32351 }
32352 if (!argp2) {
32353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32354 }
32355 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32356 {
32357 PyThreadState* __tstate = wxPyBeginAllowThreads();
32358 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32359 wxPyEndAllowThreads(__tstate);
32360 if (PyErr_Occurred()) SWIG_fail;
32361 }
32362 resultobj = result;
32363 return resultobj;
32364 fail:
32365 return NULL;
32366 }
32367
32368
32369 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32370 PyObject *resultobj = 0;
32371 wxDataObject *arg1 = (wxDataObject *) 0 ;
32372 wxDataFormat *arg2 = 0 ;
32373 PyObject *arg3 = (PyObject *) 0 ;
32374 bool result;
32375 void *argp1 = 0 ;
32376 int res1 = 0 ;
32377 void *argp2 = 0 ;
32378 int res2 = 0 ;
32379 PyObject * obj0 = 0 ;
32380 PyObject * obj1 = 0 ;
32381 PyObject * obj2 = 0 ;
32382 char * kwnames[] = {
32383 (char *) "self",(char *) "format",(char *) "data", NULL
32384 };
32385
32386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32388 if (!SWIG_IsOK(res1)) {
32389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32390 }
32391 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32392 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32393 if (!SWIG_IsOK(res2)) {
32394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32395 }
32396 if (!argp2) {
32397 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32398 }
32399 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32400 arg3 = obj2;
32401 {
32402 PyThreadState* __tstate = wxPyBeginAllowThreads();
32403 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32404 wxPyEndAllowThreads(__tstate);
32405 if (PyErr_Occurred()) SWIG_fail;
32406 }
32407 {
32408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32409 }
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32417 PyObject *obj;
32418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32419 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32420 return SWIG_Py_Void();
32421 }
32422
32423 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32424 PyObject *resultobj = 0;
32425 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32426 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32427 wxDataObjectSimple *result = 0 ;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 PyObject * obj0 = 0 ;
32431 char * kwnames[] = {
32432 (char *) "format", NULL
32433 };
32434
32435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32436 if (obj0) {
32437 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32440 }
32441 if (!argp1) {
32442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32443 }
32444 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32445 }
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32449 wxPyEndAllowThreads(__tstate);
32450 if (PyErr_Occurred()) SWIG_fail;
32451 }
32452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32453 return resultobj;
32454 fail:
32455 return NULL;
32456 }
32457
32458
32459 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32460 PyObject *resultobj = 0;
32461 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32462 wxDataFormat *result = 0 ;
32463 void *argp1 = 0 ;
32464 int res1 = 0 ;
32465 PyObject *swig_obj[1] ;
32466
32467 if (!args) SWIG_fail;
32468 swig_obj[0] = args;
32469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32470 if (!SWIG_IsOK(res1)) {
32471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32472 }
32473 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 {
32477 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32478 result = (wxDataFormat *) &_result_ref;
32479 }
32480 wxPyEndAllowThreads(__tstate);
32481 if (PyErr_Occurred()) SWIG_fail;
32482 }
32483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32484 return resultobj;
32485 fail:
32486 return NULL;
32487 }
32488
32489
32490 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32491 PyObject *resultobj = 0;
32492 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32493 wxDataFormat *arg2 = 0 ;
32494 void *argp1 = 0 ;
32495 int res1 = 0 ;
32496 void *argp2 = 0 ;
32497 int res2 = 0 ;
32498 PyObject * obj0 = 0 ;
32499 PyObject * obj1 = 0 ;
32500 char * kwnames[] = {
32501 (char *) "self",(char *) "format", NULL
32502 };
32503
32504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32506 if (!SWIG_IsOK(res1)) {
32507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32508 }
32509 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32511 if (!SWIG_IsOK(res2)) {
32512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32513 }
32514 if (!argp2) {
32515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32516 }
32517 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32518 {
32519 PyThreadState* __tstate = wxPyBeginAllowThreads();
32520 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32521 wxPyEndAllowThreads(__tstate);
32522 if (PyErr_Occurred()) SWIG_fail;
32523 }
32524 resultobj = SWIG_Py_Void();
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32532 PyObject *resultobj = 0;
32533 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32534 size_t result;
32535 void *argp1 = 0 ;
32536 int res1 = 0 ;
32537 PyObject *swig_obj[1] ;
32538
32539 if (!args) SWIG_fail;
32540 swig_obj[0] = args;
32541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32542 if (!SWIG_IsOK(res1)) {
32543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32544 }
32545 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32546 {
32547 PyThreadState* __tstate = wxPyBeginAllowThreads();
32548 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32553 return resultobj;
32554 fail:
32555 return NULL;
32556 }
32557
32558
32559 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32560 PyObject *resultobj = 0;
32561 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32562 PyObject *result = 0 ;
32563 void *argp1 = 0 ;
32564 int res1 = 0 ;
32565 PyObject *swig_obj[1] ;
32566
32567 if (!args) SWIG_fail;
32568 swig_obj[0] = args;
32569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32570 if (!SWIG_IsOK(res1)) {
32571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32572 }
32573 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32574 {
32575 PyThreadState* __tstate = wxPyBeginAllowThreads();
32576 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32577 wxPyEndAllowThreads(__tstate);
32578 if (PyErr_Occurred()) SWIG_fail;
32579 }
32580 resultobj = result;
32581 return resultobj;
32582 fail:
32583 return NULL;
32584 }
32585
32586
32587 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32588 PyObject *resultobj = 0;
32589 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32590 PyObject *arg2 = (PyObject *) 0 ;
32591 bool result;
32592 void *argp1 = 0 ;
32593 int res1 = 0 ;
32594 PyObject * obj0 = 0 ;
32595 PyObject * obj1 = 0 ;
32596 char * kwnames[] = {
32597 (char *) "self",(char *) "data", NULL
32598 };
32599
32600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32602 if (!SWIG_IsOK(res1)) {
32603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32604 }
32605 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32606 arg2 = obj1;
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 {
32614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32615 }
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32623 PyObject *obj;
32624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32625 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32626 return SWIG_Py_Void();
32627 }
32628
32629 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32630 return SWIG_Python_InitShadowInstance(args);
32631 }
32632
32633 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32634 PyObject *resultobj = 0;
32635 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32636 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32637 wxPyDataObjectSimple *result = 0 ;
32638 void *argp1 = 0 ;
32639 int res1 = 0 ;
32640 PyObject * obj0 = 0 ;
32641 char * kwnames[] = {
32642 (char *) "format", NULL
32643 };
32644
32645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32646 if (obj0) {
32647 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32648 if (!SWIG_IsOK(res1)) {
32649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32650 }
32651 if (!argp1) {
32652 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32653 }
32654 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32655 }
32656 {
32657 PyThreadState* __tstate = wxPyBeginAllowThreads();
32658 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32659 wxPyEndAllowThreads(__tstate);
32660 if (PyErr_Occurred()) SWIG_fail;
32661 }
32662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32663 return resultobj;
32664 fail:
32665 return NULL;
32666 }
32667
32668
32669 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32670 PyObject *resultobj = 0;
32671 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32672 PyObject *arg2 = (PyObject *) 0 ;
32673 PyObject *arg3 = (PyObject *) 0 ;
32674 void *argp1 = 0 ;
32675 int res1 = 0 ;
32676 PyObject * obj0 = 0 ;
32677 PyObject * obj1 = 0 ;
32678 PyObject * obj2 = 0 ;
32679 char * kwnames[] = {
32680 (char *) "self",(char *) "self",(char *) "_class", NULL
32681 };
32682
32683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32685 if (!SWIG_IsOK(res1)) {
32686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32687 }
32688 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32689 arg2 = obj1;
32690 arg3 = obj2;
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 (arg1)->_setCallbackInfo(arg2,arg3);
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 resultobj = SWIG_Py_Void();
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32705 PyObject *obj;
32706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32707 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32708 return SWIG_Py_Void();
32709 }
32710
32711 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32712 return SWIG_Python_InitShadowInstance(args);
32713 }
32714
32715 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32716 PyObject *resultobj = 0;
32717 wxDataObjectComposite *result = 0 ;
32718
32719 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32720 {
32721 PyThreadState* __tstate = wxPyBeginAllowThreads();
32722 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32723 wxPyEndAllowThreads(__tstate);
32724 if (PyErr_Occurred()) SWIG_fail;
32725 }
32726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32727 return resultobj;
32728 fail:
32729 return NULL;
32730 }
32731
32732
32733 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32734 PyObject *resultobj = 0;
32735 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32736 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32737 bool arg3 = (bool) false ;
32738 void *argp1 = 0 ;
32739 int res1 = 0 ;
32740 int res2 = 0 ;
32741 bool val3 ;
32742 int ecode3 = 0 ;
32743 PyObject * obj0 = 0 ;
32744 PyObject * obj1 = 0 ;
32745 PyObject * obj2 = 0 ;
32746 char * kwnames[] = {
32747 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32748 };
32749
32750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32752 if (!SWIG_IsOK(res1)) {
32753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32754 }
32755 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32756 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32757 if (!SWIG_IsOK(res2)) {
32758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32759 }
32760 if (obj2) {
32761 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32762 if (!SWIG_IsOK(ecode3)) {
32763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32764 }
32765 arg3 = static_cast< bool >(val3);
32766 }
32767 {
32768 PyThreadState* __tstate = wxPyBeginAllowThreads();
32769 (arg1)->Add(arg2,arg3);
32770 wxPyEndAllowThreads(__tstate);
32771 if (PyErr_Occurred()) SWIG_fail;
32772 }
32773 resultobj = SWIG_Py_Void();
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32781 PyObject *resultobj = 0;
32782 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32783 SwigValueWrapper<wxDataFormat > result;
32784 void *argp1 = 0 ;
32785 int res1 = 0 ;
32786 PyObject *swig_obj[1] ;
32787
32788 if (!args) SWIG_fail;
32789 swig_obj[0] = args;
32790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32791 if (!SWIG_IsOK(res1)) {
32792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32793 }
32794 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32795 {
32796 PyThreadState* __tstate = wxPyBeginAllowThreads();
32797 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32798 wxPyEndAllowThreads(__tstate);
32799 if (PyErr_Occurred()) SWIG_fail;
32800 }
32801 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32802 return resultobj;
32803 fail:
32804 return NULL;
32805 }
32806
32807
32808 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32809 PyObject *obj;
32810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32811 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32812 return SWIG_Py_Void();
32813 }
32814
32815 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32816 return SWIG_Python_InitShadowInstance(args);
32817 }
32818
32819 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32820 PyObject *resultobj = 0;
32821 wxString const &arg1_defvalue = wxPyEmptyString ;
32822 wxString *arg1 = (wxString *) &arg1_defvalue ;
32823 wxTextDataObject *result = 0 ;
32824 bool temp1 = false ;
32825 PyObject * obj0 = 0 ;
32826 char * kwnames[] = {
32827 (char *) "text", NULL
32828 };
32829
32830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32831 if (obj0) {
32832 {
32833 arg1 = wxString_in_helper(obj0);
32834 if (arg1 == NULL) SWIG_fail;
32835 temp1 = true;
32836 }
32837 }
32838 {
32839 PyThreadState* __tstate = wxPyBeginAllowThreads();
32840 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32841 wxPyEndAllowThreads(__tstate);
32842 if (PyErr_Occurred()) SWIG_fail;
32843 }
32844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32845 {
32846 if (temp1)
32847 delete arg1;
32848 }
32849 return resultobj;
32850 fail:
32851 {
32852 if (temp1)
32853 delete arg1;
32854 }
32855 return NULL;
32856 }
32857
32858
32859 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32860 PyObject *resultobj = 0;
32861 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32862 size_t result;
32863 void *argp1 = 0 ;
32864 int res1 = 0 ;
32865 PyObject *swig_obj[1] ;
32866
32867 if (!args) SWIG_fail;
32868 swig_obj[0] = args;
32869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32870 if (!SWIG_IsOK(res1)) {
32871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32872 }
32873 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32874 {
32875 PyThreadState* __tstate = wxPyBeginAllowThreads();
32876 result = (size_t)(arg1)->GetTextLength();
32877 wxPyEndAllowThreads(__tstate);
32878 if (PyErr_Occurred()) SWIG_fail;
32879 }
32880 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32881 return resultobj;
32882 fail:
32883 return NULL;
32884 }
32885
32886
32887 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32888 PyObject *resultobj = 0;
32889 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32890 wxString result;
32891 void *argp1 = 0 ;
32892 int res1 = 0 ;
32893 PyObject *swig_obj[1] ;
32894
32895 if (!args) SWIG_fail;
32896 swig_obj[0] = args;
32897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32898 if (!SWIG_IsOK(res1)) {
32899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32900 }
32901 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32902 {
32903 PyThreadState* __tstate = wxPyBeginAllowThreads();
32904 result = (arg1)->GetText();
32905 wxPyEndAllowThreads(__tstate);
32906 if (PyErr_Occurred()) SWIG_fail;
32907 }
32908 {
32909 #if wxUSE_UNICODE
32910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32911 #else
32912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32913 #endif
32914 }
32915 return resultobj;
32916 fail:
32917 return NULL;
32918 }
32919
32920
32921 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32922 PyObject *resultobj = 0;
32923 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32924 wxString *arg2 = 0 ;
32925 void *argp1 = 0 ;
32926 int res1 = 0 ;
32927 bool temp2 = false ;
32928 PyObject * obj0 = 0 ;
32929 PyObject * obj1 = 0 ;
32930 char * kwnames[] = {
32931 (char *) "self",(char *) "text", NULL
32932 };
32933
32934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32936 if (!SWIG_IsOK(res1)) {
32937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32938 }
32939 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32940 {
32941 arg2 = wxString_in_helper(obj1);
32942 if (arg2 == NULL) SWIG_fail;
32943 temp2 = true;
32944 }
32945 {
32946 PyThreadState* __tstate = wxPyBeginAllowThreads();
32947 (arg1)->SetText((wxString const &)*arg2);
32948 wxPyEndAllowThreads(__tstate);
32949 if (PyErr_Occurred()) SWIG_fail;
32950 }
32951 resultobj = SWIG_Py_Void();
32952 {
32953 if (temp2)
32954 delete arg2;
32955 }
32956 return resultobj;
32957 fail:
32958 {
32959 if (temp2)
32960 delete arg2;
32961 }
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *obj;
32968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32969 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32970 return SWIG_Py_Void();
32971 }
32972
32973 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32974 return SWIG_Python_InitShadowInstance(args);
32975 }
32976
32977 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32978 PyObject *resultobj = 0;
32979 wxString const &arg1_defvalue = wxPyEmptyString ;
32980 wxString *arg1 = (wxString *) &arg1_defvalue ;
32981 wxPyTextDataObject *result = 0 ;
32982 bool temp1 = false ;
32983 PyObject * obj0 = 0 ;
32984 char * kwnames[] = {
32985 (char *) "text", NULL
32986 };
32987
32988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32989 if (obj0) {
32990 {
32991 arg1 = wxString_in_helper(obj0);
32992 if (arg1 == NULL) SWIG_fail;
32993 temp1 = true;
32994 }
32995 }
32996 {
32997 PyThreadState* __tstate = wxPyBeginAllowThreads();
32998 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
33003 {
33004 if (temp1)
33005 delete arg1;
33006 }
33007 return resultobj;
33008 fail:
33009 {
33010 if (temp1)
33011 delete arg1;
33012 }
33013 return NULL;
33014 }
33015
33016
33017 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33018 PyObject *resultobj = 0;
33019 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
33020 PyObject *arg2 = (PyObject *) 0 ;
33021 PyObject *arg3 = (PyObject *) 0 ;
33022 void *argp1 = 0 ;
33023 int res1 = 0 ;
33024 PyObject * obj0 = 0 ;
33025 PyObject * obj1 = 0 ;
33026 PyObject * obj2 = 0 ;
33027 char * kwnames[] = {
33028 (char *) "self",(char *) "self",(char *) "_class", NULL
33029 };
33030
33031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
33035 }
33036 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
33037 arg2 = obj1;
33038 arg3 = obj2;
33039 {
33040 PyThreadState* __tstate = wxPyBeginAllowThreads();
33041 (arg1)->_setCallbackInfo(arg2,arg3);
33042 wxPyEndAllowThreads(__tstate);
33043 if (PyErr_Occurred()) SWIG_fail;
33044 }
33045 resultobj = SWIG_Py_Void();
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33053 PyObject *obj;
33054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33055 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
33056 return SWIG_Py_Void();
33057 }
33058
33059 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33060 return SWIG_Python_InitShadowInstance(args);
33061 }
33062
33063 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33064 PyObject *resultobj = 0;
33065 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33066 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33067 wxBitmapDataObject *result = 0 ;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 PyObject * obj0 = 0 ;
33071 char * kwnames[] = {
33072 (char *) "bitmap", NULL
33073 };
33074
33075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33076 if (obj0) {
33077 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33078 if (!SWIG_IsOK(res1)) {
33079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33080 }
33081 if (!argp1) {
33082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33083 }
33084 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33085 }
33086 {
33087 PyThreadState* __tstate = wxPyBeginAllowThreads();
33088 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33089 wxPyEndAllowThreads(__tstate);
33090 if (PyErr_Occurred()) SWIG_fail;
33091 }
33092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33093 return resultobj;
33094 fail:
33095 return NULL;
33096 }
33097
33098
33099 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33100 PyObject *resultobj = 0;
33101 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33102 wxBitmap result;
33103 void *argp1 = 0 ;
33104 int res1 = 0 ;
33105 PyObject *swig_obj[1] ;
33106
33107 if (!args) SWIG_fail;
33108 swig_obj[0] = args;
33109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33110 if (!SWIG_IsOK(res1)) {
33111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33112 }
33113 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33114 {
33115 PyThreadState* __tstate = wxPyBeginAllowThreads();
33116 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33117 wxPyEndAllowThreads(__tstate);
33118 if (PyErr_Occurred()) SWIG_fail;
33119 }
33120 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33121 return resultobj;
33122 fail:
33123 return NULL;
33124 }
33125
33126
33127 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33128 PyObject *resultobj = 0;
33129 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33130 wxBitmap *arg2 = 0 ;
33131 void *argp1 = 0 ;
33132 int res1 = 0 ;
33133 void *argp2 = 0 ;
33134 int res2 = 0 ;
33135 PyObject * obj0 = 0 ;
33136 PyObject * obj1 = 0 ;
33137 char * kwnames[] = {
33138 (char *) "self",(char *) "bitmap", NULL
33139 };
33140
33141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33143 if (!SWIG_IsOK(res1)) {
33144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33145 }
33146 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33148 if (!SWIG_IsOK(res2)) {
33149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33150 }
33151 if (!argp2) {
33152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33153 }
33154 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 resultobj = SWIG_Py_Void();
33162 return resultobj;
33163 fail:
33164 return NULL;
33165 }
33166
33167
33168 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33169 PyObject *obj;
33170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33171 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33172 return SWIG_Py_Void();
33173 }
33174
33175 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33176 return SWIG_Python_InitShadowInstance(args);
33177 }
33178
33179 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33180 PyObject *resultobj = 0;
33181 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33182 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33183 wxPyBitmapDataObject *result = 0 ;
33184 void *argp1 = 0 ;
33185 int res1 = 0 ;
33186 PyObject * obj0 = 0 ;
33187 char * kwnames[] = {
33188 (char *) "bitmap", NULL
33189 };
33190
33191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33192 if (obj0) {
33193 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33194 if (!SWIG_IsOK(res1)) {
33195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33196 }
33197 if (!argp1) {
33198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33199 }
33200 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33201 }
33202 {
33203 PyThreadState* __tstate = wxPyBeginAllowThreads();
33204 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33205 wxPyEndAllowThreads(__tstate);
33206 if (PyErr_Occurred()) SWIG_fail;
33207 }
33208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33209 return resultobj;
33210 fail:
33211 return NULL;
33212 }
33213
33214
33215 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33216 PyObject *resultobj = 0;
33217 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33218 PyObject *arg2 = (PyObject *) 0 ;
33219 PyObject *arg3 = (PyObject *) 0 ;
33220 void *argp1 = 0 ;
33221 int res1 = 0 ;
33222 PyObject * obj0 = 0 ;
33223 PyObject * obj1 = 0 ;
33224 PyObject * obj2 = 0 ;
33225 char * kwnames[] = {
33226 (char *) "self",(char *) "self",(char *) "_class", NULL
33227 };
33228
33229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33231 if (!SWIG_IsOK(res1)) {
33232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33233 }
33234 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33235 arg2 = obj1;
33236 arg3 = obj2;
33237 {
33238 PyThreadState* __tstate = wxPyBeginAllowThreads();
33239 (arg1)->_setCallbackInfo(arg2,arg3);
33240 wxPyEndAllowThreads(__tstate);
33241 if (PyErr_Occurred()) SWIG_fail;
33242 }
33243 resultobj = SWIG_Py_Void();
33244 return resultobj;
33245 fail:
33246 return NULL;
33247 }
33248
33249
33250 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33251 PyObject *obj;
33252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33253 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33254 return SWIG_Py_Void();
33255 }
33256
33257 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33258 return SWIG_Python_InitShadowInstance(args);
33259 }
33260
33261 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33262 PyObject *resultobj = 0;
33263 wxFileDataObject *result = 0 ;
33264
33265 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33266 {
33267 PyThreadState* __tstate = wxPyBeginAllowThreads();
33268 result = (wxFileDataObject *)new wxFileDataObject();
33269 wxPyEndAllowThreads(__tstate);
33270 if (PyErr_Occurred()) SWIG_fail;
33271 }
33272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33280 PyObject *resultobj = 0;
33281 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33282 wxArrayString *result = 0 ;
33283 void *argp1 = 0 ;
33284 int res1 = 0 ;
33285 PyObject *swig_obj[1] ;
33286
33287 if (!args) SWIG_fail;
33288 swig_obj[0] = args;
33289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33292 }
33293 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33294 {
33295 PyThreadState* __tstate = wxPyBeginAllowThreads();
33296 {
33297 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33298 result = (wxArrayString *) &_result_ref;
33299 }
33300 wxPyEndAllowThreads(__tstate);
33301 if (PyErr_Occurred()) SWIG_fail;
33302 }
33303 {
33304 resultobj = wxArrayString2PyList_helper(*result);
33305 }
33306 return resultobj;
33307 fail:
33308 return NULL;
33309 }
33310
33311
33312 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33313 PyObject *resultobj = 0;
33314 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33315 wxString *arg2 = 0 ;
33316 void *argp1 = 0 ;
33317 int res1 = 0 ;
33318 bool temp2 = false ;
33319 PyObject * obj0 = 0 ;
33320 PyObject * obj1 = 0 ;
33321 char * kwnames[] = {
33322 (char *) "self",(char *) "filename", NULL
33323 };
33324
33325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33327 if (!SWIG_IsOK(res1)) {
33328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33329 }
33330 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33331 {
33332 arg2 = wxString_in_helper(obj1);
33333 if (arg2 == NULL) SWIG_fail;
33334 temp2 = true;
33335 }
33336 {
33337 PyThreadState* __tstate = wxPyBeginAllowThreads();
33338 (arg1)->AddFile((wxString const &)*arg2);
33339 wxPyEndAllowThreads(__tstate);
33340 if (PyErr_Occurred()) SWIG_fail;
33341 }
33342 resultobj = SWIG_Py_Void();
33343 {
33344 if (temp2)
33345 delete arg2;
33346 }
33347 return resultobj;
33348 fail:
33349 {
33350 if (temp2)
33351 delete arg2;
33352 }
33353 return NULL;
33354 }
33355
33356
33357 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33358 PyObject *obj;
33359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33360 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33361 return SWIG_Py_Void();
33362 }
33363
33364 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33365 return SWIG_Python_InitShadowInstance(args);
33366 }
33367
33368 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33369 PyObject *resultobj = 0;
33370 wxDataFormat *arg1 = 0 ;
33371 wxCustomDataObject *result = 0 ;
33372 void *argp1 = 0 ;
33373 int res1 = 0 ;
33374
33375 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33377 if (!SWIG_IsOK(res1)) {
33378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33379 }
33380 if (!argp1) {
33381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33382 }
33383 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33384 {
33385 PyThreadState* __tstate = wxPyBeginAllowThreads();
33386 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33387 wxPyEndAllowThreads(__tstate);
33388 if (PyErr_Occurred()) SWIG_fail;
33389 }
33390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33391 return resultobj;
33392 fail:
33393 return NULL;
33394 }
33395
33396
33397 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33398 PyObject *resultobj = 0;
33399 wxString *arg1 = 0 ;
33400 wxCustomDataObject *result = 0 ;
33401 bool temp1 = false ;
33402
33403 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33404 {
33405 arg1 = wxString_in_helper(swig_obj[0]);
33406 if (arg1 == NULL) SWIG_fail;
33407 temp1 = true;
33408 }
33409 {
33410 PyThreadState* __tstate = wxPyBeginAllowThreads();
33411 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33412 wxPyEndAllowThreads(__tstate);
33413 if (PyErr_Occurred()) SWIG_fail;
33414 }
33415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33416 {
33417 if (temp1)
33418 delete arg1;
33419 }
33420 return resultobj;
33421 fail:
33422 {
33423 if (temp1)
33424 delete arg1;
33425 }
33426 return NULL;
33427 }
33428
33429
33430 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33431 PyObject *resultobj = 0;
33432 wxCustomDataObject *result = 0 ;
33433
33434 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33435 {
33436 PyThreadState* __tstate = wxPyBeginAllowThreads();
33437 result = (wxCustomDataObject *)new wxCustomDataObject();
33438 wxPyEndAllowThreads(__tstate);
33439 if (PyErr_Occurred()) SWIG_fail;
33440 }
33441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33442 return resultobj;
33443 fail:
33444 return NULL;
33445 }
33446
33447
33448 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33449 int argc;
33450 PyObject *argv[2];
33451
33452 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33453 --argc;
33454 if (argc == 0) {
33455 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33456 }
33457 if (argc == 1) {
33458 int _v = 0;
33459 {
33460 {
33461 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33462 }
33463 }
33464 if (!_v) goto check_2;
33465 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33466 }
33467 check_2:
33468
33469 if (argc == 1) {
33470 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33471 }
33472
33473 fail:
33474 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33475 return NULL;
33476 }
33477
33478
33479 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33480 PyObject *resultobj = 0;
33481 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33482 PyObject *arg2 = (PyObject *) 0 ;
33483 bool result;
33484 void *argp1 = 0 ;
33485 int res1 = 0 ;
33486 PyObject * obj0 = 0 ;
33487 PyObject * obj1 = 0 ;
33488 char * kwnames[] = {
33489 (char *) "self",(char *) "data", NULL
33490 };
33491
33492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33494 if (!SWIG_IsOK(res1)) {
33495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33496 }
33497 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33498 arg2 = obj1;
33499 {
33500 PyThreadState* __tstate = wxPyBeginAllowThreads();
33501 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33502 wxPyEndAllowThreads(__tstate);
33503 if (PyErr_Occurred()) SWIG_fail;
33504 }
33505 {
33506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33507 }
33508 return resultobj;
33509 fail:
33510 return NULL;
33511 }
33512
33513
33514 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33515 PyObject *resultobj = 0;
33516 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33517 size_t result;
33518 void *argp1 = 0 ;
33519 int res1 = 0 ;
33520 PyObject *swig_obj[1] ;
33521
33522 if (!args) SWIG_fail;
33523 swig_obj[0] = args;
33524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33525 if (!SWIG_IsOK(res1)) {
33526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33527 }
33528 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33529 {
33530 PyThreadState* __tstate = wxPyBeginAllowThreads();
33531 result = (size_t)(arg1)->GetSize();
33532 wxPyEndAllowThreads(__tstate);
33533 if (PyErr_Occurred()) SWIG_fail;
33534 }
33535 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33536 return resultobj;
33537 fail:
33538 return NULL;
33539 }
33540
33541
33542 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33543 PyObject *resultobj = 0;
33544 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33545 PyObject *result = 0 ;
33546 void *argp1 = 0 ;
33547 int res1 = 0 ;
33548 PyObject *swig_obj[1] ;
33549
33550 if (!args) SWIG_fail;
33551 swig_obj[0] = args;
33552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33553 if (!SWIG_IsOK(res1)) {
33554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33555 }
33556 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33557 {
33558 PyThreadState* __tstate = wxPyBeginAllowThreads();
33559 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33560 wxPyEndAllowThreads(__tstate);
33561 if (PyErr_Occurred()) SWIG_fail;
33562 }
33563 resultobj = result;
33564 return resultobj;
33565 fail:
33566 return NULL;
33567 }
33568
33569
33570 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33571 PyObject *obj;
33572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33573 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33574 return SWIG_Py_Void();
33575 }
33576
33577 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33578 return SWIG_Python_InitShadowInstance(args);
33579 }
33580
33581 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33582 PyObject *resultobj = 0;
33583 wxString const &arg1_defvalue = wxPyEmptyString ;
33584 wxString *arg1 = (wxString *) &arg1_defvalue ;
33585 wxURLDataObject *result = 0 ;
33586 bool temp1 = false ;
33587 PyObject * obj0 = 0 ;
33588 char * kwnames[] = {
33589 (char *) "url", NULL
33590 };
33591
33592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33593 if (obj0) {
33594 {
33595 arg1 = wxString_in_helper(obj0);
33596 if (arg1 == NULL) SWIG_fail;
33597 temp1 = true;
33598 }
33599 }
33600 {
33601 PyThreadState* __tstate = wxPyBeginAllowThreads();
33602 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33607 {
33608 if (temp1)
33609 delete arg1;
33610 }
33611 return resultobj;
33612 fail:
33613 {
33614 if (temp1)
33615 delete arg1;
33616 }
33617 return NULL;
33618 }
33619
33620
33621 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33622 PyObject *resultobj = 0;
33623 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33624 wxString result;
33625 void *argp1 = 0 ;
33626 int res1 = 0 ;
33627 PyObject *swig_obj[1] ;
33628
33629 if (!args) SWIG_fail;
33630 swig_obj[0] = args;
33631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33632 if (!SWIG_IsOK(res1)) {
33633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33634 }
33635 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33636 {
33637 PyThreadState* __tstate = wxPyBeginAllowThreads();
33638 result = (arg1)->GetURL();
33639 wxPyEndAllowThreads(__tstate);
33640 if (PyErr_Occurred()) SWIG_fail;
33641 }
33642 {
33643 #if wxUSE_UNICODE
33644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33645 #else
33646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33647 #endif
33648 }
33649 return resultobj;
33650 fail:
33651 return NULL;
33652 }
33653
33654
33655 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33656 PyObject *resultobj = 0;
33657 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33658 wxString *arg2 = 0 ;
33659 void *argp1 = 0 ;
33660 int res1 = 0 ;
33661 bool temp2 = false ;
33662 PyObject * obj0 = 0 ;
33663 PyObject * obj1 = 0 ;
33664 char * kwnames[] = {
33665 (char *) "self",(char *) "url", NULL
33666 };
33667
33668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33670 if (!SWIG_IsOK(res1)) {
33671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33672 }
33673 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33674 {
33675 arg2 = wxString_in_helper(obj1);
33676 if (arg2 == NULL) SWIG_fail;
33677 temp2 = true;
33678 }
33679 {
33680 PyThreadState* __tstate = wxPyBeginAllowThreads();
33681 (arg1)->SetURL((wxString const &)*arg2);
33682 wxPyEndAllowThreads(__tstate);
33683 if (PyErr_Occurred()) SWIG_fail;
33684 }
33685 resultobj = SWIG_Py_Void();
33686 {
33687 if (temp2)
33688 delete arg2;
33689 }
33690 return resultobj;
33691 fail:
33692 {
33693 if (temp2)
33694 delete arg2;
33695 }
33696 return NULL;
33697 }
33698
33699
33700 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33701 PyObject *obj;
33702 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33703 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33704 return SWIG_Py_Void();
33705 }
33706
33707 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33708 return SWIG_Python_InitShadowInstance(args);
33709 }
33710
33711 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33712 PyObject *resultobj = 0;
33713 wxMetafileDataObject *result = 0 ;
33714
33715 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33716 {
33717 PyThreadState* __tstate = wxPyBeginAllowThreads();
33718 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33719 wxPyEndAllowThreads(__tstate);
33720 if (PyErr_Occurred()) SWIG_fail;
33721 }
33722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33723 return resultobj;
33724 fail:
33725 return NULL;
33726 }
33727
33728
33729 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33730 PyObject *obj;
33731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33732 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33733 return SWIG_Py_Void();
33734 }
33735
33736 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33737 return SWIG_Python_InitShadowInstance(args);
33738 }
33739
33740 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33741 PyObject *resultobj = 0;
33742 wxDragResult arg1 ;
33743 bool result;
33744 int val1 ;
33745 int ecode1 = 0 ;
33746 PyObject * obj0 = 0 ;
33747 char * kwnames[] = {
33748 (char *) "res", NULL
33749 };
33750
33751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33752 ecode1 = SWIG_AsVal_int(obj0, &val1);
33753 if (!SWIG_IsOK(ecode1)) {
33754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33755 }
33756 arg1 = static_cast< wxDragResult >(val1);
33757 {
33758 PyThreadState* __tstate = wxPyBeginAllowThreads();
33759 result = (bool)wxIsDragResultOk(arg1);
33760 wxPyEndAllowThreads(__tstate);
33761 if (PyErr_Occurred()) SWIG_fail;
33762 }
33763 {
33764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33765 }
33766 return resultobj;
33767 fail:
33768 return NULL;
33769 }
33770
33771
33772 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33773 PyObject *resultobj = 0;
33774 wxWindow *arg1 = (wxWindow *) 0 ;
33775 wxIcon const &arg2_defvalue = wxNullIcon ;
33776 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33777 wxIcon const &arg3_defvalue = wxNullIcon ;
33778 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33779 wxIcon const &arg4_defvalue = wxNullIcon ;
33780 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33781 wxPyDropSource *result = 0 ;
33782 void *argp1 = 0 ;
33783 int res1 = 0 ;
33784 void *argp2 = 0 ;
33785 int res2 = 0 ;
33786 void *argp3 = 0 ;
33787 int res3 = 0 ;
33788 void *argp4 = 0 ;
33789 int res4 = 0 ;
33790 PyObject * obj0 = 0 ;
33791 PyObject * obj1 = 0 ;
33792 PyObject * obj2 = 0 ;
33793 PyObject * obj3 = 0 ;
33794 char * kwnames[] = {
33795 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33796 };
33797
33798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33802 }
33803 arg1 = reinterpret_cast< wxWindow * >(argp1);
33804 if (obj1) {
33805 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33806 if (!SWIG_IsOK(res2)) {
33807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33808 }
33809 if (!argp2) {
33810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33811 }
33812 arg2 = reinterpret_cast< wxIcon * >(argp2);
33813 }
33814 if (obj2) {
33815 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33816 if (!SWIG_IsOK(res3)) {
33817 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33818 }
33819 if (!argp3) {
33820 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33821 }
33822 arg3 = reinterpret_cast< wxIcon * >(argp3);
33823 }
33824 if (obj3) {
33825 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33826 if (!SWIG_IsOK(res4)) {
33827 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33828 }
33829 if (!argp4) {
33830 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33831 }
33832 arg4 = reinterpret_cast< wxIcon * >(argp4);
33833 }
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33837 wxPyEndAllowThreads(__tstate);
33838 if (PyErr_Occurred()) SWIG_fail;
33839 }
33840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33841 return resultobj;
33842 fail:
33843 return NULL;
33844 }
33845
33846
33847 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33848 PyObject *resultobj = 0;
33849 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33850 PyObject *arg2 = (PyObject *) 0 ;
33851 PyObject *arg3 = (PyObject *) 0 ;
33852 int arg4 = (int) 0 ;
33853 void *argp1 = 0 ;
33854 int res1 = 0 ;
33855 int val4 ;
33856 int ecode4 = 0 ;
33857 PyObject * obj0 = 0 ;
33858 PyObject * obj1 = 0 ;
33859 PyObject * obj2 = 0 ;
33860 PyObject * obj3 = 0 ;
33861 char * kwnames[] = {
33862 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33863 };
33864
33865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33867 if (!SWIG_IsOK(res1)) {
33868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33869 }
33870 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33871 arg2 = obj1;
33872 arg3 = obj2;
33873 if (obj3) {
33874 ecode4 = SWIG_AsVal_int(obj3, &val4);
33875 if (!SWIG_IsOK(ecode4)) {
33876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33877 }
33878 arg4 = static_cast< int >(val4);
33879 }
33880 {
33881 PyThreadState* __tstate = wxPyBeginAllowThreads();
33882 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33883 wxPyEndAllowThreads(__tstate);
33884 if (PyErr_Occurred()) SWIG_fail;
33885 }
33886 resultobj = SWIG_Py_Void();
33887 return resultobj;
33888 fail:
33889 return NULL;
33890 }
33891
33892
33893 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33894 PyObject *resultobj = 0;
33895 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33896 void *argp1 = 0 ;
33897 int res1 = 0 ;
33898 PyObject *swig_obj[1] ;
33899
33900 if (!args) SWIG_fail;
33901 swig_obj[0] = args;
33902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33903 if (!SWIG_IsOK(res1)) {
33904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33905 }
33906 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 delete arg1;
33910
33911 wxPyEndAllowThreads(__tstate);
33912 if (PyErr_Occurred()) SWIG_fail;
33913 }
33914 resultobj = SWIG_Py_Void();
33915 return resultobj;
33916 fail:
33917 return NULL;
33918 }
33919
33920
33921 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33922 PyObject *resultobj = 0;
33923 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33924 wxDataObject *arg2 = 0 ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 void *argp2 = 0 ;
33928 int res2 = 0 ;
33929 PyObject * obj0 = 0 ;
33930 PyObject * obj1 = 0 ;
33931 char * kwnames[] = {
33932 (char *) "self",(char *) "data", NULL
33933 };
33934
33935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33937 if (!SWIG_IsOK(res1)) {
33938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33939 }
33940 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33942 if (!SWIG_IsOK(res2)) {
33943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33944 }
33945 if (!argp2) {
33946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33947 }
33948 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33949 {
33950 PyThreadState* __tstate = wxPyBeginAllowThreads();
33951 (arg1)->SetData(*arg2);
33952 wxPyEndAllowThreads(__tstate);
33953 if (PyErr_Occurred()) SWIG_fail;
33954 }
33955 resultobj = SWIG_Py_Void();
33956 return resultobj;
33957 fail:
33958 return NULL;
33959 }
33960
33961
33962 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33963 PyObject *resultobj = 0;
33964 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33965 wxDataObject *result = 0 ;
33966 void *argp1 = 0 ;
33967 int res1 = 0 ;
33968 PyObject *swig_obj[1] ;
33969
33970 if (!args) SWIG_fail;
33971 swig_obj[0] = args;
33972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33973 if (!SWIG_IsOK(res1)) {
33974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33975 }
33976 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33977 {
33978 PyThreadState* __tstate = wxPyBeginAllowThreads();
33979 result = (wxDataObject *)(arg1)->GetDataObject();
33980 wxPyEndAllowThreads(__tstate);
33981 if (PyErr_Occurred()) SWIG_fail;
33982 }
33983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33984 return resultobj;
33985 fail:
33986 return NULL;
33987 }
33988
33989
33990 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33991 PyObject *resultobj = 0;
33992 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33993 wxDragResult arg2 ;
33994 wxCursor *arg3 = 0 ;
33995 void *argp1 = 0 ;
33996 int res1 = 0 ;
33997 int val2 ;
33998 int ecode2 = 0 ;
33999 void *argp3 = 0 ;
34000 int res3 = 0 ;
34001 PyObject * obj0 = 0 ;
34002 PyObject * obj1 = 0 ;
34003 PyObject * obj2 = 0 ;
34004 char * kwnames[] = {
34005 (char *) "self",(char *) "res",(char *) "cursor", NULL
34006 };
34007
34008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34010 if (!SWIG_IsOK(res1)) {
34011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34012 }
34013 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34014 ecode2 = SWIG_AsVal_int(obj1, &val2);
34015 if (!SWIG_IsOK(ecode2)) {
34016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34017 }
34018 arg2 = static_cast< wxDragResult >(val2);
34019 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34020 if (!SWIG_IsOK(res3)) {
34021 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34022 }
34023 if (!argp3) {
34024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34025 }
34026 arg3 = reinterpret_cast< wxCursor * >(argp3);
34027 {
34028 PyThreadState* __tstate = wxPyBeginAllowThreads();
34029 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34030 wxPyEndAllowThreads(__tstate);
34031 if (PyErr_Occurred()) SWIG_fail;
34032 }
34033 resultobj = SWIG_Py_Void();
34034 return resultobj;
34035 fail:
34036 return NULL;
34037 }
34038
34039
34040 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34041 PyObject *resultobj = 0;
34042 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34043 int arg2 = (int) wxDrag_CopyOnly ;
34044 wxDragResult result;
34045 void *argp1 = 0 ;
34046 int res1 = 0 ;
34047 int val2 ;
34048 int ecode2 = 0 ;
34049 PyObject * obj0 = 0 ;
34050 PyObject * obj1 = 0 ;
34051 char * kwnames[] = {
34052 (char *) "self",(char *) "flags", NULL
34053 };
34054
34055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34057 if (!SWIG_IsOK(res1)) {
34058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34059 }
34060 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34061 if (obj1) {
34062 ecode2 = SWIG_AsVal_int(obj1, &val2);
34063 if (!SWIG_IsOK(ecode2)) {
34064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34065 }
34066 arg2 = static_cast< int >(val2);
34067 }
34068 {
34069 PyThreadState* __tstate = wxPyBeginAllowThreads();
34070 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34071 wxPyEndAllowThreads(__tstate);
34072 if (PyErr_Occurred()) SWIG_fail;
34073 }
34074 resultobj = SWIG_From_int(static_cast< int >(result));
34075 return resultobj;
34076 fail:
34077 return NULL;
34078 }
34079
34080
34081 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34082 PyObject *resultobj = 0;
34083 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34084 wxDragResult arg2 ;
34085 bool result;
34086 void *argp1 = 0 ;
34087 int res1 = 0 ;
34088 int val2 ;
34089 int ecode2 = 0 ;
34090 PyObject * obj0 = 0 ;
34091 PyObject * obj1 = 0 ;
34092 char * kwnames[] = {
34093 (char *) "self",(char *) "effect", NULL
34094 };
34095
34096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34098 if (!SWIG_IsOK(res1)) {
34099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34100 }
34101 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34102 ecode2 = SWIG_AsVal_int(obj1, &val2);
34103 if (!SWIG_IsOK(ecode2)) {
34104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34105 }
34106 arg2 = static_cast< wxDragResult >(val2);
34107 {
34108 PyThreadState* __tstate = wxPyBeginAllowThreads();
34109 result = (bool)(arg1)->GiveFeedback(arg2);
34110 wxPyEndAllowThreads(__tstate);
34111 if (PyErr_Occurred()) SWIG_fail;
34112 }
34113 {
34114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34115 }
34116 return resultobj;
34117 fail:
34118 return NULL;
34119 }
34120
34121
34122 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34123 PyObject *obj;
34124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34125 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34126 return SWIG_Py_Void();
34127 }
34128
34129 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34130 return SWIG_Python_InitShadowInstance(args);
34131 }
34132
34133 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34134 PyObject *resultobj = 0;
34135 wxDataObject *arg1 = (wxDataObject *) NULL ;
34136 wxPyDropTarget *result = 0 ;
34137 int res1 = 0 ;
34138 PyObject * obj0 = 0 ;
34139 char * kwnames[] = {
34140 (char *) "dataObject", NULL
34141 };
34142
34143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34144 if (obj0) {
34145 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34146 if (!SWIG_IsOK(res1)) {
34147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34148 }
34149 }
34150 {
34151 PyThreadState* __tstate = wxPyBeginAllowThreads();
34152 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34153 wxPyEndAllowThreads(__tstate);
34154 if (PyErr_Occurred()) SWIG_fail;
34155 }
34156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34157 return resultobj;
34158 fail:
34159 return NULL;
34160 }
34161
34162
34163 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34164 PyObject *resultobj = 0;
34165 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34166 PyObject *arg2 = (PyObject *) 0 ;
34167 PyObject *arg3 = (PyObject *) 0 ;
34168 void *argp1 = 0 ;
34169 int res1 = 0 ;
34170 PyObject * obj0 = 0 ;
34171 PyObject * obj1 = 0 ;
34172 PyObject * obj2 = 0 ;
34173 char * kwnames[] = {
34174 (char *) "self",(char *) "self",(char *) "_class", NULL
34175 };
34176
34177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34179 if (!SWIG_IsOK(res1)) {
34180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34181 }
34182 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34183 arg2 = obj1;
34184 arg3 = obj2;
34185 {
34186 PyThreadState* __tstate = wxPyBeginAllowThreads();
34187 (arg1)->_setCallbackInfo(arg2,arg3);
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 resultobj = SWIG_Py_Void();
34192 return resultobj;
34193 fail:
34194 return NULL;
34195 }
34196
34197
34198 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34199 PyObject *resultobj = 0;
34200 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34201 void *argp1 = 0 ;
34202 int res1 = 0 ;
34203 PyObject *swig_obj[1] ;
34204
34205 if (!args) SWIG_fail;
34206 swig_obj[0] = args;
34207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34210 }
34211 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 delete arg1;
34215
34216 wxPyEndAllowThreads(__tstate);
34217 if (PyErr_Occurred()) SWIG_fail;
34218 }
34219 resultobj = SWIG_Py_Void();
34220 return resultobj;
34221 fail:
34222 return NULL;
34223 }
34224
34225
34226 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34227 PyObject *resultobj = 0;
34228 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34229 wxDataObject *result = 0 ;
34230 void *argp1 = 0 ;
34231 int res1 = 0 ;
34232 PyObject *swig_obj[1] ;
34233
34234 if (!args) SWIG_fail;
34235 swig_obj[0] = args;
34236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34237 if (!SWIG_IsOK(res1)) {
34238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34239 }
34240 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34241 {
34242 PyThreadState* __tstate = wxPyBeginAllowThreads();
34243 result = (wxDataObject *)(arg1)->GetDataObject();
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34255 PyObject *resultobj = 0;
34256 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34257 wxDataObject *arg2 = (wxDataObject *) 0 ;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 int res2 = 0 ;
34261 PyObject * obj0 = 0 ;
34262 PyObject * obj1 = 0 ;
34263 char * kwnames[] = {
34264 (char *) "self",(char *) "dataObject", NULL
34265 };
34266
34267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34269 if (!SWIG_IsOK(res1)) {
34270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34271 }
34272 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34273 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34274 if (!SWIG_IsOK(res2)) {
34275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34276 }
34277 {
34278 PyThreadState* __tstate = wxPyBeginAllowThreads();
34279 (arg1)->SetDataObject(arg2);
34280 wxPyEndAllowThreads(__tstate);
34281 if (PyErr_Occurred()) SWIG_fail;
34282 }
34283 resultobj = SWIG_Py_Void();
34284 return resultobj;
34285 fail:
34286 return NULL;
34287 }
34288
34289
34290 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34291 PyObject *resultobj = 0;
34292 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34293 int arg2 ;
34294 int arg3 ;
34295 wxDragResult arg4 ;
34296 wxDragResult result;
34297 void *argp1 = 0 ;
34298 int res1 = 0 ;
34299 int val2 ;
34300 int ecode2 = 0 ;
34301 int val3 ;
34302 int ecode3 = 0 ;
34303 int val4 ;
34304 int ecode4 = 0 ;
34305 PyObject * obj0 = 0 ;
34306 PyObject * obj1 = 0 ;
34307 PyObject * obj2 = 0 ;
34308 PyObject * obj3 = 0 ;
34309 char * kwnames[] = {
34310 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34311 };
34312
34313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34315 if (!SWIG_IsOK(res1)) {
34316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34317 }
34318 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34319 ecode2 = SWIG_AsVal_int(obj1, &val2);
34320 if (!SWIG_IsOK(ecode2)) {
34321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34322 }
34323 arg2 = static_cast< int >(val2);
34324 ecode3 = SWIG_AsVal_int(obj2, &val3);
34325 if (!SWIG_IsOK(ecode3)) {
34326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34327 }
34328 arg3 = static_cast< int >(val3);
34329 ecode4 = SWIG_AsVal_int(obj3, &val4);
34330 if (!SWIG_IsOK(ecode4)) {
34331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34332 }
34333 arg4 = static_cast< wxDragResult >(val4);
34334 {
34335 PyThreadState* __tstate = wxPyBeginAllowThreads();
34336 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34337 wxPyEndAllowThreads(__tstate);
34338 if (PyErr_Occurred()) SWIG_fail;
34339 }
34340 resultobj = SWIG_From_int(static_cast< int >(result));
34341 return resultobj;
34342 fail:
34343 return NULL;
34344 }
34345
34346
34347 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34348 PyObject *resultobj = 0;
34349 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34350 int arg2 ;
34351 int arg3 ;
34352 wxDragResult arg4 ;
34353 wxDragResult result;
34354 void *argp1 = 0 ;
34355 int res1 = 0 ;
34356 int val2 ;
34357 int ecode2 = 0 ;
34358 int val3 ;
34359 int ecode3 = 0 ;
34360 int val4 ;
34361 int ecode4 = 0 ;
34362 PyObject * obj0 = 0 ;
34363 PyObject * obj1 = 0 ;
34364 PyObject * obj2 = 0 ;
34365 PyObject * obj3 = 0 ;
34366 char * kwnames[] = {
34367 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34368 };
34369
34370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34372 if (!SWIG_IsOK(res1)) {
34373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34374 }
34375 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34376 ecode2 = SWIG_AsVal_int(obj1, &val2);
34377 if (!SWIG_IsOK(ecode2)) {
34378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34379 }
34380 arg2 = static_cast< int >(val2);
34381 ecode3 = SWIG_AsVal_int(obj2, &val3);
34382 if (!SWIG_IsOK(ecode3)) {
34383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34384 }
34385 arg3 = static_cast< int >(val3);
34386 ecode4 = SWIG_AsVal_int(obj3, &val4);
34387 if (!SWIG_IsOK(ecode4)) {
34388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34389 }
34390 arg4 = static_cast< wxDragResult >(val4);
34391 {
34392 PyThreadState* __tstate = wxPyBeginAllowThreads();
34393 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34394 wxPyEndAllowThreads(__tstate);
34395 if (PyErr_Occurred()) SWIG_fail;
34396 }
34397 resultobj = SWIG_From_int(static_cast< int >(result));
34398 return resultobj;
34399 fail:
34400 return NULL;
34401 }
34402
34403
34404 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34405 PyObject *resultobj = 0;
34406 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34407 void *argp1 = 0 ;
34408 int res1 = 0 ;
34409 PyObject *swig_obj[1] ;
34410
34411 if (!args) SWIG_fail;
34412 swig_obj[0] = args;
34413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34414 if (!SWIG_IsOK(res1)) {
34415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34416 }
34417 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 (arg1)->OnLeave();
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_Py_Void();
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34432 PyObject *resultobj = 0;
34433 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34434 int arg2 ;
34435 int arg3 ;
34436 bool result;
34437 void *argp1 = 0 ;
34438 int res1 = 0 ;
34439 int val2 ;
34440 int ecode2 = 0 ;
34441 int val3 ;
34442 int ecode3 = 0 ;
34443 PyObject * obj0 = 0 ;
34444 PyObject * obj1 = 0 ;
34445 PyObject * obj2 = 0 ;
34446 char * kwnames[] = {
34447 (char *) "self",(char *) "x",(char *) "y", NULL
34448 };
34449
34450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34452 if (!SWIG_IsOK(res1)) {
34453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34454 }
34455 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34456 ecode2 = SWIG_AsVal_int(obj1, &val2);
34457 if (!SWIG_IsOK(ecode2)) {
34458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34459 }
34460 arg2 = static_cast< int >(val2);
34461 ecode3 = SWIG_AsVal_int(obj2, &val3);
34462 if (!SWIG_IsOK(ecode3)) {
34463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34464 }
34465 arg3 = static_cast< int >(val3);
34466 {
34467 PyThreadState* __tstate = wxPyBeginAllowThreads();
34468 result = (bool)(arg1)->OnDrop(arg2,arg3);
34469 wxPyEndAllowThreads(__tstate);
34470 if (PyErr_Occurred()) SWIG_fail;
34471 }
34472 {
34473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34474 }
34475 return resultobj;
34476 fail:
34477 return NULL;
34478 }
34479
34480
34481 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34482 PyObject *resultobj = 0;
34483 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34484 bool result;
34485 void *argp1 = 0 ;
34486 int res1 = 0 ;
34487 PyObject *swig_obj[1] ;
34488
34489 if (!args) SWIG_fail;
34490 swig_obj[0] = args;
34491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34492 if (!SWIG_IsOK(res1)) {
34493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34494 }
34495 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34496 {
34497 PyThreadState* __tstate = wxPyBeginAllowThreads();
34498 result = (bool)(arg1)->GetData();
34499 wxPyEndAllowThreads(__tstate);
34500 if (PyErr_Occurred()) SWIG_fail;
34501 }
34502 {
34503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34504 }
34505 return resultobj;
34506 fail:
34507 return NULL;
34508 }
34509
34510
34511 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34512 PyObject *resultobj = 0;
34513 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34514 wxDragResult arg2 ;
34515 void *argp1 = 0 ;
34516 int res1 = 0 ;
34517 int val2 ;
34518 int ecode2 = 0 ;
34519 PyObject * obj0 = 0 ;
34520 PyObject * obj1 = 0 ;
34521 char * kwnames[] = {
34522 (char *) "self",(char *) "action", NULL
34523 };
34524
34525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34527 if (!SWIG_IsOK(res1)) {
34528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34529 }
34530 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34531 ecode2 = SWIG_AsVal_int(obj1, &val2);
34532 if (!SWIG_IsOK(ecode2)) {
34533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34534 }
34535 arg2 = static_cast< wxDragResult >(val2);
34536 {
34537 PyThreadState* __tstate = wxPyBeginAllowThreads();
34538 (arg1)->SetDefaultAction(arg2);
34539 wxPyEndAllowThreads(__tstate);
34540 if (PyErr_Occurred()) SWIG_fail;
34541 }
34542 resultobj = SWIG_Py_Void();
34543 return resultobj;
34544 fail:
34545 return NULL;
34546 }
34547
34548
34549 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34550 PyObject *resultobj = 0;
34551 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34552 wxDragResult result;
34553 void *argp1 = 0 ;
34554 int res1 = 0 ;
34555 PyObject *swig_obj[1] ;
34556
34557 if (!args) SWIG_fail;
34558 swig_obj[0] = args;
34559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34560 if (!SWIG_IsOK(res1)) {
34561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34562 }
34563 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34564 {
34565 PyThreadState* __tstate = wxPyBeginAllowThreads();
34566 result = (wxDragResult)(arg1)->GetDefaultAction();
34567 wxPyEndAllowThreads(__tstate);
34568 if (PyErr_Occurred()) SWIG_fail;
34569 }
34570 resultobj = SWIG_From_int(static_cast< int >(result));
34571 return resultobj;
34572 fail:
34573 return NULL;
34574 }
34575
34576
34577 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34578 PyObject *obj;
34579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34580 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34581 return SWIG_Py_Void();
34582 }
34583
34584 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34585 return SWIG_Python_InitShadowInstance(args);
34586 }
34587
34588 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34589 PyObject *resultobj = 0;
34590 wxPyTextDropTarget *result = 0 ;
34591
34592 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34593 {
34594 PyThreadState* __tstate = wxPyBeginAllowThreads();
34595 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34596 wxPyEndAllowThreads(__tstate);
34597 if (PyErr_Occurred()) SWIG_fail;
34598 }
34599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34600 return resultobj;
34601 fail:
34602 return NULL;
34603 }
34604
34605
34606 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34607 PyObject *resultobj = 0;
34608 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34609 PyObject *arg2 = (PyObject *) 0 ;
34610 PyObject *arg3 = (PyObject *) 0 ;
34611 void *argp1 = 0 ;
34612 int res1 = 0 ;
34613 PyObject * obj0 = 0 ;
34614 PyObject * obj1 = 0 ;
34615 PyObject * obj2 = 0 ;
34616 char * kwnames[] = {
34617 (char *) "self",(char *) "self",(char *) "_class", NULL
34618 };
34619
34620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34622 if (!SWIG_IsOK(res1)) {
34623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34624 }
34625 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34626 arg2 = obj1;
34627 arg3 = obj2;
34628 {
34629 PyThreadState* __tstate = wxPyBeginAllowThreads();
34630 (arg1)->_setCallbackInfo(arg2,arg3);
34631 wxPyEndAllowThreads(__tstate);
34632 if (PyErr_Occurred()) SWIG_fail;
34633 }
34634 resultobj = SWIG_Py_Void();
34635 return resultobj;
34636 fail:
34637 return NULL;
34638 }
34639
34640
34641 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34642 PyObject *resultobj = 0;
34643 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34644 int arg2 ;
34645 int arg3 ;
34646 wxString *arg4 = 0 ;
34647 bool result;
34648 void *argp1 = 0 ;
34649 int res1 = 0 ;
34650 int val2 ;
34651 int ecode2 = 0 ;
34652 int val3 ;
34653 int ecode3 = 0 ;
34654 bool temp4 = false ;
34655 PyObject * obj0 = 0 ;
34656 PyObject * obj1 = 0 ;
34657 PyObject * obj2 = 0 ;
34658 PyObject * obj3 = 0 ;
34659 char * kwnames[] = {
34660 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34661 };
34662
34663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34665 if (!SWIG_IsOK(res1)) {
34666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34667 }
34668 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34669 ecode2 = SWIG_AsVal_int(obj1, &val2);
34670 if (!SWIG_IsOK(ecode2)) {
34671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34672 }
34673 arg2 = static_cast< int >(val2);
34674 ecode3 = SWIG_AsVal_int(obj2, &val3);
34675 if (!SWIG_IsOK(ecode3)) {
34676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34677 }
34678 arg3 = static_cast< int >(val3);
34679 {
34680 arg4 = wxString_in_helper(obj3);
34681 if (arg4 == NULL) SWIG_fail;
34682 temp4 = true;
34683 }
34684 {
34685 PyThreadState* __tstate = wxPyBeginAllowThreads();
34686 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34687 wxPyEndAllowThreads(__tstate);
34688 if (PyErr_Occurred()) SWIG_fail;
34689 }
34690 {
34691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34692 }
34693 {
34694 if (temp4)
34695 delete arg4;
34696 }
34697 return resultobj;
34698 fail:
34699 {
34700 if (temp4)
34701 delete arg4;
34702 }
34703 return NULL;
34704 }
34705
34706
34707 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34708 PyObject *resultobj = 0;
34709 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34710 int arg2 ;
34711 int arg3 ;
34712 wxDragResult arg4 ;
34713 wxDragResult result;
34714 void *argp1 = 0 ;
34715 int res1 = 0 ;
34716 int val2 ;
34717 int ecode2 = 0 ;
34718 int val3 ;
34719 int ecode3 = 0 ;
34720 int val4 ;
34721 int ecode4 = 0 ;
34722 PyObject * obj0 = 0 ;
34723 PyObject * obj1 = 0 ;
34724 PyObject * obj2 = 0 ;
34725 PyObject * obj3 = 0 ;
34726 char * kwnames[] = {
34727 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34728 };
34729
34730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34732 if (!SWIG_IsOK(res1)) {
34733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34734 }
34735 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34736 ecode2 = SWIG_AsVal_int(obj1, &val2);
34737 if (!SWIG_IsOK(ecode2)) {
34738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34739 }
34740 arg2 = static_cast< int >(val2);
34741 ecode3 = SWIG_AsVal_int(obj2, &val3);
34742 if (!SWIG_IsOK(ecode3)) {
34743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34744 }
34745 arg3 = static_cast< int >(val3);
34746 ecode4 = SWIG_AsVal_int(obj3, &val4);
34747 if (!SWIG_IsOK(ecode4)) {
34748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34749 }
34750 arg4 = static_cast< wxDragResult >(val4);
34751 {
34752 PyThreadState* __tstate = wxPyBeginAllowThreads();
34753 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34754 wxPyEndAllowThreads(__tstate);
34755 if (PyErr_Occurred()) SWIG_fail;
34756 }
34757 resultobj = SWIG_From_int(static_cast< int >(result));
34758 return resultobj;
34759 fail:
34760 return NULL;
34761 }
34762
34763
34764 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34765 PyObject *resultobj = 0;
34766 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34767 int arg2 ;
34768 int arg3 ;
34769 wxDragResult arg4 ;
34770 wxDragResult result;
34771 void *argp1 = 0 ;
34772 int res1 = 0 ;
34773 int val2 ;
34774 int ecode2 = 0 ;
34775 int val3 ;
34776 int ecode3 = 0 ;
34777 int val4 ;
34778 int ecode4 = 0 ;
34779 PyObject * obj0 = 0 ;
34780 PyObject * obj1 = 0 ;
34781 PyObject * obj2 = 0 ;
34782 PyObject * obj3 = 0 ;
34783 char * kwnames[] = {
34784 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34785 };
34786
34787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34789 if (!SWIG_IsOK(res1)) {
34790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34791 }
34792 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34793 ecode2 = SWIG_AsVal_int(obj1, &val2);
34794 if (!SWIG_IsOK(ecode2)) {
34795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34796 }
34797 arg2 = static_cast< int >(val2);
34798 ecode3 = SWIG_AsVal_int(obj2, &val3);
34799 if (!SWIG_IsOK(ecode3)) {
34800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34801 }
34802 arg3 = static_cast< int >(val3);
34803 ecode4 = SWIG_AsVal_int(obj3, &val4);
34804 if (!SWIG_IsOK(ecode4)) {
34805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34806 }
34807 arg4 = static_cast< wxDragResult >(val4);
34808 {
34809 PyThreadState* __tstate = wxPyBeginAllowThreads();
34810 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34811 wxPyEndAllowThreads(__tstate);
34812 if (PyErr_Occurred()) SWIG_fail;
34813 }
34814 resultobj = SWIG_From_int(static_cast< int >(result));
34815 return resultobj;
34816 fail:
34817 return NULL;
34818 }
34819
34820
34821 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34822 PyObject *resultobj = 0;
34823 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34824 void *argp1 = 0 ;
34825 int res1 = 0 ;
34826 PyObject *swig_obj[1] ;
34827
34828 if (!args) SWIG_fail;
34829 swig_obj[0] = args;
34830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34831 if (!SWIG_IsOK(res1)) {
34832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34833 }
34834 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34835 {
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 (arg1)->OnLeave();
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 resultobj = SWIG_Py_Void();
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34849 PyObject *resultobj = 0;
34850 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34851 int arg2 ;
34852 int arg3 ;
34853 bool result;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 int val2 ;
34857 int ecode2 = 0 ;
34858 int val3 ;
34859 int ecode3 = 0 ;
34860 PyObject * obj0 = 0 ;
34861 PyObject * obj1 = 0 ;
34862 PyObject * obj2 = 0 ;
34863 char * kwnames[] = {
34864 (char *) "self",(char *) "x",(char *) "y", NULL
34865 };
34866
34867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34869 if (!SWIG_IsOK(res1)) {
34870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34871 }
34872 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34873 ecode2 = SWIG_AsVal_int(obj1, &val2);
34874 if (!SWIG_IsOK(ecode2)) {
34875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34876 }
34877 arg2 = static_cast< int >(val2);
34878 ecode3 = SWIG_AsVal_int(obj2, &val3);
34879 if (!SWIG_IsOK(ecode3)) {
34880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34881 }
34882 arg3 = static_cast< int >(val3);
34883 {
34884 PyThreadState* __tstate = wxPyBeginAllowThreads();
34885 result = (bool)(arg1)->OnDrop(arg2,arg3);
34886 wxPyEndAllowThreads(__tstate);
34887 if (PyErr_Occurred()) SWIG_fail;
34888 }
34889 {
34890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34891 }
34892 return resultobj;
34893 fail:
34894 return NULL;
34895 }
34896
34897
34898 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34899 PyObject *resultobj = 0;
34900 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34901 int arg2 ;
34902 int arg3 ;
34903 wxDragResult arg4 ;
34904 wxDragResult result;
34905 void *argp1 = 0 ;
34906 int res1 = 0 ;
34907 int val2 ;
34908 int ecode2 = 0 ;
34909 int val3 ;
34910 int ecode3 = 0 ;
34911 int val4 ;
34912 int ecode4 = 0 ;
34913 PyObject * obj0 = 0 ;
34914 PyObject * obj1 = 0 ;
34915 PyObject * obj2 = 0 ;
34916 PyObject * obj3 = 0 ;
34917 char * kwnames[] = {
34918 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34919 };
34920
34921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34923 if (!SWIG_IsOK(res1)) {
34924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34925 }
34926 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34927 ecode2 = SWIG_AsVal_int(obj1, &val2);
34928 if (!SWIG_IsOK(ecode2)) {
34929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34930 }
34931 arg2 = static_cast< int >(val2);
34932 ecode3 = SWIG_AsVal_int(obj2, &val3);
34933 if (!SWIG_IsOK(ecode3)) {
34934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34935 }
34936 arg3 = static_cast< int >(val3);
34937 ecode4 = SWIG_AsVal_int(obj3, &val4);
34938 if (!SWIG_IsOK(ecode4)) {
34939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34940 }
34941 arg4 = static_cast< wxDragResult >(val4);
34942 {
34943 PyThreadState* __tstate = wxPyBeginAllowThreads();
34944 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34945 wxPyEndAllowThreads(__tstate);
34946 if (PyErr_Occurred()) SWIG_fail;
34947 }
34948 resultobj = SWIG_From_int(static_cast< int >(result));
34949 return resultobj;
34950 fail:
34951 return NULL;
34952 }
34953
34954
34955 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34956 PyObject *obj;
34957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34958 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34959 return SWIG_Py_Void();
34960 }
34961
34962 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34963 return SWIG_Python_InitShadowInstance(args);
34964 }
34965
34966 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34967 PyObject *resultobj = 0;
34968 wxPyFileDropTarget *result = 0 ;
34969
34970 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34974 wxPyEndAllowThreads(__tstate);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 }
34977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34978 return resultobj;
34979 fail:
34980 return NULL;
34981 }
34982
34983
34984 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34985 PyObject *resultobj = 0;
34986 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34987 PyObject *arg2 = (PyObject *) 0 ;
34988 PyObject *arg3 = (PyObject *) 0 ;
34989 void *argp1 = 0 ;
34990 int res1 = 0 ;
34991 PyObject * obj0 = 0 ;
34992 PyObject * obj1 = 0 ;
34993 PyObject * obj2 = 0 ;
34994 char * kwnames[] = {
34995 (char *) "self",(char *) "self",(char *) "_class", NULL
34996 };
34997
34998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35000 if (!SWIG_IsOK(res1)) {
35001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35002 }
35003 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35004 arg2 = obj1;
35005 arg3 = obj2;
35006 {
35007 PyThreadState* __tstate = wxPyBeginAllowThreads();
35008 (arg1)->_setCallbackInfo(arg2,arg3);
35009 wxPyEndAllowThreads(__tstate);
35010 if (PyErr_Occurred()) SWIG_fail;
35011 }
35012 resultobj = SWIG_Py_Void();
35013 return resultobj;
35014 fail:
35015 return NULL;
35016 }
35017
35018
35019 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35020 PyObject *resultobj = 0;
35021 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35022 int arg2 ;
35023 int arg3 ;
35024 wxArrayString *arg4 = 0 ;
35025 bool result;
35026 void *argp1 = 0 ;
35027 int res1 = 0 ;
35028 int val2 ;
35029 int ecode2 = 0 ;
35030 int val3 ;
35031 int ecode3 = 0 ;
35032 bool temp4 = false ;
35033 PyObject * obj0 = 0 ;
35034 PyObject * obj1 = 0 ;
35035 PyObject * obj2 = 0 ;
35036 PyObject * obj3 = 0 ;
35037 char * kwnames[] = {
35038 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35039 };
35040
35041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35043 if (!SWIG_IsOK(res1)) {
35044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35045 }
35046 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35047 ecode2 = SWIG_AsVal_int(obj1, &val2);
35048 if (!SWIG_IsOK(ecode2)) {
35049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35050 }
35051 arg2 = static_cast< int >(val2);
35052 ecode3 = SWIG_AsVal_int(obj2, &val3);
35053 if (!SWIG_IsOK(ecode3)) {
35054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35055 }
35056 arg3 = static_cast< int >(val3);
35057 {
35058 if (! PySequence_Check(obj3)) {
35059 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35060 SWIG_fail;
35061 }
35062 arg4 = new wxArrayString;
35063 temp4 = true;
35064 int i, len=PySequence_Length(obj3);
35065 for (i=0; i<len; i++) {
35066 PyObject* item = PySequence_GetItem(obj3, i);
35067 wxString* s = wxString_in_helper(item);
35068 if (PyErr_Occurred()) SWIG_fail;
35069 arg4->Add(*s);
35070 delete s;
35071 Py_DECREF(item);
35072 }
35073 }
35074 {
35075 PyThreadState* __tstate = wxPyBeginAllowThreads();
35076 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35077 wxPyEndAllowThreads(__tstate);
35078 if (PyErr_Occurred()) SWIG_fail;
35079 }
35080 {
35081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35082 }
35083 {
35084 if (temp4) delete arg4;
35085 }
35086 return resultobj;
35087 fail:
35088 {
35089 if (temp4) delete arg4;
35090 }
35091 return NULL;
35092 }
35093
35094
35095 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35096 PyObject *resultobj = 0;
35097 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35098 int arg2 ;
35099 int arg3 ;
35100 wxDragResult arg4 ;
35101 wxDragResult result;
35102 void *argp1 = 0 ;
35103 int res1 = 0 ;
35104 int val2 ;
35105 int ecode2 = 0 ;
35106 int val3 ;
35107 int ecode3 = 0 ;
35108 int val4 ;
35109 int ecode4 = 0 ;
35110 PyObject * obj0 = 0 ;
35111 PyObject * obj1 = 0 ;
35112 PyObject * obj2 = 0 ;
35113 PyObject * obj3 = 0 ;
35114 char * kwnames[] = {
35115 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35116 };
35117
35118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35120 if (!SWIG_IsOK(res1)) {
35121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35122 }
35123 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35124 ecode2 = SWIG_AsVal_int(obj1, &val2);
35125 if (!SWIG_IsOK(ecode2)) {
35126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35127 }
35128 arg2 = static_cast< int >(val2);
35129 ecode3 = SWIG_AsVal_int(obj2, &val3);
35130 if (!SWIG_IsOK(ecode3)) {
35131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35132 }
35133 arg3 = static_cast< int >(val3);
35134 ecode4 = SWIG_AsVal_int(obj3, &val4);
35135 if (!SWIG_IsOK(ecode4)) {
35136 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35137 }
35138 arg4 = static_cast< wxDragResult >(val4);
35139 {
35140 PyThreadState* __tstate = wxPyBeginAllowThreads();
35141 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35142 wxPyEndAllowThreads(__tstate);
35143 if (PyErr_Occurred()) SWIG_fail;
35144 }
35145 resultobj = SWIG_From_int(static_cast< int >(result));
35146 return resultobj;
35147 fail:
35148 return NULL;
35149 }
35150
35151
35152 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35153 PyObject *resultobj = 0;
35154 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35155 int arg2 ;
35156 int arg3 ;
35157 wxDragResult arg4 ;
35158 wxDragResult result;
35159 void *argp1 = 0 ;
35160 int res1 = 0 ;
35161 int val2 ;
35162 int ecode2 = 0 ;
35163 int val3 ;
35164 int ecode3 = 0 ;
35165 int val4 ;
35166 int ecode4 = 0 ;
35167 PyObject * obj0 = 0 ;
35168 PyObject * obj1 = 0 ;
35169 PyObject * obj2 = 0 ;
35170 PyObject * obj3 = 0 ;
35171 char * kwnames[] = {
35172 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35173 };
35174
35175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35177 if (!SWIG_IsOK(res1)) {
35178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35179 }
35180 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35181 ecode2 = SWIG_AsVal_int(obj1, &val2);
35182 if (!SWIG_IsOK(ecode2)) {
35183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35184 }
35185 arg2 = static_cast< int >(val2);
35186 ecode3 = SWIG_AsVal_int(obj2, &val3);
35187 if (!SWIG_IsOK(ecode3)) {
35188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35189 }
35190 arg3 = static_cast< int >(val3);
35191 ecode4 = SWIG_AsVal_int(obj3, &val4);
35192 if (!SWIG_IsOK(ecode4)) {
35193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35194 }
35195 arg4 = static_cast< wxDragResult >(val4);
35196 {
35197 PyThreadState* __tstate = wxPyBeginAllowThreads();
35198 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35199 wxPyEndAllowThreads(__tstate);
35200 if (PyErr_Occurred()) SWIG_fail;
35201 }
35202 resultobj = SWIG_From_int(static_cast< int >(result));
35203 return resultobj;
35204 fail:
35205 return NULL;
35206 }
35207
35208
35209 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35210 PyObject *resultobj = 0;
35211 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35212 void *argp1 = 0 ;
35213 int res1 = 0 ;
35214 PyObject *swig_obj[1] ;
35215
35216 if (!args) SWIG_fail;
35217 swig_obj[0] = args;
35218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35219 if (!SWIG_IsOK(res1)) {
35220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35221 }
35222 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35223 {
35224 PyThreadState* __tstate = wxPyBeginAllowThreads();
35225 (arg1)->OnLeave();
35226 wxPyEndAllowThreads(__tstate);
35227 if (PyErr_Occurred()) SWIG_fail;
35228 }
35229 resultobj = SWIG_Py_Void();
35230 return resultobj;
35231 fail:
35232 return NULL;
35233 }
35234
35235
35236 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35237 PyObject *resultobj = 0;
35238 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35239 int arg2 ;
35240 int arg3 ;
35241 bool result;
35242 void *argp1 = 0 ;
35243 int res1 = 0 ;
35244 int val2 ;
35245 int ecode2 = 0 ;
35246 int val3 ;
35247 int ecode3 = 0 ;
35248 PyObject * obj0 = 0 ;
35249 PyObject * obj1 = 0 ;
35250 PyObject * obj2 = 0 ;
35251 char * kwnames[] = {
35252 (char *) "self",(char *) "x",(char *) "y", NULL
35253 };
35254
35255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35257 if (!SWIG_IsOK(res1)) {
35258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35259 }
35260 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35261 ecode2 = SWIG_AsVal_int(obj1, &val2);
35262 if (!SWIG_IsOK(ecode2)) {
35263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35264 }
35265 arg2 = static_cast< int >(val2);
35266 ecode3 = SWIG_AsVal_int(obj2, &val3);
35267 if (!SWIG_IsOK(ecode3)) {
35268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35269 }
35270 arg3 = static_cast< int >(val3);
35271 {
35272 PyThreadState* __tstate = wxPyBeginAllowThreads();
35273 result = (bool)(arg1)->OnDrop(arg2,arg3);
35274 wxPyEndAllowThreads(__tstate);
35275 if (PyErr_Occurred()) SWIG_fail;
35276 }
35277 {
35278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35279 }
35280 return resultobj;
35281 fail:
35282 return NULL;
35283 }
35284
35285
35286 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35287 PyObject *resultobj = 0;
35288 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35289 int arg2 ;
35290 int arg3 ;
35291 wxDragResult arg4 ;
35292 wxDragResult result;
35293 void *argp1 = 0 ;
35294 int res1 = 0 ;
35295 int val2 ;
35296 int ecode2 = 0 ;
35297 int val3 ;
35298 int ecode3 = 0 ;
35299 int val4 ;
35300 int ecode4 = 0 ;
35301 PyObject * obj0 = 0 ;
35302 PyObject * obj1 = 0 ;
35303 PyObject * obj2 = 0 ;
35304 PyObject * obj3 = 0 ;
35305 char * kwnames[] = {
35306 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35307 };
35308
35309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35311 if (!SWIG_IsOK(res1)) {
35312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35313 }
35314 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35315 ecode2 = SWIG_AsVal_int(obj1, &val2);
35316 if (!SWIG_IsOK(ecode2)) {
35317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35318 }
35319 arg2 = static_cast< int >(val2);
35320 ecode3 = SWIG_AsVal_int(obj2, &val3);
35321 if (!SWIG_IsOK(ecode3)) {
35322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35323 }
35324 arg3 = static_cast< int >(val3);
35325 ecode4 = SWIG_AsVal_int(obj3, &val4);
35326 if (!SWIG_IsOK(ecode4)) {
35327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35328 }
35329 arg4 = static_cast< wxDragResult >(val4);
35330 {
35331 PyThreadState* __tstate = wxPyBeginAllowThreads();
35332 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 resultobj = SWIG_From_int(static_cast< int >(result));
35337 return resultobj;
35338 fail:
35339 return NULL;
35340 }
35341
35342
35343 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35344 PyObject *obj;
35345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35346 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35347 return SWIG_Py_Void();
35348 }
35349
35350 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35351 return SWIG_Python_InitShadowInstance(args);
35352 }
35353
35354 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35355 PyObject *resultobj = 0;
35356 wxClipboard *result = 0 ;
35357
35358 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 result = (wxClipboard *)new wxClipboard();
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35366 return resultobj;
35367 fail:
35368 return NULL;
35369 }
35370
35371
35372 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35373 PyObject *resultobj = 0;
35374 wxClipboard *arg1 = (wxClipboard *) 0 ;
35375 void *argp1 = 0 ;
35376 int res1 = 0 ;
35377 PyObject *swig_obj[1] ;
35378
35379 if (!args) SWIG_fail;
35380 swig_obj[0] = args;
35381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35382 if (!SWIG_IsOK(res1)) {
35383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35384 }
35385 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35386 {
35387 PyThreadState* __tstate = wxPyBeginAllowThreads();
35388 delete arg1;
35389
35390 wxPyEndAllowThreads(__tstate);
35391 if (PyErr_Occurred()) SWIG_fail;
35392 }
35393 resultobj = SWIG_Py_Void();
35394 return resultobj;
35395 fail:
35396 return NULL;
35397 }
35398
35399
35400 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35401 PyObject *resultobj = 0;
35402 wxClipboard *arg1 = (wxClipboard *) 0 ;
35403 bool result;
35404 void *argp1 = 0 ;
35405 int res1 = 0 ;
35406 PyObject *swig_obj[1] ;
35407
35408 if (!args) SWIG_fail;
35409 swig_obj[0] = args;
35410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35411 if (!SWIG_IsOK(res1)) {
35412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35413 }
35414 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35415 {
35416 PyThreadState* __tstate = wxPyBeginAllowThreads();
35417 result = (bool)(arg1)->Open();
35418 wxPyEndAllowThreads(__tstate);
35419 if (PyErr_Occurred()) SWIG_fail;
35420 }
35421 {
35422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35423 }
35424 return resultobj;
35425 fail:
35426 return NULL;
35427 }
35428
35429
35430 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35431 PyObject *resultobj = 0;
35432 wxClipboard *arg1 = (wxClipboard *) 0 ;
35433 void *argp1 = 0 ;
35434 int res1 = 0 ;
35435 PyObject *swig_obj[1] ;
35436
35437 if (!args) SWIG_fail;
35438 swig_obj[0] = args;
35439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35440 if (!SWIG_IsOK(res1)) {
35441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35442 }
35443 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35444 {
35445 PyThreadState* __tstate = wxPyBeginAllowThreads();
35446 (arg1)->Close();
35447 wxPyEndAllowThreads(__tstate);
35448 if (PyErr_Occurred()) SWIG_fail;
35449 }
35450 resultobj = SWIG_Py_Void();
35451 return resultobj;
35452 fail:
35453 return NULL;
35454 }
35455
35456
35457 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35458 PyObject *resultobj = 0;
35459 wxClipboard *arg1 = (wxClipboard *) 0 ;
35460 bool result;
35461 void *argp1 = 0 ;
35462 int res1 = 0 ;
35463 PyObject *swig_obj[1] ;
35464
35465 if (!args) SWIG_fail;
35466 swig_obj[0] = args;
35467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35468 if (!SWIG_IsOK(res1)) {
35469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35470 }
35471 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35472 {
35473 PyThreadState* __tstate = wxPyBeginAllowThreads();
35474 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35475 wxPyEndAllowThreads(__tstate);
35476 if (PyErr_Occurred()) SWIG_fail;
35477 }
35478 {
35479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35480 }
35481 return resultobj;
35482 fail:
35483 return NULL;
35484 }
35485
35486
35487 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35488 PyObject *resultobj = 0;
35489 wxClipboard *arg1 = (wxClipboard *) 0 ;
35490 wxDataObject *arg2 = (wxDataObject *) 0 ;
35491 bool result;
35492 void *argp1 = 0 ;
35493 int res1 = 0 ;
35494 int res2 = 0 ;
35495 PyObject * obj0 = 0 ;
35496 PyObject * obj1 = 0 ;
35497 char * kwnames[] = {
35498 (char *) "self",(char *) "data", NULL
35499 };
35500
35501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35503 if (!SWIG_IsOK(res1)) {
35504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35505 }
35506 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35507 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35508 if (!SWIG_IsOK(res2)) {
35509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35510 }
35511 {
35512 PyThreadState* __tstate = wxPyBeginAllowThreads();
35513 result = (bool)(arg1)->AddData(arg2);
35514 wxPyEndAllowThreads(__tstate);
35515 if (PyErr_Occurred()) SWIG_fail;
35516 }
35517 {
35518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35519 }
35520 return resultobj;
35521 fail:
35522 return NULL;
35523 }
35524
35525
35526 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35527 PyObject *resultobj = 0;
35528 wxClipboard *arg1 = (wxClipboard *) 0 ;
35529 wxDataObject *arg2 = (wxDataObject *) 0 ;
35530 bool result;
35531 void *argp1 = 0 ;
35532 int res1 = 0 ;
35533 int res2 = 0 ;
35534 PyObject * obj0 = 0 ;
35535 PyObject * obj1 = 0 ;
35536 char * kwnames[] = {
35537 (char *) "self",(char *) "data", NULL
35538 };
35539
35540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35542 if (!SWIG_IsOK(res1)) {
35543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35544 }
35545 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35546 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35547 if (!SWIG_IsOK(res2)) {
35548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35549 }
35550 {
35551 PyThreadState* __tstate = wxPyBeginAllowThreads();
35552 result = (bool)(arg1)->SetData(arg2);
35553 wxPyEndAllowThreads(__tstate);
35554 if (PyErr_Occurred()) SWIG_fail;
35555 }
35556 {
35557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35558 }
35559 return resultobj;
35560 fail:
35561 return NULL;
35562 }
35563
35564
35565 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35566 PyObject *resultobj = 0;
35567 wxClipboard *arg1 = (wxClipboard *) 0 ;
35568 wxDataFormat *arg2 = 0 ;
35569 bool result;
35570 void *argp1 = 0 ;
35571 int res1 = 0 ;
35572 void *argp2 = 0 ;
35573 int res2 = 0 ;
35574 PyObject * obj0 = 0 ;
35575 PyObject * obj1 = 0 ;
35576 char * kwnames[] = {
35577 (char *) "self",(char *) "format", NULL
35578 };
35579
35580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35582 if (!SWIG_IsOK(res1)) {
35583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35584 }
35585 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35586 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35587 if (!SWIG_IsOK(res2)) {
35588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35589 }
35590 if (!argp2) {
35591 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35592 }
35593 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35594 {
35595 PyThreadState* __tstate = wxPyBeginAllowThreads();
35596 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35597 wxPyEndAllowThreads(__tstate);
35598 if (PyErr_Occurred()) SWIG_fail;
35599 }
35600 {
35601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35602 }
35603 return resultobj;
35604 fail:
35605 return NULL;
35606 }
35607
35608
35609 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35610 PyObject *resultobj = 0;
35611 wxClipboard *arg1 = (wxClipboard *) 0 ;
35612 wxDataObject *arg2 = 0 ;
35613 bool result;
35614 void *argp1 = 0 ;
35615 int res1 = 0 ;
35616 void *argp2 = 0 ;
35617 int res2 = 0 ;
35618 PyObject * obj0 = 0 ;
35619 PyObject * obj1 = 0 ;
35620 char * kwnames[] = {
35621 (char *) "self",(char *) "data", NULL
35622 };
35623
35624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35626 if (!SWIG_IsOK(res1)) {
35627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35628 }
35629 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35631 if (!SWIG_IsOK(res2)) {
35632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35633 }
35634 if (!argp2) {
35635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35636 }
35637 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 result = (bool)(arg1)->GetData(*arg2);
35641 wxPyEndAllowThreads(__tstate);
35642 if (PyErr_Occurred()) SWIG_fail;
35643 }
35644 {
35645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35646 }
35647 return resultobj;
35648 fail:
35649 return NULL;
35650 }
35651
35652
35653 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35654 PyObject *resultobj = 0;
35655 wxClipboard *arg1 = (wxClipboard *) 0 ;
35656 void *argp1 = 0 ;
35657 int res1 = 0 ;
35658 PyObject *swig_obj[1] ;
35659
35660 if (!args) SWIG_fail;
35661 swig_obj[0] = args;
35662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35663 if (!SWIG_IsOK(res1)) {
35664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35665 }
35666 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 (arg1)->Clear();
35670 wxPyEndAllowThreads(__tstate);
35671 if (PyErr_Occurred()) SWIG_fail;
35672 }
35673 resultobj = SWIG_Py_Void();
35674 return resultobj;
35675 fail:
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35681 PyObject *resultobj = 0;
35682 wxClipboard *arg1 = (wxClipboard *) 0 ;
35683 bool result;
35684 void *argp1 = 0 ;
35685 int res1 = 0 ;
35686 PyObject *swig_obj[1] ;
35687
35688 if (!args) SWIG_fail;
35689 swig_obj[0] = args;
35690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35691 if (!SWIG_IsOK(res1)) {
35692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35693 }
35694 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 result = (bool)(arg1)->Flush();
35698 wxPyEndAllowThreads(__tstate);
35699 if (PyErr_Occurred()) SWIG_fail;
35700 }
35701 {
35702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35703 }
35704 return resultobj;
35705 fail:
35706 return NULL;
35707 }
35708
35709
35710 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35711 PyObject *resultobj = 0;
35712 wxClipboard *arg1 = (wxClipboard *) 0 ;
35713 bool arg2 = (bool) true ;
35714 void *argp1 = 0 ;
35715 int res1 = 0 ;
35716 bool val2 ;
35717 int ecode2 = 0 ;
35718 PyObject * obj0 = 0 ;
35719 PyObject * obj1 = 0 ;
35720 char * kwnames[] = {
35721 (char *) "self",(char *) "primary", NULL
35722 };
35723
35724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35726 if (!SWIG_IsOK(res1)) {
35727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35728 }
35729 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35730 if (obj1) {
35731 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35732 if (!SWIG_IsOK(ecode2)) {
35733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35734 }
35735 arg2 = static_cast< bool >(val2);
35736 }
35737 {
35738 PyThreadState* __tstate = wxPyBeginAllowThreads();
35739 (arg1)->UsePrimarySelection(arg2);
35740 wxPyEndAllowThreads(__tstate);
35741 if (PyErr_Occurred()) SWIG_fail;
35742 }
35743 resultobj = SWIG_Py_Void();
35744 return resultobj;
35745 fail:
35746 return NULL;
35747 }
35748
35749
35750 SWIGINTERN PyObject *_wrap_Clipboard_IsUsingPrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35751 PyObject *resultobj = 0;
35752 wxClipboard *arg1 = (wxClipboard *) 0 ;
35753 bool result;
35754 void *argp1 = 0 ;
35755 int res1 = 0 ;
35756 PyObject *swig_obj[1] ;
35757
35758 if (!args) SWIG_fail;
35759 swig_obj[0] = args;
35760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35761 if (!SWIG_IsOK(res1)) {
35762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsUsingPrimarySelection" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35763 }
35764 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35765 {
35766 PyThreadState* __tstate = wxPyBeginAllowThreads();
35767 result = (bool)((wxClipboard const *)arg1)->IsUsingPrimarySelection();
35768 wxPyEndAllowThreads(__tstate);
35769 if (PyErr_Occurred()) SWIG_fail;
35770 }
35771 {
35772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35773 }
35774 return resultobj;
35775 fail:
35776 return NULL;
35777 }
35778
35779
35780 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35781 PyObject *resultobj = 0;
35782 wxClipboard *result = 0 ;
35783
35784 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = (wxClipboard *)wxClipboard::Get();
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35792 return resultobj;
35793 fail:
35794 return NULL;
35795 }
35796
35797
35798 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35799 PyObject *obj;
35800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35801 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35802 return SWIG_Py_Void();
35803 }
35804
35805 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35806 return SWIG_Python_InitShadowInstance(args);
35807 }
35808
35809 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35810 PyObject *resultobj = 0;
35811 wxClipboard *arg1 = (wxClipboard *) NULL ;
35812 wxClipboardLocker *result = 0 ;
35813 void *argp1 = 0 ;
35814 int res1 = 0 ;
35815 PyObject * obj0 = 0 ;
35816 char * kwnames[] = {
35817 (char *) "clipboard", NULL
35818 };
35819
35820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35821 if (obj0) {
35822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35823 if (!SWIG_IsOK(res1)) {
35824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35825 }
35826 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35827 }
35828 {
35829 PyThreadState* __tstate = wxPyBeginAllowThreads();
35830 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35831 wxPyEndAllowThreads(__tstate);
35832 if (PyErr_Occurred()) SWIG_fail;
35833 }
35834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35835 return resultobj;
35836 fail:
35837 return NULL;
35838 }
35839
35840
35841 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35842 PyObject *resultobj = 0;
35843 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35844 void *argp1 = 0 ;
35845 int res1 = 0 ;
35846 PyObject *swig_obj[1] ;
35847
35848 if (!args) SWIG_fail;
35849 swig_obj[0] = args;
35850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35851 if (!SWIG_IsOK(res1)) {
35852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35853 }
35854 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35855 {
35856 PyThreadState* __tstate = wxPyBeginAllowThreads();
35857 delete arg1;
35858
35859 wxPyEndAllowThreads(__tstate);
35860 if (PyErr_Occurred()) SWIG_fail;
35861 }
35862 resultobj = SWIG_Py_Void();
35863 return resultobj;
35864 fail:
35865 return NULL;
35866 }
35867
35868
35869 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35870 PyObject *resultobj = 0;
35871 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35872 bool result;
35873 void *argp1 = 0 ;
35874 int res1 = 0 ;
35875 PyObject *swig_obj[1] ;
35876
35877 if (!args) SWIG_fail;
35878 swig_obj[0] = args;
35879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35880 if (!SWIG_IsOK(res1)) {
35881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35882 }
35883 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 result = (bool)wxClipboardLocker___nonzero__(arg1);
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 {
35891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35892 }
35893 return resultobj;
35894 fail:
35895 return NULL;
35896 }
35897
35898
35899 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35900 PyObject *obj;
35901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35902 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35903 return SWIG_Py_Void();
35904 }
35905
35906 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35907 return SWIG_Python_InitShadowInstance(args);
35908 }
35909
35910 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35911 PyObject *resultobj = 0;
35912 int arg1 = (int) 0 ;
35913 int arg2 = (int) 0 ;
35914 int arg3 = (int) 0 ;
35915 int arg4 = (int) 0 ;
35916 wxVideoMode *result = 0 ;
35917 int val1 ;
35918 int ecode1 = 0 ;
35919 int val2 ;
35920 int ecode2 = 0 ;
35921 int val3 ;
35922 int ecode3 = 0 ;
35923 int val4 ;
35924 int ecode4 = 0 ;
35925 PyObject * obj0 = 0 ;
35926 PyObject * obj1 = 0 ;
35927 PyObject * obj2 = 0 ;
35928 PyObject * obj3 = 0 ;
35929 char * kwnames[] = {
35930 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35931 };
35932
35933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35934 if (obj0) {
35935 ecode1 = SWIG_AsVal_int(obj0, &val1);
35936 if (!SWIG_IsOK(ecode1)) {
35937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35938 }
35939 arg1 = static_cast< int >(val1);
35940 }
35941 if (obj1) {
35942 ecode2 = SWIG_AsVal_int(obj1, &val2);
35943 if (!SWIG_IsOK(ecode2)) {
35944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35945 }
35946 arg2 = static_cast< int >(val2);
35947 }
35948 if (obj2) {
35949 ecode3 = SWIG_AsVal_int(obj2, &val3);
35950 if (!SWIG_IsOK(ecode3)) {
35951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35952 }
35953 arg3 = static_cast< int >(val3);
35954 }
35955 if (obj3) {
35956 ecode4 = SWIG_AsVal_int(obj3, &val4);
35957 if (!SWIG_IsOK(ecode4)) {
35958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35959 }
35960 arg4 = static_cast< int >(val4);
35961 }
35962 {
35963 PyThreadState* __tstate = wxPyBeginAllowThreads();
35964 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35965 wxPyEndAllowThreads(__tstate);
35966 if (PyErr_Occurred()) SWIG_fail;
35967 }
35968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35969 return resultobj;
35970 fail:
35971 return NULL;
35972 }
35973
35974
35975 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35976 PyObject *resultobj = 0;
35977 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35978 void *argp1 = 0 ;
35979 int res1 = 0 ;
35980 PyObject *swig_obj[1] ;
35981
35982 if (!args) SWIG_fail;
35983 swig_obj[0] = args;
35984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35985 if (!SWIG_IsOK(res1)) {
35986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35987 }
35988 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35989 {
35990 PyThreadState* __tstate = wxPyBeginAllowThreads();
35991 delete arg1;
35992
35993 wxPyEndAllowThreads(__tstate);
35994 if (PyErr_Occurred()) SWIG_fail;
35995 }
35996 resultobj = SWIG_Py_Void();
35997 return resultobj;
35998 fail:
35999 return NULL;
36000 }
36001
36002
36003 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36004 PyObject *resultobj = 0;
36005 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36006 wxVideoMode *arg2 = 0 ;
36007 bool result;
36008 void *argp1 = 0 ;
36009 int res1 = 0 ;
36010 void *argp2 = 0 ;
36011 int res2 = 0 ;
36012 PyObject * obj0 = 0 ;
36013 PyObject * obj1 = 0 ;
36014 char * kwnames[] = {
36015 (char *) "self",(char *) "other", NULL
36016 };
36017
36018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
36019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36020 if (!SWIG_IsOK(res1)) {
36021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36022 }
36023 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36025 if (!SWIG_IsOK(res2)) {
36026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36027 }
36028 if (!argp2) {
36029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36030 }
36031 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36032 {
36033 PyThreadState* __tstate = wxPyBeginAllowThreads();
36034 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
36035 wxPyEndAllowThreads(__tstate);
36036 if (PyErr_Occurred()) SWIG_fail;
36037 }
36038 {
36039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36040 }
36041 return resultobj;
36042 fail:
36043 return NULL;
36044 }
36045
36046
36047 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36048 PyObject *resultobj = 0;
36049 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36050 int result;
36051 void *argp1 = 0 ;
36052 int res1 = 0 ;
36053 PyObject *swig_obj[1] ;
36054
36055 if (!args) SWIG_fail;
36056 swig_obj[0] = args;
36057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36058 if (!SWIG_IsOK(res1)) {
36059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36060 }
36061 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36062 {
36063 PyThreadState* __tstate = wxPyBeginAllowThreads();
36064 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36065 wxPyEndAllowThreads(__tstate);
36066 if (PyErr_Occurred()) SWIG_fail;
36067 }
36068 resultobj = SWIG_From_int(static_cast< int >(result));
36069 return resultobj;
36070 fail:
36071 return NULL;
36072 }
36073
36074
36075 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36076 PyObject *resultobj = 0;
36077 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36078 int result;
36079 void *argp1 = 0 ;
36080 int res1 = 0 ;
36081 PyObject *swig_obj[1] ;
36082
36083 if (!args) SWIG_fail;
36084 swig_obj[0] = args;
36085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36086 if (!SWIG_IsOK(res1)) {
36087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36088 }
36089 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36090 {
36091 PyThreadState* __tstate = wxPyBeginAllowThreads();
36092 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36093 wxPyEndAllowThreads(__tstate);
36094 if (PyErr_Occurred()) SWIG_fail;
36095 }
36096 resultobj = SWIG_From_int(static_cast< int >(result));
36097 return resultobj;
36098 fail:
36099 return NULL;
36100 }
36101
36102
36103 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36104 PyObject *resultobj = 0;
36105 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36106 int result;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 PyObject *swig_obj[1] ;
36110
36111 if (!args) SWIG_fail;
36112 swig_obj[0] = args;
36113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36114 if (!SWIG_IsOK(res1)) {
36115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36116 }
36117 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36118 {
36119 PyThreadState* __tstate = wxPyBeginAllowThreads();
36120 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36121 wxPyEndAllowThreads(__tstate);
36122 if (PyErr_Occurred()) SWIG_fail;
36123 }
36124 resultobj = SWIG_From_int(static_cast< int >(result));
36125 return resultobj;
36126 fail:
36127 return NULL;
36128 }
36129
36130
36131 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36132 PyObject *resultobj = 0;
36133 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36134 bool result;
36135 void *argp1 = 0 ;
36136 int res1 = 0 ;
36137 PyObject *swig_obj[1] ;
36138
36139 if (!args) SWIG_fail;
36140 swig_obj[0] = args;
36141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36142 if (!SWIG_IsOK(res1)) {
36143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36144 }
36145 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36146 {
36147 PyThreadState* __tstate = wxPyBeginAllowThreads();
36148 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36149 wxPyEndAllowThreads(__tstate);
36150 if (PyErr_Occurred()) SWIG_fail;
36151 }
36152 {
36153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36154 }
36155 return resultobj;
36156 fail:
36157 return NULL;
36158 }
36159
36160
36161 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36162 PyObject *resultobj = 0;
36163 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36164 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36165 bool result;
36166 void *argp1 = 0 ;
36167 int res1 = 0 ;
36168 void *argp2 = 0 ;
36169 int res2 = 0 ;
36170 PyObject * obj0 = 0 ;
36171 PyObject * obj1 = 0 ;
36172 char * kwnames[] = {
36173 (char *) "self",(char *) "other", NULL
36174 };
36175
36176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36178 if (!SWIG_IsOK(res1)) {
36179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36180 }
36181 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36183 if (!SWIG_IsOK(res2)) {
36184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36185 }
36186 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36187 {
36188 PyThreadState* __tstate = wxPyBeginAllowThreads();
36189 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36190 wxPyEndAllowThreads(__tstate);
36191 if (PyErr_Occurred()) SWIG_fail;
36192 }
36193 {
36194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36195 }
36196 return resultobj;
36197 fail:
36198 return NULL;
36199 }
36200
36201
36202 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36203 PyObject *resultobj = 0;
36204 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36205 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36206 bool result;
36207 void *argp1 = 0 ;
36208 int res1 = 0 ;
36209 void *argp2 = 0 ;
36210 int res2 = 0 ;
36211 PyObject * obj0 = 0 ;
36212 PyObject * obj1 = 0 ;
36213 char * kwnames[] = {
36214 (char *) "self",(char *) "other", NULL
36215 };
36216
36217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36219 if (!SWIG_IsOK(res1)) {
36220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36221 }
36222 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36224 if (!SWIG_IsOK(res2)) {
36225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36226 }
36227 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36231 wxPyEndAllowThreads(__tstate);
36232 if (PyErr_Occurred()) SWIG_fail;
36233 }
36234 {
36235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36236 }
36237 return resultobj;
36238 fail:
36239 return NULL;
36240 }
36241
36242
36243 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36244 PyObject *resultobj = 0;
36245 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36246 int arg2 ;
36247 void *argp1 = 0 ;
36248 int res1 = 0 ;
36249 int val2 ;
36250 int ecode2 = 0 ;
36251 PyObject *swig_obj[2] ;
36252
36253 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36255 if (!SWIG_IsOK(res1)) {
36256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36257 }
36258 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36259 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36260 if (!SWIG_IsOK(ecode2)) {
36261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36262 }
36263 arg2 = static_cast< int >(val2);
36264 if (arg1) (arg1)->w = arg2;
36265
36266 resultobj = SWIG_Py_Void();
36267 return resultobj;
36268 fail:
36269 return NULL;
36270 }
36271
36272
36273 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36274 PyObject *resultobj = 0;
36275 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36276 int result;
36277 void *argp1 = 0 ;
36278 int res1 = 0 ;
36279 PyObject *swig_obj[1] ;
36280
36281 if (!args) SWIG_fail;
36282 swig_obj[0] = args;
36283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36284 if (!SWIG_IsOK(res1)) {
36285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36286 }
36287 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36288 result = (int) ((arg1)->w);
36289 resultobj = SWIG_From_int(static_cast< int >(result));
36290 return resultobj;
36291 fail:
36292 return NULL;
36293 }
36294
36295
36296 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36297 PyObject *resultobj = 0;
36298 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36299 int arg2 ;
36300 void *argp1 = 0 ;
36301 int res1 = 0 ;
36302 int val2 ;
36303 int ecode2 = 0 ;
36304 PyObject *swig_obj[2] ;
36305
36306 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36308 if (!SWIG_IsOK(res1)) {
36309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36310 }
36311 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36312 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36313 if (!SWIG_IsOK(ecode2)) {
36314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36315 }
36316 arg2 = static_cast< int >(val2);
36317 if (arg1) (arg1)->h = arg2;
36318
36319 resultobj = SWIG_Py_Void();
36320 return resultobj;
36321 fail:
36322 return NULL;
36323 }
36324
36325
36326 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36327 PyObject *resultobj = 0;
36328 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36329 int result;
36330 void *argp1 = 0 ;
36331 int res1 = 0 ;
36332 PyObject *swig_obj[1] ;
36333
36334 if (!args) SWIG_fail;
36335 swig_obj[0] = args;
36336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36337 if (!SWIG_IsOK(res1)) {
36338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36339 }
36340 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36341 result = (int) ((arg1)->h);
36342 resultobj = SWIG_From_int(static_cast< int >(result));
36343 return resultobj;
36344 fail:
36345 return NULL;
36346 }
36347
36348
36349 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36350 PyObject *resultobj = 0;
36351 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36352 int arg2 ;
36353 void *argp1 = 0 ;
36354 int res1 = 0 ;
36355 int val2 ;
36356 int ecode2 = 0 ;
36357 PyObject *swig_obj[2] ;
36358
36359 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36361 if (!SWIG_IsOK(res1)) {
36362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36363 }
36364 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36365 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36366 if (!SWIG_IsOK(ecode2)) {
36367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36368 }
36369 arg2 = static_cast< int >(val2);
36370 if (arg1) (arg1)->bpp = arg2;
36371
36372 resultobj = SWIG_Py_Void();
36373 return resultobj;
36374 fail:
36375 return NULL;
36376 }
36377
36378
36379 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36380 PyObject *resultobj = 0;
36381 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36382 int result;
36383 void *argp1 = 0 ;
36384 int res1 = 0 ;
36385 PyObject *swig_obj[1] ;
36386
36387 if (!args) SWIG_fail;
36388 swig_obj[0] = args;
36389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36390 if (!SWIG_IsOK(res1)) {
36391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36392 }
36393 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36394 result = (int) ((arg1)->bpp);
36395 resultobj = SWIG_From_int(static_cast< int >(result));
36396 return resultobj;
36397 fail:
36398 return NULL;
36399 }
36400
36401
36402 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36403 PyObject *resultobj = 0;
36404 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36405 int arg2 ;
36406 void *argp1 = 0 ;
36407 int res1 = 0 ;
36408 int val2 ;
36409 int ecode2 = 0 ;
36410 PyObject *swig_obj[2] ;
36411
36412 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36414 if (!SWIG_IsOK(res1)) {
36415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36416 }
36417 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36418 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36419 if (!SWIG_IsOK(ecode2)) {
36420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36421 }
36422 arg2 = static_cast< int >(val2);
36423 if (arg1) (arg1)->refresh = arg2;
36424
36425 resultobj = SWIG_Py_Void();
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36433 PyObject *resultobj = 0;
36434 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36435 int result;
36436 void *argp1 = 0 ;
36437 int res1 = 0 ;
36438 PyObject *swig_obj[1] ;
36439
36440 if (!args) SWIG_fail;
36441 swig_obj[0] = args;
36442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36443 if (!SWIG_IsOK(res1)) {
36444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36445 }
36446 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36447 result = (int) ((arg1)->refresh);
36448 resultobj = SWIG_From_int(static_cast< int >(result));
36449 return resultobj;
36450 fail:
36451 return NULL;
36452 }
36453
36454
36455 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36456 PyObject *obj;
36457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36458 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36459 return SWIG_Py_Void();
36460 }
36461
36462 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36463 return SWIG_Python_InitShadowInstance(args);
36464 }
36465
36466 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36467 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36468 return 1;
36469 }
36470
36471
36472 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36473 PyObject *pyobj = 0;
36474
36475 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36476 return pyobj;
36477 }
36478
36479
36480 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36481 PyObject *resultobj = 0;
36482 unsigned int arg1 = (unsigned int) 0 ;
36483 wxDisplay *result = 0 ;
36484 unsigned int val1 ;
36485 int ecode1 = 0 ;
36486 PyObject * obj0 = 0 ;
36487 char * kwnames[] = {
36488 (char *) "index", NULL
36489 };
36490
36491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36492 if (obj0) {
36493 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36494 if (!SWIG_IsOK(ecode1)) {
36495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36496 }
36497 arg1 = static_cast< unsigned int >(val1);
36498 }
36499 {
36500 PyThreadState* __tstate = wxPyBeginAllowThreads();
36501 result = (wxDisplay *)new wxDisplay(arg1);
36502 wxPyEndAllowThreads(__tstate);
36503 if (PyErr_Occurred()) SWIG_fail;
36504 }
36505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36506 return resultobj;
36507 fail:
36508 return NULL;
36509 }
36510
36511
36512 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36513 PyObject *resultobj = 0;
36514 wxDisplay *arg1 = (wxDisplay *) 0 ;
36515 void *argp1 = 0 ;
36516 int res1 = 0 ;
36517 PyObject *swig_obj[1] ;
36518
36519 if (!args) SWIG_fail;
36520 swig_obj[0] = args;
36521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36522 if (!SWIG_IsOK(res1)) {
36523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36524 }
36525 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36526 {
36527 PyThreadState* __tstate = wxPyBeginAllowThreads();
36528 delete arg1;
36529
36530 wxPyEndAllowThreads(__tstate);
36531 if (PyErr_Occurred()) SWIG_fail;
36532 }
36533 resultobj = SWIG_Py_Void();
36534 return resultobj;
36535 fail:
36536 return NULL;
36537 }
36538
36539
36540 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36541 PyObject *resultobj = 0;
36542 unsigned int result;
36543
36544 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36545 {
36546 PyThreadState* __tstate = wxPyBeginAllowThreads();
36547 result = (unsigned int)wxDisplay::GetCount();
36548 wxPyEndAllowThreads(__tstate);
36549 if (PyErr_Occurred()) SWIG_fail;
36550 }
36551 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36552 return resultobj;
36553 fail:
36554 return NULL;
36555 }
36556
36557
36558 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36559 PyObject *resultobj = 0;
36560 wxPoint *arg1 = 0 ;
36561 int result;
36562 wxPoint temp1 ;
36563 PyObject * obj0 = 0 ;
36564 char * kwnames[] = {
36565 (char *) "pt", NULL
36566 };
36567
36568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36569 {
36570 arg1 = &temp1;
36571 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36572 }
36573 {
36574 PyThreadState* __tstate = wxPyBeginAllowThreads();
36575 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36576 wxPyEndAllowThreads(__tstate);
36577 if (PyErr_Occurred()) SWIG_fail;
36578 }
36579 resultobj = SWIG_From_int(static_cast< int >(result));
36580 return resultobj;
36581 fail:
36582 return NULL;
36583 }
36584
36585
36586 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36587 PyObject *resultobj = 0;
36588 wxWindow *arg1 = (wxWindow *) 0 ;
36589 int result;
36590 void *argp1 = 0 ;
36591 int res1 = 0 ;
36592 PyObject * obj0 = 0 ;
36593 char * kwnames[] = {
36594 (char *) "window", NULL
36595 };
36596
36597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36599 if (!SWIG_IsOK(res1)) {
36600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow const *""'");
36601 }
36602 arg1 = reinterpret_cast< wxWindow * >(argp1);
36603 {
36604 PyThreadState* __tstate = wxPyBeginAllowThreads();
36605 result = (int)wxDisplay::GetFromWindow((wxWindow const *)arg1);
36606 wxPyEndAllowThreads(__tstate);
36607 if (PyErr_Occurred()) SWIG_fail;
36608 }
36609 resultobj = SWIG_From_int(static_cast< int >(result));
36610 return resultobj;
36611 fail:
36612 return NULL;
36613 }
36614
36615
36616 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36617 PyObject *resultobj = 0;
36618 wxDisplay *arg1 = (wxDisplay *) 0 ;
36619 bool result;
36620 void *argp1 = 0 ;
36621 int res1 = 0 ;
36622 PyObject *swig_obj[1] ;
36623
36624 if (!args) SWIG_fail;
36625 swig_obj[0] = args;
36626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36627 if (!SWIG_IsOK(res1)) {
36628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36629 }
36630 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36631 {
36632 PyThreadState* __tstate = wxPyBeginAllowThreads();
36633 result = (bool)((wxDisplay const *)arg1)->IsOk();
36634 wxPyEndAllowThreads(__tstate);
36635 if (PyErr_Occurred()) SWIG_fail;
36636 }
36637 {
36638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36639 }
36640 return resultobj;
36641 fail:
36642 return NULL;
36643 }
36644
36645
36646 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36647 PyObject *resultobj = 0;
36648 wxDisplay *arg1 = (wxDisplay *) 0 ;
36649 wxRect result;
36650 void *argp1 = 0 ;
36651 int res1 = 0 ;
36652 PyObject *swig_obj[1] ;
36653
36654 if (!args) SWIG_fail;
36655 swig_obj[0] = args;
36656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36657 if (!SWIG_IsOK(res1)) {
36658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36659 }
36660 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36661 {
36662 PyThreadState* __tstate = wxPyBeginAllowThreads();
36663 result = ((wxDisplay const *)arg1)->GetGeometry();
36664 wxPyEndAllowThreads(__tstate);
36665 if (PyErr_Occurred()) SWIG_fail;
36666 }
36667 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36668 return resultobj;
36669 fail:
36670 return NULL;
36671 }
36672
36673
36674 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36675 PyObject *resultobj = 0;
36676 wxDisplay *arg1 = (wxDisplay *) 0 ;
36677 wxRect result;
36678 void *argp1 = 0 ;
36679 int res1 = 0 ;
36680 PyObject *swig_obj[1] ;
36681
36682 if (!args) SWIG_fail;
36683 swig_obj[0] = args;
36684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36685 if (!SWIG_IsOK(res1)) {
36686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36687 }
36688 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36689 {
36690 PyThreadState* __tstate = wxPyBeginAllowThreads();
36691 result = ((wxDisplay const *)arg1)->GetClientArea();
36692 wxPyEndAllowThreads(__tstate);
36693 if (PyErr_Occurred()) SWIG_fail;
36694 }
36695 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36703 PyObject *resultobj = 0;
36704 wxDisplay *arg1 = (wxDisplay *) 0 ;
36705 wxString result;
36706 void *argp1 = 0 ;
36707 int res1 = 0 ;
36708 PyObject *swig_obj[1] ;
36709
36710 if (!args) SWIG_fail;
36711 swig_obj[0] = args;
36712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36713 if (!SWIG_IsOK(res1)) {
36714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36715 }
36716 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 result = ((wxDisplay const *)arg1)->GetName();
36720 wxPyEndAllowThreads(__tstate);
36721 if (PyErr_Occurred()) SWIG_fail;
36722 }
36723 {
36724 #if wxUSE_UNICODE
36725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36726 #else
36727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36728 #endif
36729 }
36730 return resultobj;
36731 fail:
36732 return NULL;
36733 }
36734
36735
36736 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36737 PyObject *resultobj = 0;
36738 wxDisplay *arg1 = (wxDisplay *) 0 ;
36739 bool result;
36740 void *argp1 = 0 ;
36741 int res1 = 0 ;
36742 PyObject *swig_obj[1] ;
36743
36744 if (!args) SWIG_fail;
36745 swig_obj[0] = args;
36746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36747 if (!SWIG_IsOK(res1)) {
36748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36749 }
36750 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36751 {
36752 PyThreadState* __tstate = wxPyBeginAllowThreads();
36753 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36754 wxPyEndAllowThreads(__tstate);
36755 if (PyErr_Occurred()) SWIG_fail;
36756 }
36757 {
36758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36759 }
36760 return resultobj;
36761 fail:
36762 return NULL;
36763 }
36764
36765
36766 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36767 PyObject *resultobj = 0;
36768 wxDisplay *arg1 = (wxDisplay *) 0 ;
36769 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36770 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36771 PyObject *result = 0 ;
36772 void *argp1 = 0 ;
36773 int res1 = 0 ;
36774 void *argp2 = 0 ;
36775 int res2 = 0 ;
36776 PyObject * obj0 = 0 ;
36777 PyObject * obj1 = 0 ;
36778 char * kwnames[] = {
36779 (char *) "self",(char *) "mode", NULL
36780 };
36781
36782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36784 if (!SWIG_IsOK(res1)) {
36785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36786 }
36787 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36788 if (obj1) {
36789 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36790 if (!SWIG_IsOK(res2)) {
36791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36792 }
36793 if (!argp2) {
36794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36795 }
36796 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36797 }
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 resultobj = result;
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36812 PyObject *resultobj = 0;
36813 wxDisplay *arg1 = (wxDisplay *) 0 ;
36814 wxVideoMode result;
36815 void *argp1 = 0 ;
36816 int res1 = 0 ;
36817 PyObject *swig_obj[1] ;
36818
36819 if (!args) SWIG_fail;
36820 swig_obj[0] = args;
36821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36822 if (!SWIG_IsOK(res1)) {
36823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36824 }
36825 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36829 wxPyEndAllowThreads(__tstate);
36830 if (PyErr_Occurred()) SWIG_fail;
36831 }
36832 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36833 return resultobj;
36834 fail:
36835 return NULL;
36836 }
36837
36838
36839 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36840 PyObject *resultobj = 0;
36841 wxDisplay *arg1 = (wxDisplay *) 0 ;
36842 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36843 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36844 bool result;
36845 void *argp1 = 0 ;
36846 int res1 = 0 ;
36847 void *argp2 = 0 ;
36848 int res2 = 0 ;
36849 PyObject * obj0 = 0 ;
36850 PyObject * obj1 = 0 ;
36851 char * kwnames[] = {
36852 (char *) "self",(char *) "mode", NULL
36853 };
36854
36855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36857 if (!SWIG_IsOK(res1)) {
36858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36859 }
36860 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36861 if (obj1) {
36862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36863 if (!SWIG_IsOK(res2)) {
36864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36865 }
36866 if (!argp2) {
36867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36868 }
36869 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36870 }
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 {
36878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36879 }
36880 return resultobj;
36881 fail:
36882 return NULL;
36883 }
36884
36885
36886 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36887 PyObject *resultobj = 0;
36888 wxDisplay *arg1 = (wxDisplay *) 0 ;
36889 void *argp1 = 0 ;
36890 int res1 = 0 ;
36891 PyObject *swig_obj[1] ;
36892
36893 if (!args) SWIG_fail;
36894 swig_obj[0] = args;
36895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36896 if (!SWIG_IsOK(res1)) {
36897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36898 }
36899 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36900 {
36901 PyThreadState* __tstate = wxPyBeginAllowThreads();
36902 wxDisplay_ResetMode(arg1);
36903 wxPyEndAllowThreads(__tstate);
36904 if (PyErr_Occurred()) SWIG_fail;
36905 }
36906 resultobj = SWIG_Py_Void();
36907 return resultobj;
36908 fail:
36909 return NULL;
36910 }
36911
36912
36913 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36914 PyObject *obj;
36915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36916 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36917 return SWIG_Py_Void();
36918 }
36919
36920 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36921 return SWIG_Python_InitShadowInstance(args);
36922 }
36923
36924 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36925 PyObject *resultobj = 0;
36926 wxStandardPaths *result = 0 ;
36927
36928 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36929 {
36930 PyThreadState* __tstate = wxPyBeginAllowThreads();
36931 result = (wxStandardPaths *)wxStandardPaths_Get();
36932 wxPyEndAllowThreads(__tstate);
36933 if (PyErr_Occurred()) SWIG_fail;
36934 }
36935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36936 return resultobj;
36937 fail:
36938 return NULL;
36939 }
36940
36941
36942 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36943 PyObject *resultobj = 0;
36944 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36945 wxString result;
36946 void *argp1 = 0 ;
36947 int res1 = 0 ;
36948 PyObject *swig_obj[1] ;
36949
36950 if (!args) SWIG_fail;
36951 swig_obj[0] = args;
36952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36953 if (!SWIG_IsOK(res1)) {
36954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36955 }
36956 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36957 {
36958 PyThreadState* __tstate = wxPyBeginAllowThreads();
36959 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36960 wxPyEndAllowThreads(__tstate);
36961 if (PyErr_Occurred()) SWIG_fail;
36962 }
36963 {
36964 #if wxUSE_UNICODE
36965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36966 #else
36967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36968 #endif
36969 }
36970 return resultobj;
36971 fail:
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36977 PyObject *resultobj = 0;
36978 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36979 wxString result;
36980 void *argp1 = 0 ;
36981 int res1 = 0 ;
36982 PyObject *swig_obj[1] ;
36983
36984 if (!args) SWIG_fail;
36985 swig_obj[0] = args;
36986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36987 if (!SWIG_IsOK(res1)) {
36988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36989 }
36990 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36991 {
36992 PyThreadState* __tstate = wxPyBeginAllowThreads();
36993 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36994 wxPyEndAllowThreads(__tstate);
36995 if (PyErr_Occurred()) SWIG_fail;
36996 }
36997 {
36998 #if wxUSE_UNICODE
36999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37000 #else
37001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37002 #endif
37003 }
37004 return resultobj;
37005 fail:
37006 return NULL;
37007 }
37008
37009
37010 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37011 PyObject *resultobj = 0;
37012 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37013 wxString result;
37014 void *argp1 = 0 ;
37015 int res1 = 0 ;
37016 PyObject *swig_obj[1] ;
37017
37018 if (!args) SWIG_fail;
37019 swig_obj[0] = args;
37020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37021 if (!SWIG_IsOK(res1)) {
37022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37023 }
37024 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37025 {
37026 PyThreadState* __tstate = wxPyBeginAllowThreads();
37027 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
37028 wxPyEndAllowThreads(__tstate);
37029 if (PyErr_Occurred()) SWIG_fail;
37030 }
37031 {
37032 #if wxUSE_UNICODE
37033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37034 #else
37035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37036 #endif
37037 }
37038 return resultobj;
37039 fail:
37040 return NULL;
37041 }
37042
37043
37044 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37045 PyObject *resultobj = 0;
37046 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37047 wxString result;
37048 void *argp1 = 0 ;
37049 int res1 = 0 ;
37050 PyObject *swig_obj[1] ;
37051
37052 if (!args) SWIG_fail;
37053 swig_obj[0] = args;
37054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37055 if (!SWIG_IsOK(res1)) {
37056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37057 }
37058 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37059 {
37060 PyThreadState* __tstate = wxPyBeginAllowThreads();
37061 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37062 wxPyEndAllowThreads(__tstate);
37063 if (PyErr_Occurred()) SWIG_fail;
37064 }
37065 {
37066 #if wxUSE_UNICODE
37067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37068 #else
37069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37070 #endif
37071 }
37072 return resultobj;
37073 fail:
37074 return NULL;
37075 }
37076
37077
37078 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37079 PyObject *resultobj = 0;
37080 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37081 wxString result;
37082 void *argp1 = 0 ;
37083 int res1 = 0 ;
37084 PyObject *swig_obj[1] ;
37085
37086 if (!args) SWIG_fail;
37087 swig_obj[0] = args;
37088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37089 if (!SWIG_IsOK(res1)) {
37090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37091 }
37092 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37093 {
37094 PyThreadState* __tstate = wxPyBeginAllowThreads();
37095 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37096 wxPyEndAllowThreads(__tstate);
37097 if (PyErr_Occurred()) SWIG_fail;
37098 }
37099 {
37100 #if wxUSE_UNICODE
37101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37102 #else
37103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37104 #endif
37105 }
37106 return resultobj;
37107 fail:
37108 return NULL;
37109 }
37110
37111
37112 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37113 PyObject *resultobj = 0;
37114 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37115 wxString result;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 PyObject *swig_obj[1] ;
37119
37120 if (!args) SWIG_fail;
37121 swig_obj[0] = args;
37122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37123 if (!SWIG_IsOK(res1)) {
37124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37125 }
37126 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37127 {
37128 PyThreadState* __tstate = wxPyBeginAllowThreads();
37129 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37130 wxPyEndAllowThreads(__tstate);
37131 if (PyErr_Occurred()) SWIG_fail;
37132 }
37133 {
37134 #if wxUSE_UNICODE
37135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37136 #else
37137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37138 #endif
37139 }
37140 return resultobj;
37141 fail:
37142 return NULL;
37143 }
37144
37145
37146 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37147 PyObject *resultobj = 0;
37148 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37149 wxString result;
37150 void *argp1 = 0 ;
37151 int res1 = 0 ;
37152 PyObject *swig_obj[1] ;
37153
37154 if (!args) SWIG_fail;
37155 swig_obj[0] = args;
37156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37157 if (!SWIG_IsOK(res1)) {
37158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37159 }
37160 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37161 {
37162 PyThreadState* __tstate = wxPyBeginAllowThreads();
37163 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37164 wxPyEndAllowThreads(__tstate);
37165 if (PyErr_Occurred()) SWIG_fail;
37166 }
37167 {
37168 #if wxUSE_UNICODE
37169 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37170 #else
37171 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37172 #endif
37173 }
37174 return resultobj;
37175 fail:
37176 return NULL;
37177 }
37178
37179
37180 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37181 PyObject *resultobj = 0;
37182 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37183 wxString result;
37184 void *argp1 = 0 ;
37185 int res1 = 0 ;
37186 PyObject *swig_obj[1] ;
37187
37188 if (!args) SWIG_fail;
37189 swig_obj[0] = args;
37190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37191 if (!SWIG_IsOK(res1)) {
37192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37193 }
37194 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37195 {
37196 PyThreadState* __tstate = wxPyBeginAllowThreads();
37197 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37198 wxPyEndAllowThreads(__tstate);
37199 if (PyErr_Occurred()) SWIG_fail;
37200 }
37201 {
37202 #if wxUSE_UNICODE
37203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37204 #else
37205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37206 #endif
37207 }
37208 return resultobj;
37209 fail:
37210 return NULL;
37211 }
37212
37213
37214 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37215 PyObject *resultobj = 0;
37216 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37217 wxString result;
37218 void *argp1 = 0 ;
37219 int res1 = 0 ;
37220 PyObject *swig_obj[1] ;
37221
37222 if (!args) SWIG_fail;
37223 swig_obj[0] = args;
37224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37225 if (!SWIG_IsOK(res1)) {
37226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37227 }
37228 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37229 {
37230 PyThreadState* __tstate = wxPyBeginAllowThreads();
37231 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37232 wxPyEndAllowThreads(__tstate);
37233 if (PyErr_Occurred()) SWIG_fail;
37234 }
37235 {
37236 #if wxUSE_UNICODE
37237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37238 #else
37239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37240 #endif
37241 }
37242 return resultobj;
37243 fail:
37244 return NULL;
37245 }
37246
37247
37248 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37249 PyObject *resultobj = 0;
37250 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37251 wxString *arg2 = 0 ;
37252 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37253 wxString result;
37254 void *argp1 = 0 ;
37255 int res1 = 0 ;
37256 bool temp2 = false ;
37257 int val3 ;
37258 int ecode3 = 0 ;
37259 PyObject * obj0 = 0 ;
37260 PyObject * obj1 = 0 ;
37261 PyObject * obj2 = 0 ;
37262 char * kwnames[] = {
37263 (char *) "self",(char *) "lang",(char *) "category", NULL
37264 };
37265
37266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37268 if (!SWIG_IsOK(res1)) {
37269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37270 }
37271 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37272 {
37273 arg2 = wxString_in_helper(obj1);
37274 if (arg2 == NULL) SWIG_fail;
37275 temp2 = true;
37276 }
37277 if (obj2) {
37278 ecode3 = SWIG_AsVal_int(obj2, &val3);
37279 if (!SWIG_IsOK(ecode3)) {
37280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37281 }
37282 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37283 }
37284 {
37285 PyThreadState* __tstate = wxPyBeginAllowThreads();
37286 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37287 wxPyEndAllowThreads(__tstate);
37288 if (PyErr_Occurred()) SWIG_fail;
37289 }
37290 {
37291 #if wxUSE_UNICODE
37292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37293 #else
37294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37295 #endif
37296 }
37297 {
37298 if (temp2)
37299 delete arg2;
37300 }
37301 return resultobj;
37302 fail:
37303 {
37304 if (temp2)
37305 delete arg2;
37306 }
37307 return NULL;
37308 }
37309
37310
37311 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37312 PyObject *resultobj = 0;
37313 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37314 wxString result;
37315 void *argp1 = 0 ;
37316 int res1 = 0 ;
37317 PyObject *swig_obj[1] ;
37318
37319 if (!args) SWIG_fail;
37320 swig_obj[0] = args;
37321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37322 if (!SWIG_IsOK(res1)) {
37323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37324 }
37325 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37326 {
37327 PyThreadState* __tstate = wxPyBeginAllowThreads();
37328 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 {
37333 #if wxUSE_UNICODE
37334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37335 #else
37336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37337 #endif
37338 }
37339 return resultobj;
37340 fail:
37341 return NULL;
37342 }
37343
37344
37345 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37346 PyObject *resultobj = 0;
37347 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37348 wxString result;
37349 void *argp1 = 0 ;
37350 int res1 = 0 ;
37351 PyObject *swig_obj[1] ;
37352
37353 if (!args) SWIG_fail;
37354 swig_obj[0] = args;
37355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37356 if (!SWIG_IsOK(res1)) {
37357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37358 }
37359 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37360 {
37361 PyThreadState* __tstate = wxPyBeginAllowThreads();
37362 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37363 wxPyEndAllowThreads(__tstate);
37364 if (PyErr_Occurred()) SWIG_fail;
37365 }
37366 {
37367 #if wxUSE_UNICODE
37368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37369 #else
37370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37371 #endif
37372 }
37373 return resultobj;
37374 fail:
37375 return NULL;
37376 }
37377
37378
37379 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37380 PyObject *resultobj = 0;
37381 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37382 wxString *arg2 = 0 ;
37383 void *argp1 = 0 ;
37384 int res1 = 0 ;
37385 bool temp2 = false ;
37386 PyObject * obj0 = 0 ;
37387 PyObject * obj1 = 0 ;
37388 char * kwnames[] = {
37389 (char *) "self",(char *) "prefix", NULL
37390 };
37391
37392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37394 if (!SWIG_IsOK(res1)) {
37395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37396 }
37397 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37398 {
37399 arg2 = wxString_in_helper(obj1);
37400 if (arg2 == NULL) SWIG_fail;
37401 temp2 = true;
37402 }
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 resultobj = SWIG_Py_Void();
37410 {
37411 if (temp2)
37412 delete arg2;
37413 }
37414 return resultobj;
37415 fail:
37416 {
37417 if (temp2)
37418 delete arg2;
37419 }
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37425 PyObject *resultobj = 0;
37426 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37427 wxString result;
37428 void *argp1 = 0 ;
37429 int res1 = 0 ;
37430 PyObject *swig_obj[1] ;
37431
37432 if (!args) SWIG_fail;
37433 swig_obj[0] = args;
37434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37435 if (!SWIG_IsOK(res1)) {
37436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37437 }
37438 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 {
37446 #if wxUSE_UNICODE
37447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37448 #else
37449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37450 #endif
37451 }
37452 return resultobj;
37453 fail:
37454 return NULL;
37455 }
37456
37457
37458 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37459 PyObject *obj;
37460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37461 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37462 return SWIG_Py_Void();
37463 }
37464
37465 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37466 PyObject *resultobj = 0;
37467 wxEventType arg1 ;
37468 wxPowerEvent *result = 0 ;
37469 int val1 ;
37470 int ecode1 = 0 ;
37471 PyObject * obj0 = 0 ;
37472 char * kwnames[] = {
37473 (char *) "evtType", NULL
37474 };
37475
37476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37477 ecode1 = SWIG_AsVal_int(obj0, &val1);
37478 if (!SWIG_IsOK(ecode1)) {
37479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37480 }
37481 arg1 = static_cast< wxEventType >(val1);
37482 {
37483 PyThreadState* __tstate = wxPyBeginAllowThreads();
37484 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37485 wxPyEndAllowThreads(__tstate);
37486 if (PyErr_Occurred()) SWIG_fail;
37487 }
37488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37489 return resultobj;
37490 fail:
37491 return NULL;
37492 }
37493
37494
37495 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37496 PyObject *resultobj = 0;
37497 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37498 void *argp1 = 0 ;
37499 int res1 = 0 ;
37500 PyObject *swig_obj[1] ;
37501
37502 if (!args) SWIG_fail;
37503 swig_obj[0] = args;
37504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37505 if (!SWIG_IsOK(res1)) {
37506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37507 }
37508 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37509 {
37510 PyThreadState* __tstate = wxPyBeginAllowThreads();
37511 (arg1)->Veto();
37512 wxPyEndAllowThreads(__tstate);
37513 if (PyErr_Occurred()) SWIG_fail;
37514 }
37515 resultobj = SWIG_Py_Void();
37516 return resultobj;
37517 fail:
37518 return NULL;
37519 }
37520
37521
37522 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37523 PyObject *resultobj = 0;
37524 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37525 bool result;
37526 void *argp1 = 0 ;
37527 int res1 = 0 ;
37528 PyObject *swig_obj[1] ;
37529
37530 if (!args) SWIG_fail;
37531 swig_obj[0] = args;
37532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37533 if (!SWIG_IsOK(res1)) {
37534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37535 }
37536 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37540 wxPyEndAllowThreads(__tstate);
37541 if (PyErr_Occurred()) SWIG_fail;
37542 }
37543 {
37544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37545 }
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37553 PyObject *obj;
37554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37555 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37556 return SWIG_Py_Void();
37557 }
37558
37559 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37560 return SWIG_Python_InitShadowInstance(args);
37561 }
37562
37563 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37564 PyObject *resultobj = 0;
37565 wxPowerType result;
37566
37567 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 result = (wxPowerType)wxGetPowerType();
37571 wxPyEndAllowThreads(__tstate);
37572 if (PyErr_Occurred()) SWIG_fail;
37573 }
37574 resultobj = SWIG_From_int(static_cast< int >(result));
37575 return resultobj;
37576 fail:
37577 return NULL;
37578 }
37579
37580
37581 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37582 PyObject *resultobj = 0;
37583 wxBatteryState result;
37584
37585 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37586 {
37587 PyThreadState* __tstate = wxPyBeginAllowThreads();
37588 result = (wxBatteryState)wxGetBatteryState();
37589 wxPyEndAllowThreads(__tstate);
37590 if (PyErr_Occurred()) SWIG_fail;
37591 }
37592 resultobj = SWIG_From_int(static_cast< int >(result));
37593 return resultobj;
37594 fail:
37595 return NULL;
37596 }
37597
37598
37599 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37600 PyObject *resultobj = 0;
37601 wxAboutDialogInfo *result = 0 ;
37602
37603 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37604 {
37605 PyThreadState* __tstate = wxPyBeginAllowThreads();
37606 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37607 wxPyEndAllowThreads(__tstate);
37608 if (PyErr_Occurred()) SWIG_fail;
37609 }
37610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37611 return resultobj;
37612 fail:
37613 return NULL;
37614 }
37615
37616
37617 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37618 PyObject *resultobj = 0;
37619 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37620 void *argp1 = 0 ;
37621 int res1 = 0 ;
37622 PyObject *swig_obj[1] ;
37623
37624 if (!args) SWIG_fail;
37625 swig_obj[0] = args;
37626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37627 if (!SWIG_IsOK(res1)) {
37628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37629 }
37630 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37631 {
37632 PyThreadState* __tstate = wxPyBeginAllowThreads();
37633 delete arg1;
37634
37635 wxPyEndAllowThreads(__tstate);
37636 if (PyErr_Occurred()) SWIG_fail;
37637 }
37638 resultobj = SWIG_Py_Void();
37639 return resultobj;
37640 fail:
37641 return NULL;
37642 }
37643
37644
37645 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37646 PyObject *resultobj = 0;
37647 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37648 wxString *arg2 = 0 ;
37649 void *argp1 = 0 ;
37650 int res1 = 0 ;
37651 bool temp2 = false ;
37652 PyObject * obj0 = 0 ;
37653 PyObject * obj1 = 0 ;
37654 char * kwnames[] = {
37655 (char *) "self",(char *) "name", NULL
37656 };
37657
37658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37660 if (!SWIG_IsOK(res1)) {
37661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37662 }
37663 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37664 {
37665 arg2 = wxString_in_helper(obj1);
37666 if (arg2 == NULL) SWIG_fail;
37667 temp2 = true;
37668 }
37669 {
37670 PyThreadState* __tstate = wxPyBeginAllowThreads();
37671 (arg1)->SetName((wxString const &)*arg2);
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 resultobj = SWIG_Py_Void();
37676 {
37677 if (temp2)
37678 delete arg2;
37679 }
37680 return resultobj;
37681 fail:
37682 {
37683 if (temp2)
37684 delete arg2;
37685 }
37686 return NULL;
37687 }
37688
37689
37690 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37691 PyObject *resultobj = 0;
37692 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37693 wxString result;
37694 void *argp1 = 0 ;
37695 int res1 = 0 ;
37696 PyObject *swig_obj[1] ;
37697
37698 if (!args) SWIG_fail;
37699 swig_obj[0] = args;
37700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37701 if (!SWIG_IsOK(res1)) {
37702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37703 }
37704 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37705 {
37706 PyThreadState* __tstate = wxPyBeginAllowThreads();
37707 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37708 wxPyEndAllowThreads(__tstate);
37709 if (PyErr_Occurred()) SWIG_fail;
37710 }
37711 {
37712 #if wxUSE_UNICODE
37713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37714 #else
37715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37716 #endif
37717 }
37718 return resultobj;
37719 fail:
37720 return NULL;
37721 }
37722
37723
37724 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37725 PyObject *resultobj = 0;
37726 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37727 wxString *arg2 = 0 ;
37728 void *argp1 = 0 ;
37729 int res1 = 0 ;
37730 bool temp2 = false ;
37731 PyObject * obj0 = 0 ;
37732 PyObject * obj1 = 0 ;
37733 char * kwnames[] = {
37734 (char *) "self",(char *) "version", NULL
37735 };
37736
37737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37739 if (!SWIG_IsOK(res1)) {
37740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37741 }
37742 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37743 {
37744 arg2 = wxString_in_helper(obj1);
37745 if (arg2 == NULL) SWIG_fail;
37746 temp2 = true;
37747 }
37748 {
37749 PyThreadState* __tstate = wxPyBeginAllowThreads();
37750 (arg1)->SetVersion((wxString const &)*arg2);
37751 wxPyEndAllowThreads(__tstate);
37752 if (PyErr_Occurred()) SWIG_fail;
37753 }
37754 resultobj = SWIG_Py_Void();
37755 {
37756 if (temp2)
37757 delete arg2;
37758 }
37759 return resultobj;
37760 fail:
37761 {
37762 if (temp2)
37763 delete arg2;
37764 }
37765 return NULL;
37766 }
37767
37768
37769 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37770 PyObject *resultobj = 0;
37771 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37772 bool result;
37773 void *argp1 = 0 ;
37774 int res1 = 0 ;
37775 PyObject *swig_obj[1] ;
37776
37777 if (!args) SWIG_fail;
37778 swig_obj[0] = args;
37779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37780 if (!SWIG_IsOK(res1)) {
37781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37782 }
37783 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37784 {
37785 PyThreadState* __tstate = wxPyBeginAllowThreads();
37786 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37787 wxPyEndAllowThreads(__tstate);
37788 if (PyErr_Occurred()) SWIG_fail;
37789 }
37790 {
37791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37792 }
37793 return resultobj;
37794 fail:
37795 return NULL;
37796 }
37797
37798
37799 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37800 PyObject *resultobj = 0;
37801 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37802 wxString result;
37803 void *argp1 = 0 ;
37804 int res1 = 0 ;
37805 PyObject *swig_obj[1] ;
37806
37807 if (!args) SWIG_fail;
37808 swig_obj[0] = args;
37809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37810 if (!SWIG_IsOK(res1)) {
37811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37812 }
37813 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37814 {
37815 PyThreadState* __tstate = wxPyBeginAllowThreads();
37816 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37817 wxPyEndAllowThreads(__tstate);
37818 if (PyErr_Occurred()) SWIG_fail;
37819 }
37820 {
37821 #if wxUSE_UNICODE
37822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37823 #else
37824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37825 #endif
37826 }
37827 return resultobj;
37828 fail:
37829 return NULL;
37830 }
37831
37832
37833 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37834 PyObject *resultobj = 0;
37835 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37836 wxString *arg2 = 0 ;
37837 void *argp1 = 0 ;
37838 int res1 = 0 ;
37839 bool temp2 = false ;
37840 PyObject * obj0 = 0 ;
37841 PyObject * obj1 = 0 ;
37842 char * kwnames[] = {
37843 (char *) "self",(char *) "desc", NULL
37844 };
37845
37846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37848 if (!SWIG_IsOK(res1)) {
37849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37850 }
37851 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37852 {
37853 arg2 = wxString_in_helper(obj1);
37854 if (arg2 == NULL) SWIG_fail;
37855 temp2 = true;
37856 }
37857 {
37858 PyThreadState* __tstate = wxPyBeginAllowThreads();
37859 (arg1)->SetDescription((wxString const &)*arg2);
37860 wxPyEndAllowThreads(__tstate);
37861 if (PyErr_Occurred()) SWIG_fail;
37862 }
37863 resultobj = SWIG_Py_Void();
37864 {
37865 if (temp2)
37866 delete arg2;
37867 }
37868 return resultobj;
37869 fail:
37870 {
37871 if (temp2)
37872 delete arg2;
37873 }
37874 return NULL;
37875 }
37876
37877
37878 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37879 PyObject *resultobj = 0;
37880 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37881 bool result;
37882 void *argp1 = 0 ;
37883 int res1 = 0 ;
37884 PyObject *swig_obj[1] ;
37885
37886 if (!args) SWIG_fail;
37887 swig_obj[0] = args;
37888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37889 if (!SWIG_IsOK(res1)) {
37890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37891 }
37892 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37893 {
37894 PyThreadState* __tstate = wxPyBeginAllowThreads();
37895 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 {
37900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37901 }
37902 return resultobj;
37903 fail:
37904 return NULL;
37905 }
37906
37907
37908 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37909 PyObject *resultobj = 0;
37910 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37911 wxString result;
37912 void *argp1 = 0 ;
37913 int res1 = 0 ;
37914 PyObject *swig_obj[1] ;
37915
37916 if (!args) SWIG_fail;
37917 swig_obj[0] = args;
37918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37919 if (!SWIG_IsOK(res1)) {
37920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37921 }
37922 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37923 {
37924 PyThreadState* __tstate = wxPyBeginAllowThreads();
37925 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37926 wxPyEndAllowThreads(__tstate);
37927 if (PyErr_Occurred()) SWIG_fail;
37928 }
37929 {
37930 #if wxUSE_UNICODE
37931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37932 #else
37933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37934 #endif
37935 }
37936 return resultobj;
37937 fail:
37938 return NULL;
37939 }
37940
37941
37942 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37943 PyObject *resultobj = 0;
37944 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37945 wxString *arg2 = 0 ;
37946 void *argp1 = 0 ;
37947 int res1 = 0 ;
37948 bool temp2 = false ;
37949 PyObject * obj0 = 0 ;
37950 PyObject * obj1 = 0 ;
37951 char * kwnames[] = {
37952 (char *) "self",(char *) "copyright", NULL
37953 };
37954
37955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37957 if (!SWIG_IsOK(res1)) {
37958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37959 }
37960 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37961 {
37962 arg2 = wxString_in_helper(obj1);
37963 if (arg2 == NULL) SWIG_fail;
37964 temp2 = true;
37965 }
37966 {
37967 PyThreadState* __tstate = wxPyBeginAllowThreads();
37968 (arg1)->SetCopyright((wxString const &)*arg2);
37969 wxPyEndAllowThreads(__tstate);
37970 if (PyErr_Occurred()) SWIG_fail;
37971 }
37972 resultobj = SWIG_Py_Void();
37973 {
37974 if (temp2)
37975 delete arg2;
37976 }
37977 return resultobj;
37978 fail:
37979 {
37980 if (temp2)
37981 delete arg2;
37982 }
37983 return NULL;
37984 }
37985
37986
37987 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37988 PyObject *resultobj = 0;
37989 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37990 bool result;
37991 void *argp1 = 0 ;
37992 int res1 = 0 ;
37993 PyObject *swig_obj[1] ;
37994
37995 if (!args) SWIG_fail;
37996 swig_obj[0] = args;
37997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37998 if (!SWIG_IsOK(res1)) {
37999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38000 }
38001 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38002 {
38003 PyThreadState* __tstate = wxPyBeginAllowThreads();
38004 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 {
38009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38010 }
38011 return resultobj;
38012 fail:
38013 return NULL;
38014 }
38015
38016
38017 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38018 PyObject *resultobj = 0;
38019 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38020 wxString result;
38021 void *argp1 = 0 ;
38022 int res1 = 0 ;
38023 PyObject *swig_obj[1] ;
38024
38025 if (!args) SWIG_fail;
38026 swig_obj[0] = args;
38027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38028 if (!SWIG_IsOK(res1)) {
38029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38030 }
38031 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38032 {
38033 PyThreadState* __tstate = wxPyBeginAllowThreads();
38034 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
38035 wxPyEndAllowThreads(__tstate);
38036 if (PyErr_Occurred()) SWIG_fail;
38037 }
38038 {
38039 #if wxUSE_UNICODE
38040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38041 #else
38042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38043 #endif
38044 }
38045 return resultobj;
38046 fail:
38047 return NULL;
38048 }
38049
38050
38051 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38052 PyObject *resultobj = 0;
38053 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38054 wxString *arg2 = 0 ;
38055 void *argp1 = 0 ;
38056 int res1 = 0 ;
38057 bool temp2 = false ;
38058 PyObject * obj0 = 0 ;
38059 PyObject * obj1 = 0 ;
38060 char * kwnames[] = {
38061 (char *) "self",(char *) "licence", NULL
38062 };
38063
38064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38066 if (!SWIG_IsOK(res1)) {
38067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38068 }
38069 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38070 {
38071 arg2 = wxString_in_helper(obj1);
38072 if (arg2 == NULL) SWIG_fail;
38073 temp2 = true;
38074 }
38075 {
38076 PyThreadState* __tstate = wxPyBeginAllowThreads();
38077 (arg1)->SetLicence((wxString const &)*arg2);
38078 wxPyEndAllowThreads(__tstate);
38079 if (PyErr_Occurred()) SWIG_fail;
38080 }
38081 resultobj = SWIG_Py_Void();
38082 {
38083 if (temp2)
38084 delete arg2;
38085 }
38086 return resultobj;
38087 fail:
38088 {
38089 if (temp2)
38090 delete arg2;
38091 }
38092 return NULL;
38093 }
38094
38095
38096 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38097 PyObject *resultobj = 0;
38098 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38099 wxString *arg2 = 0 ;
38100 void *argp1 = 0 ;
38101 int res1 = 0 ;
38102 bool temp2 = false ;
38103 PyObject * obj0 = 0 ;
38104 PyObject * obj1 = 0 ;
38105 char * kwnames[] = {
38106 (char *) "self",(char *) "licence", NULL
38107 };
38108
38109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38111 if (!SWIG_IsOK(res1)) {
38112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38113 }
38114 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38115 {
38116 arg2 = wxString_in_helper(obj1);
38117 if (arg2 == NULL) SWIG_fail;
38118 temp2 = true;
38119 }
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 (arg1)->SetLicense((wxString const &)*arg2);
38123 wxPyEndAllowThreads(__tstate);
38124 if (PyErr_Occurred()) SWIG_fail;
38125 }
38126 resultobj = SWIG_Py_Void();
38127 {
38128 if (temp2)
38129 delete arg2;
38130 }
38131 return resultobj;
38132 fail:
38133 {
38134 if (temp2)
38135 delete arg2;
38136 }
38137 return NULL;
38138 }
38139
38140
38141 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38142 PyObject *resultobj = 0;
38143 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38144 bool result;
38145 void *argp1 = 0 ;
38146 int res1 = 0 ;
38147 PyObject *swig_obj[1] ;
38148
38149 if (!args) SWIG_fail;
38150 swig_obj[0] = args;
38151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38152 if (!SWIG_IsOK(res1)) {
38153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38154 }
38155 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38156 {
38157 PyThreadState* __tstate = wxPyBeginAllowThreads();
38158 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38159 wxPyEndAllowThreads(__tstate);
38160 if (PyErr_Occurred()) SWIG_fail;
38161 }
38162 {
38163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38164 }
38165 return resultobj;
38166 fail:
38167 return NULL;
38168 }
38169
38170
38171 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38172 PyObject *resultobj = 0;
38173 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38174 wxString result;
38175 void *argp1 = 0 ;
38176 int res1 = 0 ;
38177 PyObject *swig_obj[1] ;
38178
38179 if (!args) SWIG_fail;
38180 swig_obj[0] = args;
38181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38182 if (!SWIG_IsOK(res1)) {
38183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38184 }
38185 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38186 {
38187 PyThreadState* __tstate = wxPyBeginAllowThreads();
38188 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38189 wxPyEndAllowThreads(__tstate);
38190 if (PyErr_Occurred()) SWIG_fail;
38191 }
38192 {
38193 #if wxUSE_UNICODE
38194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38195 #else
38196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38197 #endif
38198 }
38199 return resultobj;
38200 fail:
38201 return NULL;
38202 }
38203
38204
38205 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38206 PyObject *resultobj = 0;
38207 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38208 wxIcon *arg2 = 0 ;
38209 void *argp1 = 0 ;
38210 int res1 = 0 ;
38211 void *argp2 = 0 ;
38212 int res2 = 0 ;
38213 PyObject * obj0 = 0 ;
38214 PyObject * obj1 = 0 ;
38215 char * kwnames[] = {
38216 (char *) "self",(char *) "icon", NULL
38217 };
38218
38219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38221 if (!SWIG_IsOK(res1)) {
38222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38223 }
38224 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38225 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38226 if (!SWIG_IsOK(res2)) {
38227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38228 }
38229 if (!argp2) {
38230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38231 }
38232 arg2 = reinterpret_cast< wxIcon * >(argp2);
38233 {
38234 PyThreadState* __tstate = wxPyBeginAllowThreads();
38235 (arg1)->SetIcon((wxIcon const &)*arg2);
38236 wxPyEndAllowThreads(__tstate);
38237 if (PyErr_Occurred()) SWIG_fail;
38238 }
38239 resultobj = SWIG_Py_Void();
38240 return resultobj;
38241 fail:
38242 return NULL;
38243 }
38244
38245
38246 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38247 PyObject *resultobj = 0;
38248 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38249 bool result;
38250 void *argp1 = 0 ;
38251 int res1 = 0 ;
38252 PyObject *swig_obj[1] ;
38253
38254 if (!args) SWIG_fail;
38255 swig_obj[0] = args;
38256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38257 if (!SWIG_IsOK(res1)) {
38258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38259 }
38260 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38261 {
38262 PyThreadState* __tstate = wxPyBeginAllowThreads();
38263 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38264 wxPyEndAllowThreads(__tstate);
38265 if (PyErr_Occurred()) SWIG_fail;
38266 }
38267 {
38268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38269 }
38270 return resultobj;
38271 fail:
38272 return NULL;
38273 }
38274
38275
38276 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38277 PyObject *resultobj = 0;
38278 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38279 wxIcon result;
38280 void *argp1 = 0 ;
38281 int res1 = 0 ;
38282 PyObject *swig_obj[1] ;
38283
38284 if (!args) SWIG_fail;
38285 swig_obj[0] = args;
38286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38287 if (!SWIG_IsOK(res1)) {
38288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38289 }
38290 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38291 {
38292 PyThreadState* __tstate = wxPyBeginAllowThreads();
38293 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38294 wxPyEndAllowThreads(__tstate);
38295 if (PyErr_Occurred()) SWIG_fail;
38296 }
38297 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38298 return resultobj;
38299 fail:
38300 return NULL;
38301 }
38302
38303
38304 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38305 PyObject *resultobj = 0;
38306 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38307 wxString *arg2 = 0 ;
38308 wxString const &arg3_defvalue = wxEmptyString ;
38309 wxString *arg3 = (wxString *) &arg3_defvalue ;
38310 void *argp1 = 0 ;
38311 int res1 = 0 ;
38312 bool temp2 = false ;
38313 bool temp3 = false ;
38314 PyObject * obj0 = 0 ;
38315 PyObject * obj1 = 0 ;
38316 PyObject * obj2 = 0 ;
38317 char * kwnames[] = {
38318 (char *) "self",(char *) "url",(char *) "desc", NULL
38319 };
38320
38321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38323 if (!SWIG_IsOK(res1)) {
38324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38325 }
38326 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38327 {
38328 arg2 = wxString_in_helper(obj1);
38329 if (arg2 == NULL) SWIG_fail;
38330 temp2 = true;
38331 }
38332 if (obj2) {
38333 {
38334 arg3 = wxString_in_helper(obj2);
38335 if (arg3 == NULL) SWIG_fail;
38336 temp3 = true;
38337 }
38338 }
38339 {
38340 PyThreadState* __tstate = wxPyBeginAllowThreads();
38341 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38342 wxPyEndAllowThreads(__tstate);
38343 if (PyErr_Occurred()) SWIG_fail;
38344 }
38345 resultobj = SWIG_Py_Void();
38346 {
38347 if (temp2)
38348 delete arg2;
38349 }
38350 {
38351 if (temp3)
38352 delete arg3;
38353 }
38354 return resultobj;
38355 fail:
38356 {
38357 if (temp2)
38358 delete arg2;
38359 }
38360 {
38361 if (temp3)
38362 delete arg3;
38363 }
38364 return NULL;
38365 }
38366
38367
38368 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38369 PyObject *resultobj = 0;
38370 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38371 wxString result;
38372 void *argp1 = 0 ;
38373 int res1 = 0 ;
38374 PyObject *swig_obj[1] ;
38375
38376 if (!args) SWIG_fail;
38377 swig_obj[0] = args;
38378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38379 if (!SWIG_IsOK(res1)) {
38380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38381 }
38382 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38383 {
38384 PyThreadState* __tstate = wxPyBeginAllowThreads();
38385 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38386 wxPyEndAllowThreads(__tstate);
38387 if (PyErr_Occurred()) SWIG_fail;
38388 }
38389 {
38390 #if wxUSE_UNICODE
38391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38392 #else
38393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38394 #endif
38395 }
38396 return resultobj;
38397 fail:
38398 return NULL;
38399 }
38400
38401
38402 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38403 PyObject *resultobj = 0;
38404 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38405 wxString result;
38406 void *argp1 = 0 ;
38407 int res1 = 0 ;
38408 PyObject *swig_obj[1] ;
38409
38410 if (!args) SWIG_fail;
38411 swig_obj[0] = args;
38412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38413 if (!SWIG_IsOK(res1)) {
38414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38415 }
38416 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38417 {
38418 PyThreadState* __tstate = wxPyBeginAllowThreads();
38419 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38420 wxPyEndAllowThreads(__tstate);
38421 if (PyErr_Occurred()) SWIG_fail;
38422 }
38423 {
38424 #if wxUSE_UNICODE
38425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38426 #else
38427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38428 #endif
38429 }
38430 return resultobj;
38431 fail:
38432 return NULL;
38433 }
38434
38435
38436 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38437 PyObject *resultobj = 0;
38438 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38439 bool result;
38440 void *argp1 = 0 ;
38441 int res1 = 0 ;
38442 PyObject *swig_obj[1] ;
38443
38444 if (!args) SWIG_fail;
38445 swig_obj[0] = args;
38446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38447 if (!SWIG_IsOK(res1)) {
38448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38449 }
38450 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38451 {
38452 PyThreadState* __tstate = wxPyBeginAllowThreads();
38453 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38454 wxPyEndAllowThreads(__tstate);
38455 if (PyErr_Occurred()) SWIG_fail;
38456 }
38457 {
38458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38459 }
38460 return resultobj;
38461 fail:
38462 return NULL;
38463 }
38464
38465
38466 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38467 PyObject *resultobj = 0;
38468 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38469 wxArrayString *arg2 = 0 ;
38470 void *argp1 = 0 ;
38471 int res1 = 0 ;
38472 bool temp2 = false ;
38473 PyObject * obj0 = 0 ;
38474 PyObject * obj1 = 0 ;
38475 char * kwnames[] = {
38476 (char *) "self",(char *) "developers", NULL
38477 };
38478
38479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38481 if (!SWIG_IsOK(res1)) {
38482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38483 }
38484 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38485 {
38486 if (! PySequence_Check(obj1)) {
38487 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38488 SWIG_fail;
38489 }
38490 arg2 = new wxArrayString;
38491 temp2 = true;
38492 int i, len=PySequence_Length(obj1);
38493 for (i=0; i<len; i++) {
38494 PyObject* item = PySequence_GetItem(obj1, i);
38495 wxString* s = wxString_in_helper(item);
38496 if (PyErr_Occurred()) SWIG_fail;
38497 arg2->Add(*s);
38498 delete s;
38499 Py_DECREF(item);
38500 }
38501 }
38502 {
38503 PyThreadState* __tstate = wxPyBeginAllowThreads();
38504 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38505 wxPyEndAllowThreads(__tstate);
38506 if (PyErr_Occurred()) SWIG_fail;
38507 }
38508 resultobj = SWIG_Py_Void();
38509 {
38510 if (temp2) delete arg2;
38511 }
38512 return resultobj;
38513 fail:
38514 {
38515 if (temp2) delete arg2;
38516 }
38517 return NULL;
38518 }
38519
38520
38521 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38522 PyObject *resultobj = 0;
38523 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38524 wxString *arg2 = 0 ;
38525 void *argp1 = 0 ;
38526 int res1 = 0 ;
38527 bool temp2 = false ;
38528 PyObject * obj0 = 0 ;
38529 PyObject * obj1 = 0 ;
38530 char * kwnames[] = {
38531 (char *) "self",(char *) "developer", NULL
38532 };
38533
38534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38536 if (!SWIG_IsOK(res1)) {
38537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38538 }
38539 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38540 {
38541 arg2 = wxString_in_helper(obj1);
38542 if (arg2 == NULL) SWIG_fail;
38543 temp2 = true;
38544 }
38545 {
38546 PyThreadState* __tstate = wxPyBeginAllowThreads();
38547 (arg1)->AddDeveloper((wxString const &)*arg2);
38548 wxPyEndAllowThreads(__tstate);
38549 if (PyErr_Occurred()) SWIG_fail;
38550 }
38551 resultobj = SWIG_Py_Void();
38552 {
38553 if (temp2)
38554 delete arg2;
38555 }
38556 return resultobj;
38557 fail:
38558 {
38559 if (temp2)
38560 delete arg2;
38561 }
38562 return NULL;
38563 }
38564
38565
38566 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38567 PyObject *resultobj = 0;
38568 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38569 bool result;
38570 void *argp1 = 0 ;
38571 int res1 = 0 ;
38572 PyObject *swig_obj[1] ;
38573
38574 if (!args) SWIG_fail;
38575 swig_obj[0] = args;
38576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38577 if (!SWIG_IsOK(res1)) {
38578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38579 }
38580 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38581 {
38582 PyThreadState* __tstate = wxPyBeginAllowThreads();
38583 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38584 wxPyEndAllowThreads(__tstate);
38585 if (PyErr_Occurred()) SWIG_fail;
38586 }
38587 {
38588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38589 }
38590 return resultobj;
38591 fail:
38592 return NULL;
38593 }
38594
38595
38596 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38597 PyObject *resultobj = 0;
38598 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38599 wxArrayString *result = 0 ;
38600 void *argp1 = 0 ;
38601 int res1 = 0 ;
38602 PyObject *swig_obj[1] ;
38603
38604 if (!args) SWIG_fail;
38605 swig_obj[0] = args;
38606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38607 if (!SWIG_IsOK(res1)) {
38608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38609 }
38610 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38611 {
38612 PyThreadState* __tstate = wxPyBeginAllowThreads();
38613 {
38614 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38615 result = (wxArrayString *) &_result_ref;
38616 }
38617 wxPyEndAllowThreads(__tstate);
38618 if (PyErr_Occurred()) SWIG_fail;
38619 }
38620 {
38621 resultobj = wxArrayString2PyList_helper(*result);
38622 }
38623 return resultobj;
38624 fail:
38625 return NULL;
38626 }
38627
38628
38629 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38630 PyObject *resultobj = 0;
38631 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38632 wxArrayString *arg2 = 0 ;
38633 void *argp1 = 0 ;
38634 int res1 = 0 ;
38635 bool temp2 = false ;
38636 PyObject * obj0 = 0 ;
38637 PyObject * obj1 = 0 ;
38638 char * kwnames[] = {
38639 (char *) "self",(char *) "docwriters", NULL
38640 };
38641
38642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38644 if (!SWIG_IsOK(res1)) {
38645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38646 }
38647 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38648 {
38649 if (! PySequence_Check(obj1)) {
38650 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38651 SWIG_fail;
38652 }
38653 arg2 = new wxArrayString;
38654 temp2 = true;
38655 int i, len=PySequence_Length(obj1);
38656 for (i=0; i<len; i++) {
38657 PyObject* item = PySequence_GetItem(obj1, i);
38658 wxString* s = wxString_in_helper(item);
38659 if (PyErr_Occurred()) SWIG_fail;
38660 arg2->Add(*s);
38661 delete s;
38662 Py_DECREF(item);
38663 }
38664 }
38665 {
38666 PyThreadState* __tstate = wxPyBeginAllowThreads();
38667 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38668 wxPyEndAllowThreads(__tstate);
38669 if (PyErr_Occurred()) SWIG_fail;
38670 }
38671 resultobj = SWIG_Py_Void();
38672 {
38673 if (temp2) delete arg2;
38674 }
38675 return resultobj;
38676 fail:
38677 {
38678 if (temp2) delete arg2;
38679 }
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38685 PyObject *resultobj = 0;
38686 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38687 wxString *arg2 = 0 ;
38688 void *argp1 = 0 ;
38689 int res1 = 0 ;
38690 bool temp2 = false ;
38691 PyObject * obj0 = 0 ;
38692 PyObject * obj1 = 0 ;
38693 char * kwnames[] = {
38694 (char *) "self",(char *) "docwriter", NULL
38695 };
38696
38697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38699 if (!SWIG_IsOK(res1)) {
38700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38701 }
38702 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38703 {
38704 arg2 = wxString_in_helper(obj1);
38705 if (arg2 == NULL) SWIG_fail;
38706 temp2 = true;
38707 }
38708 {
38709 PyThreadState* __tstate = wxPyBeginAllowThreads();
38710 (arg1)->AddDocWriter((wxString const &)*arg2);
38711 wxPyEndAllowThreads(__tstate);
38712 if (PyErr_Occurred()) SWIG_fail;
38713 }
38714 resultobj = SWIG_Py_Void();
38715 {
38716 if (temp2)
38717 delete arg2;
38718 }
38719 return resultobj;
38720 fail:
38721 {
38722 if (temp2)
38723 delete arg2;
38724 }
38725 return NULL;
38726 }
38727
38728
38729 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38730 PyObject *resultobj = 0;
38731 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38732 bool result;
38733 void *argp1 = 0 ;
38734 int res1 = 0 ;
38735 PyObject *swig_obj[1] ;
38736
38737 if (!args) SWIG_fail;
38738 swig_obj[0] = args;
38739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38740 if (!SWIG_IsOK(res1)) {
38741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38742 }
38743 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38744 {
38745 PyThreadState* __tstate = wxPyBeginAllowThreads();
38746 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38747 wxPyEndAllowThreads(__tstate);
38748 if (PyErr_Occurred()) SWIG_fail;
38749 }
38750 {
38751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38752 }
38753 return resultobj;
38754 fail:
38755 return NULL;
38756 }
38757
38758
38759 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38760 PyObject *resultobj = 0;
38761 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38762 wxArrayString *result = 0 ;
38763 void *argp1 = 0 ;
38764 int res1 = 0 ;
38765 PyObject *swig_obj[1] ;
38766
38767 if (!args) SWIG_fail;
38768 swig_obj[0] = args;
38769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38770 if (!SWIG_IsOK(res1)) {
38771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38772 }
38773 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38774 {
38775 PyThreadState* __tstate = wxPyBeginAllowThreads();
38776 {
38777 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38778 result = (wxArrayString *) &_result_ref;
38779 }
38780 wxPyEndAllowThreads(__tstate);
38781 if (PyErr_Occurred()) SWIG_fail;
38782 }
38783 {
38784 resultobj = wxArrayString2PyList_helper(*result);
38785 }
38786 return resultobj;
38787 fail:
38788 return NULL;
38789 }
38790
38791
38792 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38793 PyObject *resultobj = 0;
38794 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38795 wxArrayString *arg2 = 0 ;
38796 void *argp1 = 0 ;
38797 int res1 = 0 ;
38798 bool temp2 = false ;
38799 PyObject * obj0 = 0 ;
38800 PyObject * obj1 = 0 ;
38801 char * kwnames[] = {
38802 (char *) "self",(char *) "artists", NULL
38803 };
38804
38805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38807 if (!SWIG_IsOK(res1)) {
38808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38809 }
38810 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38811 {
38812 if (! PySequence_Check(obj1)) {
38813 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38814 SWIG_fail;
38815 }
38816 arg2 = new wxArrayString;
38817 temp2 = true;
38818 int i, len=PySequence_Length(obj1);
38819 for (i=0; i<len; i++) {
38820 PyObject* item = PySequence_GetItem(obj1, i);
38821 wxString* s = wxString_in_helper(item);
38822 if (PyErr_Occurred()) SWIG_fail;
38823 arg2->Add(*s);
38824 delete s;
38825 Py_DECREF(item);
38826 }
38827 }
38828 {
38829 PyThreadState* __tstate = wxPyBeginAllowThreads();
38830 (arg1)->SetArtists((wxArrayString const &)*arg2);
38831 wxPyEndAllowThreads(__tstate);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 }
38834 resultobj = SWIG_Py_Void();
38835 {
38836 if (temp2) delete arg2;
38837 }
38838 return resultobj;
38839 fail:
38840 {
38841 if (temp2) delete arg2;
38842 }
38843 return NULL;
38844 }
38845
38846
38847 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38848 PyObject *resultobj = 0;
38849 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38850 wxString *arg2 = 0 ;
38851 void *argp1 = 0 ;
38852 int res1 = 0 ;
38853 bool temp2 = false ;
38854 PyObject * obj0 = 0 ;
38855 PyObject * obj1 = 0 ;
38856 char * kwnames[] = {
38857 (char *) "self",(char *) "artist", NULL
38858 };
38859
38860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38862 if (!SWIG_IsOK(res1)) {
38863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38864 }
38865 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38866 {
38867 arg2 = wxString_in_helper(obj1);
38868 if (arg2 == NULL) SWIG_fail;
38869 temp2 = true;
38870 }
38871 {
38872 PyThreadState* __tstate = wxPyBeginAllowThreads();
38873 (arg1)->AddArtist((wxString const &)*arg2);
38874 wxPyEndAllowThreads(__tstate);
38875 if (PyErr_Occurred()) SWIG_fail;
38876 }
38877 resultobj = SWIG_Py_Void();
38878 {
38879 if (temp2)
38880 delete arg2;
38881 }
38882 return resultobj;
38883 fail:
38884 {
38885 if (temp2)
38886 delete arg2;
38887 }
38888 return NULL;
38889 }
38890
38891
38892 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38893 PyObject *resultobj = 0;
38894 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38895 bool result;
38896 void *argp1 = 0 ;
38897 int res1 = 0 ;
38898 PyObject *swig_obj[1] ;
38899
38900 if (!args) SWIG_fail;
38901 swig_obj[0] = args;
38902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38903 if (!SWIG_IsOK(res1)) {
38904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38905 }
38906 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38907 {
38908 PyThreadState* __tstate = wxPyBeginAllowThreads();
38909 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38910 wxPyEndAllowThreads(__tstate);
38911 if (PyErr_Occurred()) SWIG_fail;
38912 }
38913 {
38914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38915 }
38916 return resultobj;
38917 fail:
38918 return NULL;
38919 }
38920
38921
38922 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38923 PyObject *resultobj = 0;
38924 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38925 wxArrayString *result = 0 ;
38926 void *argp1 = 0 ;
38927 int res1 = 0 ;
38928 PyObject *swig_obj[1] ;
38929
38930 if (!args) SWIG_fail;
38931 swig_obj[0] = args;
38932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38933 if (!SWIG_IsOK(res1)) {
38934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38935 }
38936 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38937 {
38938 PyThreadState* __tstate = wxPyBeginAllowThreads();
38939 {
38940 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38941 result = (wxArrayString *) &_result_ref;
38942 }
38943 wxPyEndAllowThreads(__tstate);
38944 if (PyErr_Occurred()) SWIG_fail;
38945 }
38946 {
38947 resultobj = wxArrayString2PyList_helper(*result);
38948 }
38949 return resultobj;
38950 fail:
38951 return NULL;
38952 }
38953
38954
38955 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38956 PyObject *resultobj = 0;
38957 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38958 wxArrayString *arg2 = 0 ;
38959 void *argp1 = 0 ;
38960 int res1 = 0 ;
38961 bool temp2 = false ;
38962 PyObject * obj0 = 0 ;
38963 PyObject * obj1 = 0 ;
38964 char * kwnames[] = {
38965 (char *) "self",(char *) "translators", NULL
38966 };
38967
38968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38970 if (!SWIG_IsOK(res1)) {
38971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38972 }
38973 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38974 {
38975 if (! PySequence_Check(obj1)) {
38976 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38977 SWIG_fail;
38978 }
38979 arg2 = new wxArrayString;
38980 temp2 = true;
38981 int i, len=PySequence_Length(obj1);
38982 for (i=0; i<len; i++) {
38983 PyObject* item = PySequence_GetItem(obj1, i);
38984 wxString* s = wxString_in_helper(item);
38985 if (PyErr_Occurred()) SWIG_fail;
38986 arg2->Add(*s);
38987 delete s;
38988 Py_DECREF(item);
38989 }
38990 }
38991 {
38992 PyThreadState* __tstate = wxPyBeginAllowThreads();
38993 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38994 wxPyEndAllowThreads(__tstate);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 }
38997 resultobj = SWIG_Py_Void();
38998 {
38999 if (temp2) delete arg2;
39000 }
39001 return resultobj;
39002 fail:
39003 {
39004 if (temp2) delete arg2;
39005 }
39006 return NULL;
39007 }
39008
39009
39010 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39011 PyObject *resultobj = 0;
39012 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39013 wxString *arg2 = 0 ;
39014 void *argp1 = 0 ;
39015 int res1 = 0 ;
39016 bool temp2 = false ;
39017 PyObject * obj0 = 0 ;
39018 PyObject * obj1 = 0 ;
39019 char * kwnames[] = {
39020 (char *) "self",(char *) "translator", NULL
39021 };
39022
39023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
39024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39025 if (!SWIG_IsOK(res1)) {
39026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
39027 }
39028 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39029 {
39030 arg2 = wxString_in_helper(obj1);
39031 if (arg2 == NULL) SWIG_fail;
39032 temp2 = true;
39033 }
39034 {
39035 PyThreadState* __tstate = wxPyBeginAllowThreads();
39036 (arg1)->AddTranslator((wxString const &)*arg2);
39037 wxPyEndAllowThreads(__tstate);
39038 if (PyErr_Occurred()) SWIG_fail;
39039 }
39040 resultobj = SWIG_Py_Void();
39041 {
39042 if (temp2)
39043 delete arg2;
39044 }
39045 return resultobj;
39046 fail:
39047 {
39048 if (temp2)
39049 delete arg2;
39050 }
39051 return NULL;
39052 }
39053
39054
39055 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39056 PyObject *resultobj = 0;
39057 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39058 bool result;
39059 void *argp1 = 0 ;
39060 int res1 = 0 ;
39061 PyObject *swig_obj[1] ;
39062
39063 if (!args) SWIG_fail;
39064 swig_obj[0] = args;
39065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39066 if (!SWIG_IsOK(res1)) {
39067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39068 }
39069 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39070 {
39071 PyThreadState* __tstate = wxPyBeginAllowThreads();
39072 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 {
39077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39078 }
39079 return resultobj;
39080 fail:
39081 return NULL;
39082 }
39083
39084
39085 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39086 PyObject *resultobj = 0;
39087 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39088 wxArrayString *result = 0 ;
39089 void *argp1 = 0 ;
39090 int res1 = 0 ;
39091 PyObject *swig_obj[1] ;
39092
39093 if (!args) SWIG_fail;
39094 swig_obj[0] = args;
39095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39096 if (!SWIG_IsOK(res1)) {
39097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39098 }
39099 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 {
39103 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39104 result = (wxArrayString *) &_result_ref;
39105 }
39106 wxPyEndAllowThreads(__tstate);
39107 if (PyErr_Occurred()) SWIG_fail;
39108 }
39109 {
39110 resultobj = wxArrayString2PyList_helper(*result);
39111 }
39112 return resultobj;
39113 fail:
39114 return NULL;
39115 }
39116
39117
39118 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39119 PyObject *resultobj = 0;
39120 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39121 bool result;
39122 void *argp1 = 0 ;
39123 int res1 = 0 ;
39124 PyObject *swig_obj[1] ;
39125
39126 if (!args) SWIG_fail;
39127 swig_obj[0] = args;
39128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39129 if (!SWIG_IsOK(res1)) {
39130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39131 }
39132 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39133 {
39134 PyThreadState* __tstate = wxPyBeginAllowThreads();
39135 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39136 wxPyEndAllowThreads(__tstate);
39137 if (PyErr_Occurred()) SWIG_fail;
39138 }
39139 {
39140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39141 }
39142 return resultobj;
39143 fail:
39144 return NULL;
39145 }
39146
39147
39148 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39149 PyObject *resultobj = 0;
39150 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39151 wxString result;
39152 void *argp1 = 0 ;
39153 int res1 = 0 ;
39154 PyObject *swig_obj[1] ;
39155
39156 if (!args) SWIG_fail;
39157 swig_obj[0] = args;
39158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39159 if (!SWIG_IsOK(res1)) {
39160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39161 }
39162 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39163 {
39164 PyThreadState* __tstate = wxPyBeginAllowThreads();
39165 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39166 wxPyEndAllowThreads(__tstate);
39167 if (PyErr_Occurred()) SWIG_fail;
39168 }
39169 {
39170 #if wxUSE_UNICODE
39171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39172 #else
39173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39174 #endif
39175 }
39176 return resultobj;
39177 fail:
39178 return NULL;
39179 }
39180
39181
39182 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39183 PyObject *obj;
39184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39185 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39186 return SWIG_Py_Void();
39187 }
39188
39189 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39190 return SWIG_Python_InitShadowInstance(args);
39191 }
39192
39193 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39194 PyObject *resultobj = 0;
39195 wxAboutDialogInfo *arg1 = 0 ;
39196 void *argp1 = 0 ;
39197 int res1 = 0 ;
39198 PyObject * obj0 = 0 ;
39199 char * kwnames[] = {
39200 (char *) "info", NULL
39201 };
39202
39203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39204 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39205 if (!SWIG_IsOK(res1)) {
39206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39207 }
39208 if (!argp1) {
39209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39210 }
39211 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39212 {
39213 PyThreadState* __tstate = wxPyBeginAllowThreads();
39214 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39215 wxPyEndAllowThreads(__tstate);
39216 if (PyErr_Occurred()) SWIG_fail;
39217 }
39218 resultobj = SWIG_Py_Void();
39219 return resultobj;
39220 fail:
39221 return NULL;
39222 }
39223
39224
39225 static PyMethodDef SwigMethods[] = {
39226 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39228 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39231 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39233 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39234 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39236 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39238 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39239 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39241 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39242 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39243 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39244 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39245 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39250 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39251 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39252 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39253 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39255 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39256 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39257 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39258 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39259 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39260 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39263 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39264 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39266 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39267 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39268 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39269 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39270 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39271 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39273 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39274 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39276 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39277 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39278 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39279 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39280 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39281 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39282 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39283 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39284 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39285 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39286 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39287 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39288 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39289 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39290 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39291 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39292 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39293 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39295 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39296 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39297 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39298 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39299 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39302 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39305 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39306 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39307 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39308 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39309 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39310 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39311 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39312 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39313 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39314 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39315 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39316 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39318 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39319 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39320 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39324 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39326 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39327 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39328 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39329 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39330 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39331 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39332 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39333 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39334 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39335 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39336 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39337 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39338 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39340 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39341 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39342 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39344 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39345 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39346 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39347 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39348 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39349 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39350 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39351 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39352 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39353 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39354 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39355 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39357 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39361 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39362 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39363 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39364 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39365 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39367 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39368 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39369 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39370 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39371 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39372 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39373 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39375 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39376 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39377 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39378 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39379 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39381 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39382 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39383 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39384 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39385 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39387 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39388 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39389 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39390 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39391 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39395 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39396 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39397 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39398 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39399 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39400 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39402 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39403 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39405 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39406 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39407 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39408 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39411 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39412 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39414 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39415 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39417 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39418 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39419 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39420 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39421 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39422 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39423 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39424 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39425 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39426 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39427 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39428 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39429 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39430 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39431 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39432 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39433 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39434 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39435 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39436 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39437 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39438 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39439 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39440 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39442 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39443 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39445 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39446 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39447 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39450 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39453 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39455 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39456 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39457 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39458 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39459 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39460 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39461 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39462 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39464 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39465 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39466 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39467 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39468 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39469 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39470 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39471 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39472 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39473 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39474 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39475 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39476 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39477 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39478 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39479 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39480 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39481 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39482 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39483 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39484 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39485 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39487 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39488 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39489 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39491 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39492 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39493 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39494 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39495 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39497 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39498 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39499 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39500 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39501 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39502 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39503 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39504 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39505 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39507 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39508 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39509 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39510 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39511 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39512 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39514 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39515 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39516 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39517 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39518 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39519 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39520 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39522 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39523 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39524 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39525 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39526 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39527 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39528 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39529 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39530 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39531 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39532 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39533 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39534 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39537 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39538 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39539 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39540 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39541 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39542 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39543 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39544 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39545 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39546 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39547 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39548 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39549 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39550 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39551 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39552 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39553 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39554 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39555 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39558 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39559 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39560 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39561 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39562 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39563 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39564 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39565 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39566 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39567 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39568 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39569 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39570 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39571 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39572 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39573 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39575 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39576 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39577 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39578 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39579 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39580 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39581 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39582 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39583 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39584 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39585 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39586 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39587 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39588 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39589 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39590 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39591 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39592 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39593 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39594 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39595 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39597 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39598 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39599 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39600 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39601 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39602 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39603 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39604 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39605 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39606 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39607 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39608 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39609 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39610 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39611 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39612 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39613 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39614 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39615 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39616 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39617 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39618 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39619 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39620 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39621 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39622 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39623 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39624 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39625 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39626 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39627 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39628 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39629 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39630 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39632 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39633 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39634 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39635 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39636 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39638 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39641 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39642 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39643 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39644 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39645 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39648 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39649 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39652 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39655 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39658 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39659 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39660 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39663 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39664 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39667 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39668 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39669 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39670 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39671 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39672 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39673 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39674 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39675 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39676 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39677 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39679 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39680 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39681 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39682 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39683 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39684 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39685 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39691 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39693 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39694 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39696 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39698 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39703 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39707 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39708 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39709 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39710 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39711 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39715 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"ArtProvider_GetIconBundle", (PyCFunction) _wrap_ArtProvider_GetIconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39721 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39722 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39723 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39724 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39727 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39728 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39730 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39731 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39733 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39754 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39756 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39758 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39760 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39761 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39765 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39766 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39768 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39769 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39770 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39772 { (char *)"FileConfig_GetGlobalFileName", (PyCFunction) _wrap_FileConfig_GetGlobalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"FileConfig_GetLocalFileName", (PyCFunction) _wrap_FileConfig_GetLocalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39775 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39776 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39778 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39779 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39780 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39781 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39784 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39795 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39799 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39800 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39801 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39802 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39808 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39809 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39814 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39815 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39837 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39838 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39839 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39840 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39841 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39853 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39854 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39865 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39880 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39881 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39882 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39883 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39894 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39896 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39897 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39898 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39899 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39900 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39901 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39903 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39905 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39907 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39909 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39911 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39912 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39913 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39915 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39917 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39919 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39920 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39921 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39924 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39935 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39936 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39937 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39941 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39942 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39943 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39944 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39945 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39946 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39948 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39949 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39951 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39953 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39955 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39957 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39959 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39964 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39965 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39966 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39967 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39968 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39970 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39971 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39975 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39976 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39977 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39978 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39979 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39980 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39983 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39984 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39985 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39986 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39987 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39988 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39991 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39992 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39993 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39994 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39995 { (char *)"DataFormat__GetId", (PyCFunction)_wrap_DataFormat__GetId, METH_O, NULL},
39996 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39998 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39999 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
40000 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40003 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
40004 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
40005 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40007 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
40008 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40009 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
40010 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
40012 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
40013 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
40015 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
40016 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
40019 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
40020 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
40021 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
40023 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
40024 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
40025 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
40027 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
40028 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
40030 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
40031 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40032 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
40034 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
40035 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40036 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
40037 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
40038 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
40039 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
40040 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40042 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
40043 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
40044 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
40045 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
40046 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
40048 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40049 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40050 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40051 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40052 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40053 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40054 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40055 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40056 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40057 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40059 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40060 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40061 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40062 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40063 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40065 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40067 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40069 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40070 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40071 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40072 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40073 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40074 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40075 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40076 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40077 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40078 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40082 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40083 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40084 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40085 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40086 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40087 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40088 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40089 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40091 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40092 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40093 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40094 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40095 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40096 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40097 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40098 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40099 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40100 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40101 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40102 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40103 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40104 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40105 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40106 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40107 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40108 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40109 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40110 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40111 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40112 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40113 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40114 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40115 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40116 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40117 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40118 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40119 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40120 { (char *)"Clipboard_IsUsingPrimarySelection", (PyCFunction)_wrap_Clipboard_IsUsingPrimarySelection, METH_O, NULL},
40121 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40122 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40123 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40124 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40125 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40126 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40127 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40128 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40129 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40130 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40131 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40132 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40133 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40134 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40135 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40136 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40137 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40138 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40139 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40140 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40141 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40142 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40143 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40144 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40145 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40146 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40147 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40148 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40149 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40150 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40151 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40152 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40153 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40154 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40155 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40156 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40157 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40158 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40159 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40160 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40161 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40162 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40163 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40164 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40165 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40166 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40167 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40168 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40169 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40170 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40171 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40172 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40173 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40174 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40175 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40176 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40177 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40178 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40179 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40180 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40181 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40182 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40183 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40184 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40185 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40186 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40187 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40188 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40189 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40190 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40191 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40192 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40193 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40194 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40195 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40196 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40197 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40198 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40199 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40200 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40201 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40202 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40203 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40204 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40205 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40206 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40207 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40208 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40209 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40210 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40211 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40212 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40213 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40214 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40215 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40216 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40217 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40218 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40219 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40220 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40221 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40222 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40223 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40224 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40225 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40226 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40227 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40228 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40229 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40230 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40231 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40232 { NULL, NULL, 0, NULL }
40233 };
40234
40235
40236 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40237
40238 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40239 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40240 }
40241 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40242 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40243 }
40244 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40245 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40246 }
40247 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40248 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40249 }
40250 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40251 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40252 }
40253 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40254 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40255 }
40256 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40257 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40258 }
40259 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40260 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40261 }
40262 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40263 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40264 }
40265 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40266 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40267 }
40268 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40269 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40270 }
40271 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40272 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40273 }
40274 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40275 return (void *)((wxEvent *) ((wxPyEvent *) x));
40276 }
40277 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40278 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40279 }
40280 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40281 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40282 }
40283 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40284 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40285 }
40286 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40287 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40288 }
40289 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40290 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40291 }
40292 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40293 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40294 }
40295 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40296 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40297 }
40298 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40299 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40300 }
40301 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40302 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40303 }
40304 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40305 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40306 }
40307 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40308 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40309 }
40310 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40311 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40312 }
40313 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40314 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40315 }
40316 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40317 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40318 }
40319 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40320 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40321 }
40322 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40323 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40324 }
40325 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40326 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40327 }
40328 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40329 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40330 }
40331 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40332 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40333 }
40334 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40335 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40336 }
40337 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40338 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40339 }
40340 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40341 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40342 }
40343 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40344 return (void *)((wxEvent *) ((wxShowEvent *) x));
40345 }
40346 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40347 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40348 }
40349 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40350 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40351 }
40352 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40353 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40354 }
40355 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40356 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40357 }
40358 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40359 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40360 }
40361 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40362 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40363 }
40364 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40365 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40366 }
40367 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40368 return (void *)((wxConfigBase *) ((wxConfig *) x));
40369 }
40370 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40371 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40372 }
40373 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40374 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40375 }
40376 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40377 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40378 }
40379 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40380 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40381 }
40382 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40383 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40384 }
40385 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40386 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40387 }
40388 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40389 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40390 }
40391 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40392 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40393 }
40394 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40395 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40396 }
40397 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40398 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40399 }
40400 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40401 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40402 }
40403 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40404 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40405 }
40406 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40407 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40408 }
40409 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40410 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40411 }
40412 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40413 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40414 }
40415 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40416 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40417 }
40418 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40419 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40420 }
40421 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40422 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40423 }
40424 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40425 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40426 }
40427 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40428 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40429 }
40430 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40431 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40432 }
40433 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40434 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40435 }
40436 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40437 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40438 }
40439 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40440 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40441 }
40442 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40443 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40444 }
40445 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40446 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40447 }
40448 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40449 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40450 }
40451 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40452 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40453 }
40454 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40455 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40456 }
40457 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
40458 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
40459 }
40460 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40461 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40462 }
40463 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40464 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40465 }
40466 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40467 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40468 }
40469 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40470 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40471 }
40472 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
40473 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
40474 }
40475 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40476 return (void *)((wxObject *) ((wxSizerItem *) x));
40477 }
40478 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40479 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40480 }
40481 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40482 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40483 }
40484 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40485 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40486 }
40487 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40488 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40489 }
40490 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40491 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40492 }
40493 static void *_p_wxSizerTo_p_wxObject(void *x) {
40494 return (void *)((wxObject *) ((wxSizer *) x));
40495 }
40496 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40497 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40498 }
40499 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40500 return (void *)((wxObject *) ((wxFileHistory *) x));
40501 }
40502 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40503 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40504 }
40505 static void *_p_wxEventTo_p_wxObject(void *x) {
40506 return (void *)((wxObject *) ((wxEvent *) x));
40507 }
40508 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40509 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40510 }
40511 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40512 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40513 }
40514 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40515 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40516 }
40517 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40518 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40519 }
40520 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40521 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40522 }
40523 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40524 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40525 }
40526 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40527 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40528 }
40529 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40530 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40531 }
40532 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40533 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40534 }
40535 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40536 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40537 }
40538 static void *_p_wxControlTo_p_wxObject(void *x) {
40539 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40540 }
40541 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40542 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40543 }
40544 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40545 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40546 }
40547 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40548 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40549 }
40550 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40551 return (void *)((wxObject *) ((wxFSFile *) x));
40552 }
40553 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40554 return (void *)((wxObject *) ((wxClipboard *) x));
40555 }
40556 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40557 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40558 }
40559 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40560 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40561 }
40562 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40563 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40564 }
40565 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40566 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40567 }
40568 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40569 return (void *)((wxObject *) ((wxToolTip *) x));
40570 }
40571 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40572 return (void *)((wxObject *) ((wxMenuItem *) x));
40573 }
40574 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40575 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40576 }
40577 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40578 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40579 }
40580 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40581 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40582 }
40583 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40584 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40585 }
40586 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40587 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40588 }
40589 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40590 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40591 }
40592 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40593 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40594 }
40595 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40596 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40597 }
40598 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40599 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40600 }
40601 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40602 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40603 }
40604 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40605 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40606 }
40607 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40608 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40609 }
40610 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40611 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40612 }
40613 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40614 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40615 }
40616 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40617 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40618 }
40619 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40620 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40621 }
40622 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40623 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40624 }
40625 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40626 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40627 }
40628 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40629 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40630 }
40631 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40632 return (void *)((wxObject *) ((wxImageHandler *) x));
40633 }
40634 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40635 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40636 }
40637 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40638 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40639 }
40640 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40641 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40642 }
40643 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40644 return (void *)((wxObject *) ((wxEvtHandler *) x));
40645 }
40646 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40647 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40648 }
40649 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40650 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40651 }
40652 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40653 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40654 }
40655 static void *_p_wxImageTo_p_wxObject(void *x) {
40656 return (void *)((wxObject *) ((wxImage *) x));
40657 }
40658 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40659 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40660 }
40661 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40662 return (void *)((wxObject *) ((wxSystemOptions *) x));
40663 }
40664 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40665 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40666 }
40667 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40668 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40669 }
40670 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40671 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40672 }
40673 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40674 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40675 }
40676 static void *_p_wxWindowTo_p_wxObject(void *x) {
40677 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40678 }
40679 static void *_p_wxMenuTo_p_wxObject(void *x) {
40680 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40681 }
40682 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40683 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40684 }
40685 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40686 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40687 }
40688 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40689 return (void *)((wxObject *) ((wxFileSystem *) x));
40690 }
40691 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40692 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40693 }
40694 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40695 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40696 }
40697 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40698 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40699 }
40700 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40701 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40702 }
40703 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40704 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40705 }
40706 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40707 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40708 }
40709 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40710 return (void *)((wxObject *) ((wxBusyInfo *) x));
40711 }
40712 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40713 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40714 }
40715 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40716 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40717 }
40718 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40719 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40720 }
40721 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40722 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40723 }
40724 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40725 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40726 }
40727 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40728 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40729 }
40730 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40731 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40732 }
40733 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40734 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40735 }
40736 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40737 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40738 }
40739 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40740 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40741 }
40742 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40743 return (void *)((wxLog *) ((wxLogBuffer *) x));
40744 }
40745 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40746 return (void *)((wxLog *) ((wxLogStderr *) x));
40747 }
40748 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40749 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40750 }
40751 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40752 return (void *)((wxLog *) ((wxLogWindow *) x));
40753 }
40754 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40755 return (void *)((wxLog *) ((wxLogChain *) x));
40756 }
40757 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40758 return (void *)((wxLog *) ((wxLogGui *) x));
40759 }
40760 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40761 return (void *)((wxLog *) ((wxPyLog *) x));
40762 }
40763 static void *_p_wxControlTo_p_wxWindow(void *x) {
40764 return (void *)((wxWindow *) ((wxControl *) x));
40765 }
40766 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40767 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40768 }
40769 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40770 return (void *)((wxWindow *) ((wxMenuBar *) x));
40771 }
40772 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40773 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40774 }
40775 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40776 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40777 }
40778 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40779 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};
40780 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxArtClient = {"_p_wxArtClient", "wxArtClient *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxArtID = {"_p_wxArtID", "wxArtID *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40812 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40813 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40814 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40817 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40818 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40825 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40828 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40832 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40833 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40835 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40836 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40837 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40838 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40839 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40840 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40841 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40842 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40843 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40844 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40845 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40846 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40847 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40848 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40849 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40850 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40851 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40852 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40853 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40854 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40855 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40856 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40857 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40858 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40859 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
40860 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40861 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40862 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40863 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40866 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40867 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40868 static swig_type_info _swigt__p_wxIconBundle = {"_p_wxIconBundle", "wxIconBundle *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40870 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40871 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40875 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40876 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40877 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40878 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40879 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40880 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40881 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40882 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40883 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40884 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40885 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40886 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40887 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40888 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40889 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40890 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40891 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40892 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40893 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40894 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40895 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40896 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40897 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40898 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40899 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40900 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40901 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40902 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40903 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40904 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40905 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40906 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40907 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40908 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40909 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40910 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40911 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40912 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40913 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40914 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40915 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40916 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40917 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40918 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40919 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40920 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40921 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40922 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40923 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40924 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40925 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40926 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40927 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40928 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40929 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40930 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40931 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40932 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40933 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40934 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40935 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40936 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40937 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40938 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40939 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40940 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40941 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40942 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40943 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40944 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40945 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40946 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40947 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40948 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40949 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40950 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40951 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40952 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40953 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40954 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40955 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40956
40957 static swig_type_info *swig_type_initial[] = {
40958 &_swigt__p_char,
40959 &_swigt__p_form_ops_t,
40960 &_swigt__p_int,
40961 &_swigt__p_unsigned_char,
40962 &_swigt__p_unsigned_int,
40963 &_swigt__p_unsigned_long,
40964 &_swigt__p_void,
40965 &_swigt__p_wxANIHandler,
40966 &_swigt__p_wxAboutDialogInfo,
40967 &_swigt__p_wxAcceleratorTable,
40968 &_swigt__p_wxActivateEvent,
40969 &_swigt__p_wxArrayString,
40970 &_swigt__p_wxArtClient,
40971 &_swigt__p_wxArtID,
40972 &_swigt__p_wxBMPHandler,
40973 &_swigt__p_wxBitmap,
40974 &_swigt__p_wxBitmapDataObject,
40975 &_swigt__p_wxBoxSizer,
40976 &_swigt__p_wxBusyCursor,
40977 &_swigt__p_wxBusyInfo,
40978 &_swigt__p_wxCURHandler,
40979 &_swigt__p_wxCaret,
40980 &_swigt__p_wxChar,
40981 &_swigt__p_wxChildFocusEvent,
40982 &_swigt__p_wxClipboard,
40983 &_swigt__p_wxClipboardLocker,
40984 &_swigt__p_wxClipboardTextEvent,
40985 &_swigt__p_wxCloseEvent,
40986 &_swigt__p_wxColour,
40987 &_swigt__p_wxCommandEvent,
40988 &_swigt__p_wxConfig,
40989 &_swigt__p_wxConfigBase,
40990 &_swigt__p_wxConfigPathChanger,
40991 &_swigt__p_wxContextMenuEvent,
40992 &_swigt__p_wxControl,
40993 &_swigt__p_wxControlWithItems,
40994 &_swigt__p_wxCursor,
40995 &_swigt__p_wxCustomDataObject,
40996 &_swigt__p_wxDC,
40997 &_swigt__p_wxDataFormat,
40998 &_swigt__p_wxDataObject,
40999 &_swigt__p_wxDataObjectComposite,
41000 &_swigt__p_wxDataObjectSimple,
41001 &_swigt__p_wxDateEvent,
41002 &_swigt__p_wxDateSpan,
41003 &_swigt__p_wxDateTime,
41004 &_swigt__p_wxDateTime__TimeZone,
41005 &_swigt__p_wxDisplay,
41006 &_swigt__p_wxDisplayChangedEvent,
41007 &_swigt__p_wxDropFilesEvent,
41008 &_swigt__p_wxDuplexMode,
41009 &_swigt__p_wxEraseEvent,
41010 &_swigt__p_wxEvent,
41011 &_swigt__p_wxEventBlocker,
41012 &_swigt__p_wxEvtHandler,
41013 &_swigt__p_wxFSFile,
41014 &_swigt__p_wxFileConfig,
41015 &_swigt__p_wxFileDataObject,
41016 &_swigt__p_wxFileHistory,
41017 &_swigt__p_wxFileSystem,
41018 &_swigt__p_wxFileType,
41019 &_swigt__p_wxFileTypeInfo,
41020 &_swigt__p_wxFlexGridSizer,
41021 &_swigt__p_wxFocusEvent,
41022 &_swigt__p_wxFont,
41023 &_swigt__p_wxFrame,
41024 &_swigt__p_wxGBSizerItem,
41025 &_swigt__p_wxGIFHandler,
41026 &_swigt__p_wxGridBagSizer,
41027 &_swigt__p_wxGridSizer,
41028 &_swigt__p_wxICOHandler,
41029 &_swigt__p_wxIcon,
41030 &_swigt__p_wxIconBundle,
41031 &_swigt__p_wxIconizeEvent,
41032 &_swigt__p_wxIdleEvent,
41033 &_swigt__p_wxImage,
41034 &_swigt__p_wxImageHandler,
41035 &_swigt__p_wxIndividualLayoutConstraint,
41036 &_swigt__p_wxInitDialogEvent,
41037 &_swigt__p_wxJPEGHandler,
41038 &_swigt__p_wxJoystick,
41039 &_swigt__p_wxJoystickEvent,
41040 &_swigt__p_wxKeyEvent,
41041 &_swigt__p_wxKillError,
41042 &_swigt__p_wxLayoutConstraints,
41043 &_swigt__p_wxLog,
41044 &_swigt__p_wxLogBuffer,
41045 &_swigt__p_wxLogChain,
41046 &_swigt__p_wxLogGui,
41047 &_swigt__p_wxLogNull,
41048 &_swigt__p_wxLogStderr,
41049 &_swigt__p_wxLogTextCtrl,
41050 &_swigt__p_wxLogWindow,
41051 &_swigt__p_wxMaximizeEvent,
41052 &_swigt__p_wxMenu,
41053 &_swigt__p_wxMenuBar,
41054 &_swigt__p_wxMenuEvent,
41055 &_swigt__p_wxMenuItem,
41056 &_swigt__p_wxMetafileDataObject,
41057 &_swigt__p_wxMimeTypesManager,
41058 &_swigt__p_wxMouseCaptureChangedEvent,
41059 &_swigt__p_wxMouseCaptureLostEvent,
41060 &_swigt__p_wxMouseEvent,
41061 &_swigt__p_wxMouseState,
41062 &_swigt__p_wxMoveEvent,
41063 &_swigt__p_wxMutexGuiLocker,
41064 &_swigt__p_wxNavigationKeyEvent,
41065 &_swigt__p_wxNcPaintEvent,
41066 &_swigt__p_wxNotifyEvent,
41067 &_swigt__p_wxObject,
41068 &_swigt__p_wxOutputStream,
41069 &_swigt__p_wxPCXHandler,
41070 &_swigt__p_wxPNGHandler,
41071 &_swigt__p_wxPNMHandler,
41072 &_swigt__p_wxPaintEvent,
41073 &_swigt__p_wxPaletteChangedEvent,
41074 &_swigt__p_wxPaperSize,
41075 &_swigt__p_wxPlatformInfo,
41076 &_swigt__p_wxPoint,
41077 &_swigt__p_wxPowerEvent,
41078 &_swigt__p_wxProcessEvent,
41079 &_swigt__p_wxPyApp,
41080 &_swigt__p_wxPyArtProvider,
41081 &_swigt__p_wxPyBitmapDataObject,
41082 &_swigt__p_wxPyCommandEvent,
41083 &_swigt__p_wxPyDataObjectSimple,
41084 &_swigt__p_wxPyDropSource,
41085 &_swigt__p_wxPyDropTarget,
41086 &_swigt__p_wxPyEvent,
41087 &_swigt__p_wxPyFileDropTarget,
41088 &_swigt__p_wxPyImageHandler,
41089 &_swigt__p_wxPyLog,
41090 &_swigt__p_wxPyProcess,
41091 &_swigt__p_wxPySizer,
41092 &_swigt__p_wxPyTextDataObject,
41093 &_swigt__p_wxPyTextDropTarget,
41094 &_swigt__p_wxPyTimer,
41095 &_swigt__p_wxPyTipProvider,
41096 &_swigt__p_wxPyValidator,
41097 &_swigt__p_wxQueryNewPaletteEvent,
41098 &_swigt__p_wxRect,
41099 &_swigt__p_wxScrollEvent,
41100 &_swigt__p_wxScrollWinEvent,
41101 &_swigt__p_wxSetCursorEvent,
41102 &_swigt__p_wxShowEvent,
41103 &_swigt__p_wxSingleInstanceChecker,
41104 &_swigt__p_wxSize,
41105 &_swigt__p_wxSizeEvent,
41106 &_swigt__p_wxSizer,
41107 &_swigt__p_wxSizerItem,
41108 &_swigt__p_wxSound,
41109 &_swigt__p_wxStandardPaths,
41110 &_swigt__p_wxStaticBoxSizer,
41111 &_swigt__p_wxStdDialogButtonSizer,
41112 &_swigt__p_wxStopWatch,
41113 &_swigt__p_wxString,
41114 &_swigt__p_wxSysColourChangedEvent,
41115 &_swigt__p_wxSystemOptions,
41116 &_swigt__p_wxSystemSettings,
41117 &_swigt__p_wxTGAHandler,
41118 &_swigt__p_wxTIFFHandler,
41119 &_swigt__p_wxTextCtrl,
41120 &_swigt__p_wxTextDataObject,
41121 &_swigt__p_wxTimeSpan,
41122 &_swigt__p_wxTimer,
41123 &_swigt__p_wxTimerEvent,
41124 &_swigt__p_wxTimerRunner,
41125 &_swigt__p_wxTipProvider,
41126 &_swigt__p_wxToolTip,
41127 &_swigt__p_wxURLDataObject,
41128 &_swigt__p_wxUpdateUIEvent,
41129 &_swigt__p_wxValidator,
41130 &_swigt__p_wxVideoMode,
41131 &_swigt__p_wxWindow,
41132 &_swigt__p_wxWindowCreateEvent,
41133 &_swigt__p_wxWindowDestroyEvent,
41134 &_swigt__p_wxWindowDisabler,
41135 &_swigt__p_wxXPMHandler,
41136 };
41137
41138 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxArtClient[] = { {&_swigt__p_wxArtClient, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxArtID[] = { {&_swigt__p_wxArtID, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41150 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}};
41151 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41159 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}};
41160 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41165 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}};
41166 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41167 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}};
41168 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41211 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}};
41212 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
41219 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_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxIconBundle[] = { {&_swigt__p_wxIconBundle, 0, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41232 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}};
41233 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41237 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41241 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41244 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41245 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41246 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41247 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41248 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41251 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41252 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41255 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41256 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41257 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41258 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41259 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41260 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41261 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41262 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41263 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41264 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41265 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41266 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41267 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41268 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41269 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41270 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41271 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41272 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41273 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41274 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41275 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41276 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_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_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_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_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_wxXPMHandler, _p_wxXPMHandlerTo_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}};
41277 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41278 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41279 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41280 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41281 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41282 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41283 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41284 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41285 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41286 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41287 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}};
41288 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41289 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41290 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41291 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41292 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41293 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41294 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41295 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41296 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41297 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41298 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41299 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41300 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41301 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41302 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41303 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41304 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41305 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}};
41306 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41307 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41308 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41309 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41310 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}};
41311 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41312 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41313 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41314 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}};
41315 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41316
41317 static swig_cast_info *swig_cast_initial[] = {
41318 _swigc__p_char,
41319 _swigc__p_form_ops_t,
41320 _swigc__p_int,
41321 _swigc__p_unsigned_char,
41322 _swigc__p_unsigned_int,
41323 _swigc__p_unsigned_long,
41324 _swigc__p_void,
41325 _swigc__p_wxANIHandler,
41326 _swigc__p_wxAboutDialogInfo,
41327 _swigc__p_wxAcceleratorTable,
41328 _swigc__p_wxActivateEvent,
41329 _swigc__p_wxArrayString,
41330 _swigc__p_wxArtClient,
41331 _swigc__p_wxArtID,
41332 _swigc__p_wxBMPHandler,
41333 _swigc__p_wxBitmap,
41334 _swigc__p_wxBitmapDataObject,
41335 _swigc__p_wxBoxSizer,
41336 _swigc__p_wxBusyCursor,
41337 _swigc__p_wxBusyInfo,
41338 _swigc__p_wxCURHandler,
41339 _swigc__p_wxCaret,
41340 _swigc__p_wxChar,
41341 _swigc__p_wxChildFocusEvent,
41342 _swigc__p_wxClipboard,
41343 _swigc__p_wxClipboardLocker,
41344 _swigc__p_wxClipboardTextEvent,
41345 _swigc__p_wxCloseEvent,
41346 _swigc__p_wxColour,
41347 _swigc__p_wxCommandEvent,
41348 _swigc__p_wxConfig,
41349 _swigc__p_wxConfigBase,
41350 _swigc__p_wxConfigPathChanger,
41351 _swigc__p_wxContextMenuEvent,
41352 _swigc__p_wxControl,
41353 _swigc__p_wxControlWithItems,
41354 _swigc__p_wxCursor,
41355 _swigc__p_wxCustomDataObject,
41356 _swigc__p_wxDC,
41357 _swigc__p_wxDataFormat,
41358 _swigc__p_wxDataObject,
41359 _swigc__p_wxDataObjectComposite,
41360 _swigc__p_wxDataObjectSimple,
41361 _swigc__p_wxDateEvent,
41362 _swigc__p_wxDateSpan,
41363 _swigc__p_wxDateTime,
41364 _swigc__p_wxDateTime__TimeZone,
41365 _swigc__p_wxDisplay,
41366 _swigc__p_wxDisplayChangedEvent,
41367 _swigc__p_wxDropFilesEvent,
41368 _swigc__p_wxDuplexMode,
41369 _swigc__p_wxEraseEvent,
41370 _swigc__p_wxEvent,
41371 _swigc__p_wxEventBlocker,
41372 _swigc__p_wxEvtHandler,
41373 _swigc__p_wxFSFile,
41374 _swigc__p_wxFileConfig,
41375 _swigc__p_wxFileDataObject,
41376 _swigc__p_wxFileHistory,
41377 _swigc__p_wxFileSystem,
41378 _swigc__p_wxFileType,
41379 _swigc__p_wxFileTypeInfo,
41380 _swigc__p_wxFlexGridSizer,
41381 _swigc__p_wxFocusEvent,
41382 _swigc__p_wxFont,
41383 _swigc__p_wxFrame,
41384 _swigc__p_wxGBSizerItem,
41385 _swigc__p_wxGIFHandler,
41386 _swigc__p_wxGridBagSizer,
41387 _swigc__p_wxGridSizer,
41388 _swigc__p_wxICOHandler,
41389 _swigc__p_wxIcon,
41390 _swigc__p_wxIconBundle,
41391 _swigc__p_wxIconizeEvent,
41392 _swigc__p_wxIdleEvent,
41393 _swigc__p_wxImage,
41394 _swigc__p_wxImageHandler,
41395 _swigc__p_wxIndividualLayoutConstraint,
41396 _swigc__p_wxInitDialogEvent,
41397 _swigc__p_wxJPEGHandler,
41398 _swigc__p_wxJoystick,
41399 _swigc__p_wxJoystickEvent,
41400 _swigc__p_wxKeyEvent,
41401 _swigc__p_wxKillError,
41402 _swigc__p_wxLayoutConstraints,
41403 _swigc__p_wxLog,
41404 _swigc__p_wxLogBuffer,
41405 _swigc__p_wxLogChain,
41406 _swigc__p_wxLogGui,
41407 _swigc__p_wxLogNull,
41408 _swigc__p_wxLogStderr,
41409 _swigc__p_wxLogTextCtrl,
41410 _swigc__p_wxLogWindow,
41411 _swigc__p_wxMaximizeEvent,
41412 _swigc__p_wxMenu,
41413 _swigc__p_wxMenuBar,
41414 _swigc__p_wxMenuEvent,
41415 _swigc__p_wxMenuItem,
41416 _swigc__p_wxMetafileDataObject,
41417 _swigc__p_wxMimeTypesManager,
41418 _swigc__p_wxMouseCaptureChangedEvent,
41419 _swigc__p_wxMouseCaptureLostEvent,
41420 _swigc__p_wxMouseEvent,
41421 _swigc__p_wxMouseState,
41422 _swigc__p_wxMoveEvent,
41423 _swigc__p_wxMutexGuiLocker,
41424 _swigc__p_wxNavigationKeyEvent,
41425 _swigc__p_wxNcPaintEvent,
41426 _swigc__p_wxNotifyEvent,
41427 _swigc__p_wxObject,
41428 _swigc__p_wxOutputStream,
41429 _swigc__p_wxPCXHandler,
41430 _swigc__p_wxPNGHandler,
41431 _swigc__p_wxPNMHandler,
41432 _swigc__p_wxPaintEvent,
41433 _swigc__p_wxPaletteChangedEvent,
41434 _swigc__p_wxPaperSize,
41435 _swigc__p_wxPlatformInfo,
41436 _swigc__p_wxPoint,
41437 _swigc__p_wxPowerEvent,
41438 _swigc__p_wxProcessEvent,
41439 _swigc__p_wxPyApp,
41440 _swigc__p_wxPyArtProvider,
41441 _swigc__p_wxPyBitmapDataObject,
41442 _swigc__p_wxPyCommandEvent,
41443 _swigc__p_wxPyDataObjectSimple,
41444 _swigc__p_wxPyDropSource,
41445 _swigc__p_wxPyDropTarget,
41446 _swigc__p_wxPyEvent,
41447 _swigc__p_wxPyFileDropTarget,
41448 _swigc__p_wxPyImageHandler,
41449 _swigc__p_wxPyLog,
41450 _swigc__p_wxPyProcess,
41451 _swigc__p_wxPySizer,
41452 _swigc__p_wxPyTextDataObject,
41453 _swigc__p_wxPyTextDropTarget,
41454 _swigc__p_wxPyTimer,
41455 _swigc__p_wxPyTipProvider,
41456 _swigc__p_wxPyValidator,
41457 _swigc__p_wxQueryNewPaletteEvent,
41458 _swigc__p_wxRect,
41459 _swigc__p_wxScrollEvent,
41460 _swigc__p_wxScrollWinEvent,
41461 _swigc__p_wxSetCursorEvent,
41462 _swigc__p_wxShowEvent,
41463 _swigc__p_wxSingleInstanceChecker,
41464 _swigc__p_wxSize,
41465 _swigc__p_wxSizeEvent,
41466 _swigc__p_wxSizer,
41467 _swigc__p_wxSizerItem,
41468 _swigc__p_wxSound,
41469 _swigc__p_wxStandardPaths,
41470 _swigc__p_wxStaticBoxSizer,
41471 _swigc__p_wxStdDialogButtonSizer,
41472 _swigc__p_wxStopWatch,
41473 _swigc__p_wxString,
41474 _swigc__p_wxSysColourChangedEvent,
41475 _swigc__p_wxSystemOptions,
41476 _swigc__p_wxSystemSettings,
41477 _swigc__p_wxTGAHandler,
41478 _swigc__p_wxTIFFHandler,
41479 _swigc__p_wxTextCtrl,
41480 _swigc__p_wxTextDataObject,
41481 _swigc__p_wxTimeSpan,
41482 _swigc__p_wxTimer,
41483 _swigc__p_wxTimerEvent,
41484 _swigc__p_wxTimerRunner,
41485 _swigc__p_wxTipProvider,
41486 _swigc__p_wxToolTip,
41487 _swigc__p_wxURLDataObject,
41488 _swigc__p_wxUpdateUIEvent,
41489 _swigc__p_wxValidator,
41490 _swigc__p_wxVideoMode,
41491 _swigc__p_wxWindow,
41492 _swigc__p_wxWindowCreateEvent,
41493 _swigc__p_wxWindowDestroyEvent,
41494 _swigc__p_wxWindowDisabler,
41495 _swigc__p_wxXPMHandler,
41496 };
41497
41498
41499 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41500
41501 static swig_const_info swig_const_table[] = {
41502 {0, 0, 0, 0.0, 0, 0}};
41503
41504 #ifdef __cplusplus
41505 }
41506 #endif
41507 /* -----------------------------------------------------------------------------
41508 * Type initialization:
41509 * This problem is tough by the requirement that no dynamic
41510 * memory is used. Also, since swig_type_info structures store pointers to
41511 * swig_cast_info structures and swig_cast_info structures store pointers back
41512 * to swig_type_info structures, we need some lookup code at initialization.
41513 * The idea is that swig generates all the structures that are needed.
41514 * The runtime then collects these partially filled structures.
41515 * The SWIG_InitializeModule function takes these initial arrays out of
41516 * swig_module, and does all the lookup, filling in the swig_module.types
41517 * array with the correct data and linking the correct swig_cast_info
41518 * structures together.
41519 *
41520 * The generated swig_type_info structures are assigned staticly to an initial
41521 * array. We just loop though that array, and handle each type individually.
41522 * First we lookup if this type has been already loaded, and if so, use the
41523 * loaded structure instead of the generated one. Then we have to fill in the
41524 * cast linked list. The cast data is initially stored in something like a
41525 * two-dimensional array. Each row corresponds to a type (there are the same
41526 * number of rows as there are in the swig_type_initial array). Each entry in
41527 * a column is one of the swig_cast_info structures for that type.
41528 * The cast_initial array is actually an array of arrays, because each row has
41529 * a variable number of columns. So to actually build the cast linked list,
41530 * we find the array of casts associated with the type, and loop through it
41531 * adding the casts to the list. The one last trick we need to do is making
41532 * sure the type pointer in the swig_cast_info struct is correct.
41533 *
41534 * First off, we lookup the cast->type name to see if it is already loaded.
41535 * There are three cases to handle:
41536 * 1) If the cast->type has already been loaded AND the type we are adding
41537 * casting info to has not been loaded (it is in this module), THEN we
41538 * replace the cast->type pointer with the type pointer that has already
41539 * been loaded.
41540 * 2) If BOTH types (the one we are adding casting info to, and the
41541 * cast->type) are loaded, THEN the cast info has already been loaded by
41542 * the previous module so we just ignore it.
41543 * 3) Finally, if cast->type has not already been loaded, then we add that
41544 * swig_cast_info to the linked list (because the cast->type) pointer will
41545 * be correct.
41546 * ----------------------------------------------------------------------------- */
41547
41548 #ifdef __cplusplus
41549 extern "C" {
41550 #if 0
41551 } /* c-mode */
41552 #endif
41553 #endif
41554
41555 #if 0
41556 #define SWIGRUNTIME_DEBUG
41557 #endif
41558
41559 SWIGRUNTIME void
41560 SWIG_InitializeModule(void *clientdata) {
41561 size_t i;
41562 swig_module_info *module_head;
41563 static int init_run = 0;
41564
41565 clientdata = clientdata;
41566
41567 if (init_run) return;
41568 init_run = 1;
41569
41570 /* Initialize the swig_module */
41571 swig_module.type_initial = swig_type_initial;
41572 swig_module.cast_initial = swig_cast_initial;
41573
41574 /* Try and load any already created modules */
41575 module_head = SWIG_GetModule(clientdata);
41576 if (module_head) {
41577 swig_module.next = module_head->next;
41578 module_head->next = &swig_module;
41579 } else {
41580 /* This is the first module loaded */
41581 swig_module.next = &swig_module;
41582 SWIG_SetModule(clientdata, &swig_module);
41583 }
41584
41585 /* Now work on filling in swig_module.types */
41586 #ifdef SWIGRUNTIME_DEBUG
41587 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41588 #endif
41589 for (i = 0; i < swig_module.size; ++i) {
41590 swig_type_info *type = 0;
41591 swig_type_info *ret;
41592 swig_cast_info *cast;
41593
41594 #ifdef SWIGRUNTIME_DEBUG
41595 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41596 #endif
41597
41598 /* if there is another module already loaded */
41599 if (swig_module.next != &swig_module) {
41600 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41601 }
41602 if (type) {
41603 /* Overwrite clientdata field */
41604 #ifdef SWIGRUNTIME_DEBUG
41605 printf("SWIG_InitializeModule: found type %s\n", type->name);
41606 #endif
41607 if (swig_module.type_initial[i]->clientdata) {
41608 type->clientdata = swig_module.type_initial[i]->clientdata;
41609 #ifdef SWIGRUNTIME_DEBUG
41610 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41611 #endif
41612 }
41613 } else {
41614 type = swig_module.type_initial[i];
41615 }
41616
41617 /* Insert casting types */
41618 cast = swig_module.cast_initial[i];
41619 while (cast->type) {
41620 /* Don't need to add information already in the list */
41621 ret = 0;
41622 #ifdef SWIGRUNTIME_DEBUG
41623 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41624 #endif
41625 if (swig_module.next != &swig_module) {
41626 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41627 #ifdef SWIGRUNTIME_DEBUG
41628 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41629 #endif
41630 }
41631 if (ret) {
41632 if (type == swig_module.type_initial[i]) {
41633 #ifdef SWIGRUNTIME_DEBUG
41634 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41635 #endif
41636 cast->type = ret;
41637 ret = 0;
41638 } else {
41639 /* Check for casting already in the list */
41640 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41641 #ifdef SWIGRUNTIME_DEBUG
41642 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41643 #endif
41644 if (!ocast) ret = 0;
41645 }
41646 }
41647
41648 if (!ret) {
41649 #ifdef SWIGRUNTIME_DEBUG
41650 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41651 #endif
41652 if (type->cast) {
41653 type->cast->prev = cast;
41654 cast->next = type->cast;
41655 }
41656 type->cast = cast;
41657 }
41658 cast++;
41659 }
41660 /* Set entry in modules->types array equal to the type */
41661 swig_module.types[i] = type;
41662 }
41663 swig_module.types[i] = 0;
41664
41665 #ifdef SWIGRUNTIME_DEBUG
41666 printf("**** SWIG_InitializeModule: Cast List ******\n");
41667 for (i = 0; i < swig_module.size; ++i) {
41668 int j = 0;
41669 swig_cast_info *cast = swig_module.cast_initial[i];
41670 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41671 while (cast->type) {
41672 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41673 cast++;
41674 ++j;
41675 }
41676 printf("---- Total casts: %d\n",j);
41677 }
41678 printf("**** SWIG_InitializeModule: Cast List ******\n");
41679 #endif
41680 }
41681
41682 /* This function will propagate the clientdata field of type to
41683 * any new swig_type_info structures that have been added into the list
41684 * of equivalent types. It is like calling
41685 * SWIG_TypeClientData(type, clientdata) a second time.
41686 */
41687 SWIGRUNTIME void
41688 SWIG_PropagateClientData(void) {
41689 size_t i;
41690 swig_cast_info *equiv;
41691 static int init_run = 0;
41692
41693 if (init_run) return;
41694 init_run = 1;
41695
41696 for (i = 0; i < swig_module.size; i++) {
41697 if (swig_module.types[i]->clientdata) {
41698 equiv = swig_module.types[i]->cast;
41699 while (equiv) {
41700 if (!equiv->converter) {
41701 if (equiv->type && !equiv->type->clientdata)
41702 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41703 }
41704 equiv = equiv->next;
41705 }
41706 }
41707 }
41708 }
41709
41710 #ifdef __cplusplus
41711 #if 0
41712 {
41713 /* c-mode */
41714 #endif
41715 }
41716 #endif
41717
41718
41719
41720 #ifdef __cplusplus
41721 extern "C" {
41722 #endif
41723
41724 /* Python-specific SWIG API */
41725 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41726 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41727 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41728
41729 /* -----------------------------------------------------------------------------
41730 * global variable support code.
41731 * ----------------------------------------------------------------------------- */
41732
41733 typedef struct swig_globalvar {
41734 char *name; /* Name of global variable */
41735 PyObject *(*get_attr)(void); /* Return the current value */
41736 int (*set_attr)(PyObject *); /* Set the value */
41737 struct swig_globalvar *next;
41738 } swig_globalvar;
41739
41740 typedef struct swig_varlinkobject {
41741 PyObject_HEAD
41742 swig_globalvar *vars;
41743 } swig_varlinkobject;
41744
41745 SWIGINTERN PyObject *
41746 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41747 return PyString_FromString("<Swig global variables>");
41748 }
41749
41750 SWIGINTERN PyObject *
41751 swig_varlink_str(swig_varlinkobject *v) {
41752 PyObject *str = PyString_FromString("(");
41753 swig_globalvar *var;
41754 for (var = v->vars; var; var=var->next) {
41755 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41756 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41757 }
41758 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41759 return str;
41760 }
41761
41762 SWIGINTERN int
41763 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41764 PyObject *str = swig_varlink_str(v);
41765 fprintf(fp,"Swig global variables ");
41766 fprintf(fp,"%s\n", PyString_AsString(str));
41767 Py_DECREF(str);
41768 return 0;
41769 }
41770
41771 SWIGINTERN void
41772 swig_varlink_dealloc(swig_varlinkobject *v) {
41773 swig_globalvar *var = v->vars;
41774 while (var) {
41775 swig_globalvar *n = var->next;
41776 free(var->name);
41777 free(var);
41778 var = n;
41779 }
41780 }
41781
41782 SWIGINTERN PyObject *
41783 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41784 PyObject *res = NULL;
41785 swig_globalvar *var = v->vars;
41786 while (var) {
41787 if (strcmp(var->name,n) == 0) {
41788 res = (*var->get_attr)();
41789 break;
41790 }
41791 var = var->next;
41792 }
41793 if (res == NULL && !PyErr_Occurred()) {
41794 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41795 }
41796 return res;
41797 }
41798
41799 SWIGINTERN int
41800 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41801 int res = 1;
41802 swig_globalvar *var = v->vars;
41803 while (var) {
41804 if (strcmp(var->name,n) == 0) {
41805 res = (*var->set_attr)(p);
41806 break;
41807 }
41808 var = var->next;
41809 }
41810 if (res == 1 && !PyErr_Occurred()) {
41811 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41812 }
41813 return res;
41814 }
41815
41816 SWIGINTERN PyTypeObject*
41817 swig_varlink_type(void) {
41818 static char varlink__doc__[] = "Swig var link object";
41819 static PyTypeObject varlink_type;
41820 static int type_init = 0;
41821 if (!type_init) {
41822 const PyTypeObject tmp
41823 = {
41824 PyObject_HEAD_INIT(NULL)
41825 0, /* Number of items in variable part (ob_size) */
41826 (char *)"swigvarlink", /* Type name (tp_name) */
41827 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41828 0, /* Itemsize (tp_itemsize) */
41829 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41830 (printfunc) swig_varlink_print, /* Print (tp_print) */
41831 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41832 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41833 0, /* tp_compare */
41834 (reprfunc) swig_varlink_repr, /* tp_repr */
41835 0, /* tp_as_number */
41836 0, /* tp_as_sequence */
41837 0, /* tp_as_mapping */
41838 0, /* tp_hash */
41839 0, /* tp_call */
41840 (reprfunc)swig_varlink_str, /* tp_str */
41841 0, /* tp_getattro */
41842 0, /* tp_setattro */
41843 0, /* tp_as_buffer */
41844 0, /* tp_flags */
41845 varlink__doc__, /* tp_doc */
41846 0, /* tp_traverse */
41847 0, /* tp_clear */
41848 0, /* tp_richcompare */
41849 0, /* tp_weaklistoffset */
41850 #if PY_VERSION_HEX >= 0x02020000
41851 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41852 #endif
41853 #if PY_VERSION_HEX >= 0x02030000
41854 0, /* tp_del */
41855 #endif
41856 #ifdef COUNT_ALLOCS
41857 0,0,0,0 /* tp_alloc -> tp_next */
41858 #endif
41859 };
41860 varlink_type = tmp;
41861 varlink_type.ob_type = &PyType_Type;
41862 type_init = 1;
41863 }
41864 return &varlink_type;
41865 }
41866
41867 /* Create a variable linking object for use later */
41868 SWIGINTERN PyObject *
41869 SWIG_Python_newvarlink(void) {
41870 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41871 if (result) {
41872 result->vars = 0;
41873 }
41874 return ((PyObject*) result);
41875 }
41876
41877 SWIGINTERN void
41878 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41879 swig_varlinkobject *v = (swig_varlinkobject *) p;
41880 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41881 if (gv) {
41882 size_t size = strlen(name)+1;
41883 gv->name = (char *)malloc(size);
41884 if (gv->name) {
41885 strncpy(gv->name,name,size);
41886 gv->get_attr = get_attr;
41887 gv->set_attr = set_attr;
41888 gv->next = v->vars;
41889 }
41890 }
41891 v->vars = gv;
41892 }
41893
41894 SWIGINTERN PyObject *
41895 SWIG_globals() {
41896 static PyObject *_SWIG_globals = 0;
41897 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41898 return _SWIG_globals;
41899 }
41900
41901 /* -----------------------------------------------------------------------------
41902 * constants/methods manipulation
41903 * ----------------------------------------------------------------------------- */
41904
41905 /* Install Constants */
41906 SWIGINTERN void
41907 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41908 PyObject *obj = 0;
41909 size_t i;
41910 for (i = 0; constants[i].type; ++i) {
41911 switch(constants[i].type) {
41912 case SWIG_PY_POINTER:
41913 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41914 break;
41915 case SWIG_PY_BINARY:
41916 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41917 break;
41918 default:
41919 obj = 0;
41920 break;
41921 }
41922 if (obj) {
41923 PyDict_SetItemString(d, constants[i].name, obj);
41924 Py_DECREF(obj);
41925 }
41926 }
41927 }
41928
41929 /* -----------------------------------------------------------------------------*/
41930 /* Fix SwigMethods to carry the callback ptrs when needed */
41931 /* -----------------------------------------------------------------------------*/
41932
41933 SWIGINTERN void
41934 SWIG_Python_FixMethods(PyMethodDef *methods,
41935 swig_const_info *const_table,
41936 swig_type_info **types,
41937 swig_type_info **types_initial) {
41938 size_t i;
41939 for (i = 0; methods[i].ml_name; ++i) {
41940 const char *c = methods[i].ml_doc;
41941 if (c && (c = strstr(c, "swig_ptr: "))) {
41942 int j;
41943 swig_const_info *ci = 0;
41944 const char *name = c + 10;
41945 for (j = 0; const_table[j].type; ++j) {
41946 if (strncmp(const_table[j].name, name,
41947 strlen(const_table[j].name)) == 0) {
41948 ci = &(const_table[j]);
41949 break;
41950 }
41951 }
41952 if (ci) {
41953 size_t shift = (ci->ptype) - types;
41954 swig_type_info *ty = types_initial[shift];
41955 size_t ldoc = (c - methods[i].ml_doc);
41956 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41957 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41958 if (ndoc) {
41959 char *buff = ndoc;
41960 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41961 if (ptr) {
41962 strncpy(buff, methods[i].ml_doc, ldoc);
41963 buff += ldoc;
41964 strncpy(buff, "swig_ptr: ", 10);
41965 buff += 10;
41966 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41967 methods[i].ml_doc = ndoc;
41968 }
41969 }
41970 }
41971 }
41972 }
41973 }
41974
41975 #ifdef __cplusplus
41976 }
41977 #endif
41978
41979 /* -----------------------------------------------------------------------------*
41980 * Partial Init method
41981 * -----------------------------------------------------------------------------*/
41982
41983 #ifdef __cplusplus
41984 extern "C"
41985 #endif
41986 SWIGEXPORT void SWIG_init(void) {
41987 PyObject *m, *d;
41988
41989 /* Fix SwigMethods to carry the callback ptrs when needed */
41990 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41991
41992 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41993 d = PyModule_GetDict(m);
41994
41995 SWIG_InitializeModule(0);
41996 SWIG_InstallConstants(d,swig_const_table);
41997
41998
41999 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
42000 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
42001 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
42002 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
42003 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
42004 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
42005 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
42006 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
42007 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
42008 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
42009 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
42010 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
42011 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
42012 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
42013 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
42014 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
42015 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
42016 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
42017 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
42018 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
42019 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
42020 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
42021 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
42022 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
42023 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
42024 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
42025 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
42026 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
42027 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
42028 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
42029 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
42030 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
42031 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
42032 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
42033 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
42034 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
42035 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
42036 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
42037 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
42038 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
42039 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
42040 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
42041 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
42042 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
42043 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
42044 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
42045 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
42046 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
42047 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
42048 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
42049 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
42050 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
42051 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
42052 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
42053 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
42054 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
42055 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
42056 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
42057 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
42058 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
42059 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
42060 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
42061 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42062 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42063 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42064 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42065 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42066 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42067 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42068 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42069 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42070 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42071 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42072 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42073 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42074 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42075 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42076 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42077 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42078 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42079 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42080 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42081 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42082 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42083 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42084 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42085 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42086 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42087 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42088 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42089 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42090 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42091 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42092 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42093 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42094 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42095 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42096 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42097 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42098 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42099 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42100 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42101 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42102 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42103 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42104 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42105 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42106 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42107 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42108 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42109 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42110 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42111 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42112 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42113 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42114 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42115 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42116 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42117 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42118 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42119 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42120 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42121 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42122 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42123 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42124 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42125 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42126 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42127 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42128 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42129 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42130 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42131 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42132 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42133 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42134 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42135 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42136 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42137 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42138 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42139 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42140 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42141 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42142 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42143 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42144 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42145 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42146 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42147
42148 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42149
42150 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42151 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42152 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42153 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42154 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42155 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42156 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42157 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42158 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42159 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42160 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42161 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42162 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42163 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42164 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42165 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42166 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42167 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42168 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42169 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42170 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42171 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42172 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42173 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42174 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42175 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42176 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42177 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42178 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42179 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42180 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42181 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42182 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42183 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42184 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42185 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42186 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42187 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42188 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42189 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42190 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42191 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42192 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42193 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42194 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42195 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42196 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42197 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42198 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42199 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42200 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42201 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42202 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42203 SWIG_Python_SetConstant(d, "EXEC_NOEVENTS",SWIG_From_int(static_cast< int >(wxEXEC_NOEVENTS)));
42204 SWIG_Python_SetConstant(d, "EXEC_BLOCK",SWIG_From_int(static_cast< int >(wxEXEC_BLOCK)));
42205
42206 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42207
42208 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42209 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42210 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42211 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42212 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42213 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42214 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42215 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42216 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42217 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42218 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42219 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42220 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42221 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42222 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42223 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42224 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42225 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42226 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42227 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST",ART_LIST_get, ART_LIST_set);
42236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42240 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42241 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42242 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42243 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42244 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42245 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42246 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42247 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42248 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42249 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42250 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42251 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42252 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42253 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42254 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42255 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42256 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42257 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42258 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42259 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42260 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42261 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42262 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42263 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42264 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42265 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42266 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42267 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42268 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42269 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42270 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42271 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42272 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42273 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42274 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42275 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42276 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42277 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42278 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42279 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42280 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42281 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42282 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42283 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42284 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42285
42286 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42287
42288 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42289 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42290 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42291 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42292 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42293 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42294 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42295 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42296 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42297 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42298 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42299 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42300 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42301 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42302 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42303 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42304 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42305 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42306 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42307 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42308 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42309 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42310 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42311 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42312 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42313 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42314 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42315 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42316 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42317 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42318 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42319 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42320 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42321 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42322 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42323 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42324 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42325 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42326 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42327 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42328 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42329 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42330 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42331 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42332 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42333 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42334 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42335 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42336 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42337 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42338 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42339 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42340 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42341 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42342 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42343 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42344 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42345 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42346 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42347 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42348 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42349 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42350 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42351 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42352 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42353 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42354 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42355 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42356 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42357 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42358 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42359 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42360 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42361 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42362 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42363 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42364 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42365 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42366 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42367 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42368 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42369 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42370 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42371 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42372 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42373 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42374 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42375 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42376 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42377 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42378 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42379 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42380 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42381 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42382 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42383 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42384 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42385 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42386 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42387 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42388 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42389 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42390 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42391 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42392 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42393 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42394 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42395 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42396 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42397 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42398 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42399 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42400 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42401 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42402 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42403 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42404 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42405 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42406 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42407 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42408 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42409 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42410 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42411 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42412 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42413 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42414 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42415 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42416 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42417 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42418 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42419 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42420 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42421 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42422 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42423 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42424 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42425 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42426 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42427 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42428 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42429 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42430 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42431 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42432 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42433 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42434 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42435 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42436 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42437 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42438 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42439 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42440 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42441 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42442 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42443 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42444 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42445 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42446 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42447 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42448 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42449 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42450 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42451 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42452 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42453 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42454 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42455 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42456 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42457 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42458 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42459 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42460 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42461 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42462 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42463 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42464 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42465 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42466 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42467 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42468 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42469 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42470 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42471 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42472 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42473 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42474 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42475 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42476 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42477 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42478 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42479 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42480 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42481 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42482 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42483 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42484 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42485 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42486 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42487 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42488 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42489 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42490 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42491
42492 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42493 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42494 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42495 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42496
42497 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42498 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42499 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42500 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42501 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42502 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42503 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42504 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42505 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42506 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42507 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42508 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42509 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42510 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42511 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42512 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42513 }
42514
wxWidgets (Impactor)