]> 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_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTGAHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTIFFHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTextCtrl swig_types[157]
2624 #define SWIGTYPE_p_wxTextDataObject swig_types[158]
2625 #define SWIGTYPE_p_wxTimeSpan swig_types[159]
2626 #define SWIGTYPE_p_wxTimer swig_types[160]
2627 #define SWIGTYPE_p_wxTimerEvent swig_types[161]
2628 #define SWIGTYPE_p_wxTimerRunner swig_types[162]
2629 #define SWIGTYPE_p_wxTipProvider swig_types[163]
2630 #define SWIGTYPE_p_wxToolTip swig_types[164]
2631 #define SWIGTYPE_p_wxURLDataObject swig_types[165]
2632 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[166]
2633 #define SWIGTYPE_p_wxValidator swig_types[167]
2634 #define SWIGTYPE_p_wxVideoMode swig_types[168]
2635 #define SWIGTYPE_p_wxWindow swig_types[169]
2636 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDisabler swig_types[172]
2639 #define SWIGTYPE_p_wxXPMHandler swig_types[173]
2640 static swig_type_info *swig_types[175];
2641 static swig_module_info swig_module = {swig_types, 174, 0, 0, 0, 0};
2642 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2643 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2644
2645 /* -------- TYPES TABLE (END) -------- */
2646
2647 #if (PY_VERSION_HEX <= 0x02000000)
2648 # if !defined(SWIG_PYTHON_CLASSIC)
2649 # error "This python version requires to use swig with the '-classic' option"
2650 # endif
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodern' option"
2654 #endif
2655 #if (PY_VERSION_HEX <= 0x02020000)
2656 # error "This python version requires to use swig with the '-nomodernargs' option"
2657 #endif
2658 #ifndef METH_O
2659 # error "This python version requires to use swig with the '-nofastunpack' option"
2660 #endif
2661
2662 /*-----------------------------------------------
2663 @(target):= _misc_.so
2664 ------------------------------------------------*/
2665 #define SWIG_init init_misc_
2666
2667 #define SWIG_name "_misc_"
2668
2669 #define SWIGVERSION 0x010329
2670
2671
2672 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2673 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2674
2675
2676 #include <stdexcept>
2677
2678
2679 namespace swig {
2680 class PyObject_ptr {
2681 protected:
2682 PyObject *_obj;
2683
2684 public:
2685 PyObject_ptr() :_obj(0)
2686 {
2687 }
2688
2689 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2690 {
2691 Py_XINCREF(_obj);
2692 }
2693
2694 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2695 {
2696 if (initial_ref) Py_XINCREF(_obj);
2697 }
2698
2699 PyObject_ptr & operator=(const PyObject_ptr& item)
2700 {
2701 Py_XINCREF(item._obj);
2702 Py_XDECREF(_obj);
2703 _obj = item._obj;
2704 return *this;
2705 }
2706
2707 ~PyObject_ptr()
2708 {
2709 Py_XDECREF(_obj);
2710 }
2711
2712 operator PyObject *() const
2713 {
2714 return _obj;
2715 }
2716
2717 PyObject *operator->() const
2718 {
2719 return _obj;
2720 }
2721 };
2722 }
2723
2724
2725 namespace swig {
2726 struct PyObject_var : PyObject_ptr {
2727 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2728
2729 PyObject_var & operator = (PyObject* obj)
2730 {
2731 Py_XDECREF(_obj);
2732 _obj = obj;
2733 return *this;
2734 }
2735 };
2736 }
2737
2738
2739 #include "wx/wxPython/wxPython.h"
2740 #include "wx/wxPython/pyclasses.h"
2741 #include "wx/wxPython/pyistream.h"
2742
2743 static const wxString wxPyEmptyString(wxEmptyString);
2744
2745
2746
2747 #define SWIG_From_long PyInt_FromLong
2748
2749
2750 SWIGINTERNINLINE PyObject *
2751 SWIG_From_int (int value)
2752 {
2753 return SWIG_From_long (value);
2754 }
2755
2756
2757 #include <limits.h>
2758 #ifndef LLONG_MIN
2759 # define LLONG_MIN LONG_LONG_MIN
2760 #endif
2761 #ifndef LLONG_MAX
2762 # define LLONG_MAX LONG_LONG_MAX
2763 #endif
2764 #ifndef ULLONG_MAX
2765 # define ULLONG_MAX ULONG_LONG_MAX
2766 #endif
2767
2768
2769 SWIGINTERN int
2770 SWIG_AsVal_long (PyObject* obj, long* val)
2771 {
2772 if (PyNumber_Check(obj)) {
2773 if (val) *val = PyInt_AsLong(obj);
2774 return SWIG_OK;
2775 }
2776 return SWIG_TypeError;
2777 }
2778
2779
2780 SWIGINTERN int
2781 SWIG_AsVal_int (PyObject * obj, int *val)
2782 {
2783 long v;
2784 int res = SWIG_AsVal_long (obj, &v);
2785 if (SWIG_IsOK(res)) {
2786 if ((v < INT_MIN || v > INT_MAX)) {
2787 return SWIG_OverflowError;
2788 } else {
2789 if (val) *val = static_cast< int >(v);
2790 }
2791 }
2792 return res;
2793 }
2794
2795 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2796
2797 #include <wx/stockitem.h>
2798
2799 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2800 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2801 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2802
2803 SWIGINTERN int
2804 SWIG_AsVal_bool (PyObject *obj, bool *val)
2805 {
2806 if (obj == Py_True) {
2807 if (val) *val = true;
2808 return SWIG_OK;
2809 } else if (obj == Py_False) {
2810 if (val) *val = false;
2811 return SWIG_OK;
2812 } else {
2813 long v = 0;
2814 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2815 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2816 return res;
2817 }
2818 }
2819
2820
2821 wxMemorySize wxGetFreeMemory()
2822 { wxPyRaiseNotImplemented(); return 0; }
2823
2824
2825 SWIGINTERN int
2826 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2827 {
2828 long v = 0;
2829 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2830 return SWIG_TypeError;
2831 }
2832 else if (val)
2833 *val = (unsigned long)v;
2834 return SWIG_OK;
2835 }
2836
2837
2838 SWIGINTERNINLINE PyObject*
2839 SWIG_From_unsigned_SS_long (unsigned long value)
2840 {
2841 return (value > LONG_MAX) ?
2842 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2843 }
2844
2845
2846 void* wxGetXDisplay()
2847 {
2848 #ifdef __WXGTK__
2849 return wxGetDisplay();
2850 #else
2851 return NULL;
2852 #endif
2853 }
2854
2855
2856 wxWindow* FindWindowAtPointer() {
2857 wxPoint unused;
2858 return wxFindWindowAtPointer(unused);
2859 }
2860
2861
2862 void wxWakeUpMainThread() {}
2863
2864
2865 bool wxThread_IsMain() {
2866 #ifdef WXP_WITH_THREAD
2867 return wxThread::IsMain();
2868 #else
2869 return true;
2870 #endif
2871 }
2872
2873 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2874 delete self;
2875 }
2876
2877 #include <wx/snglinst.h>
2878
2879
2880 #ifdef __WXMSW__
2881 #include <wx/msw/private.h>
2882 #include <wx/dynload.h>
2883 #endif
2884
2885
2886
2887 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2888 #if 0
2889 , int method
2890 #endif
2891 )
2892 {
2893 #ifdef __WXMSW__
2894 #if 0
2895 switch (method)
2896 {
2897 case 1:
2898 // This one only partially works. Appears to be an undocumented
2899 // "standard" convention that not all widgets adhear to. For
2900 // example, for some widgets backgrounds or non-client areas may
2901 // not be painted.
2902 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2903 break;
2904
2905 case 2:
2906 #endif
2907 // This one works much better, nearly all widgets and their
2908 // children are captured correctly[**]. Prior to the big
2909 // background erase changes that Vadim did in 2004-2005 this
2910 // method failed badly on XP with Themes activated, most native
2911 // widgets draw only partially, if at all. Without themes it
2912 // worked just like on Win2k. After those changes this method
2913 // works very well.
2914 //
2915 // ** For example the radio buttons in a wxRadioBox are not its
2916 // children by default, but you can capture it via the panel
2917 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2918 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2919 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2920 PRF_ERASEBKGND | PRF_OWNED );
2921 return true;
2922 #if 0
2923 break;
2924
2925 case 3:
2926 // This one is only defined in the latest SDK and is only
2927 // available on XP. MSDN says it is similar to sending WM_PRINT
2928 // so I expect that it will work similar to the above. Since it
2929 // is avaialble only on XP, it can't be compiled like this and
2930 // will have to be loaded dynamically.
2931 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2932
2933 // fall through
2934
2935 case 4:
2936 // Use PrintWindow if available, or fallback to WM_PRINT
2937 // otherwise. Unfortunately using PrintWindow is even worse than
2938 // WM_PRINT. For most native widgets nothing is drawn to the dc
2939 // at all, with or without Themes.
2940 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2941 static bool s_triedToLoad = false;
2942 static PrintWindow_t pfnPrintWindow = NULL;
2943 if ( !s_triedToLoad )
2944 {
2945
2946 s_triedToLoad = true;
2947 wxDynamicLibrary dllUser32(_T("user32.dll"));
2948 if ( dllUser32.IsLoaded() )
2949 {
2950 wxLogNull nolog; // Don't report errors here
2951 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2952 }
2953 }
2954 if (pfnPrintWindow)
2955 {
2956 //printf("Using PrintWindow\n");
2957 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2958 }
2959 else
2960 {
2961 //printf("Using WM_PRINT\n");
2962 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2963 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2964 PRF_ERASEBKGND | PRF_OWNED );
2965 }
2966 }
2967 #endif // 0
2968 #else
2969 return false;
2970 #endif // __WXMSW__
2971 }
2972
2973
2974
2975 #include <wx/tipdlg.h>
2976
2977
2978 SWIGINTERNINLINE PyObject *
2979 SWIG_From_size_t (size_t value)
2980 {
2981 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2982 }
2983
2984
2985 class wxPyTipProvider : public wxTipProvider {
2986 public:
2987 wxPyTipProvider(size_t currentTip)
2988 : wxTipProvider(currentTip) {}
2989
2990 DEC_PYCALLBACK_STRING__pure(GetTip);
2991 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2992 PYPRIVATE;
2993 };
2994
2995 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2996 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2997
2998
2999 SWIGINTERNINLINE int
3000 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3001 {
3002 unsigned long v;
3003 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3004 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3005 return res;
3006 }
3007
3008
3009 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3010
3011 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3012
3013 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3014 : wxTimer(owner, id)
3015 {
3016 if (owner == NULL)
3017 SetOwner(this);
3018 }
3019
3020
3021 SWIGINTERN swig_type_info*
3022 SWIG_pchar_descriptor()
3023 {
3024 static int init = 0;
3025 static swig_type_info* info = 0;
3026 if (!init) {
3027 info = SWIG_TypeQuery("_p_char");
3028 init = 1;
3029 }
3030 return info;
3031 }
3032
3033
3034 SWIGINTERNINLINE PyObject *
3035 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3036 {
3037 if (carray) {
3038 if (size > INT_MAX) {
3039 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3040 return pchar_descriptor ?
3041 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3042 } else {
3043 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3044 }
3045 } else {
3046 return SWIG_Py_Void();
3047 }
3048 }
3049
3050
3051 SWIGINTERNINLINE PyObject *
3052 SWIG_FromCharPtr(const char *cptr)
3053 {
3054 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3055 }
3056
3057
3058 SWIGINTERN int
3059 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3060 {
3061 unsigned long v;
3062 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3063 if (SWIG_IsOK(res)) {
3064 if ((v > UINT_MAX)) {
3065 return SWIG_OverflowError;
3066 } else {
3067 if (val) *val = static_cast< unsigned int >(v);
3068 }
3069 }
3070 return res;
3071 }
3072
3073 SWIGINTERN wxString wxLog_TimeStamp(){
3074 wxString msg;
3075 wxLog::TimeStamp(&msg);
3076 return msg;
3077 }
3078 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3079 // Make some wrappers that double any % signs so they are 'escaped'
3080 void wxPyLogFatalError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogFatalError(m);
3085 }
3086
3087 void wxPyLogError(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogError(m);
3092 }
3093
3094 void wxPyLogWarning(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogWarning(m);
3099 }
3100
3101 void wxPyLogMessage(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogMessage(m);
3106 }
3107
3108 void wxPyLogInfo(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogInfo(m);
3113 }
3114
3115 void wxPyLogDebug(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogDebug(m);
3120 }
3121
3122 void wxPyLogVerbose(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogVerbose(m);
3127 }
3128
3129 void wxPyLogStatus(const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(m);
3134 }
3135
3136 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogStatus(pFrame, m);
3141 }
3142
3143 void wxPyLogSysError(const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogSysError(m);
3148 }
3149
3150 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogGeneric(level, m);
3155 }
3156
3157 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3165 {
3166 wxString m(msg);
3167 m.Replace(wxT("%"), wxT("%%"));
3168 wxLogTrace(mask, m);
3169 }
3170
3171
3172
3173 // A wxLog class that can be derived from in wxPython
3174 class wxPyLog : public wxLog {
3175 public:
3176 wxPyLog() : wxLog() {}
3177
3178 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3179 bool found;
3180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3181 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3182 PyObject* s = wx2PyString(szString);
3183 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3184 Py_DECREF(s);
3185 }
3186 wxPyEndBlockThreads(blocked);
3187 if (! found)
3188 wxLog::DoLog(level, szString, t);
3189 }
3190
3191 virtual void DoLogString(const wxChar *szString, time_t t) {
3192 bool found;
3193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3194 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3195 PyObject* s = wx2PyString(szString);
3196 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3197 Py_DECREF(s);
3198 }
3199 wxPyEndBlockThreads(blocked);
3200 if (! found)
3201 wxLog::DoLogString(szString, t);
3202 }
3203
3204 DEC_PYCALLBACK_VOID_(Flush);
3205 PYPRIVATE;
3206 };
3207 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3208
3209
3210
3211
3212 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3213
3214
3215 #include <wx/joystick.h>
3216
3217
3218 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3219 // A C++ stub class for wxJoystick for platforms that don't have it.
3220 class wxJoystick : public wxObject {
3221 public:
3222 wxJoystick(int joystick = wxJOYSTICK1) {
3223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3224 PyErr_SetString(PyExc_NotImplementedError,
3225 "wxJoystick is not available on this platform.");
3226 wxPyEndBlockThreads(blocked);
3227 }
3228 wxPoint GetPosition() { return wxPoint(-1,-1); }
3229 int GetZPosition() { return -1; }
3230 int GetButtonState() { return -1; }
3231 int GetPOVPosition() { return -1; }
3232 int GetPOVCTSPosition() { return -1; }
3233 int GetRudderPosition() { return -1; }
3234 int GetUPosition() { return -1; }
3235 int GetVPosition() { return -1; }
3236 int GetMovementThreshold() { return -1; }
3237 void SetMovementThreshold(int threshold) {}
3238
3239 bool IsOk(void) { return false; }
3240 int GetNumberJoysticks() { return -1; }
3241 int GetManufacturerId() { return -1; }
3242 int GetProductId() { return -1; }
3243 wxString GetProductName() { return wxEmptyString; }
3244 int GetXMin() { return -1; }
3245 int GetYMin() { return -1; }
3246 int GetZMin() { return -1; }
3247 int GetXMax() { return -1; }
3248 int GetYMax() { return -1; }
3249 int GetZMax() { return -1; }
3250 int GetNumberButtons() { return -1; }
3251 int GetNumberAxes() { return -1; }
3252 int GetMaxButtons() { return -1; }
3253 int GetMaxAxes() { return -1; }
3254 int GetPollingMin() { return -1; }
3255 int GetPollingMax() { return -1; }
3256 int GetRudderMin() { return -1; }
3257 int GetRudderMax() { return -1; }
3258 int GetUMin() { return -1; }
3259 int GetUMax() { return -1; }
3260 int GetVMin() { return -1; }
3261 int GetVMax() { return -1; }
3262
3263 bool HasRudder() { return false; }
3264 bool HasZ() { return false; }
3265 bool HasU() { return false; }
3266 bool HasV() { return false; }
3267 bool HasPOV() { return false; }
3268 bool HasPOV4Dir() { return false; }
3269 bool HasPOVCTS() { return false; }
3270
3271 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3272 bool ReleaseCapture() { return false; }
3273 };
3274 #endif
3275
3276
3277 #include <wx/sound.h>
3278
3279
3280 #if !wxUSE_SOUND
3281 // A C++ stub class for wxWave for platforms that don't have it.
3282 class wxSound : public wxObject
3283 {
3284 public:
3285 wxSound() {
3286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3287 PyErr_SetString(PyExc_NotImplementedError,
3288 "wxSound is not available on this platform.");
3289 wxPyEndBlockThreads(blocked);
3290 }
3291 wxSound(const wxString&/*, bool*/) {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297 wxSound(int, const wxByte*) {
3298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3299 PyErr_SetString(PyExc_NotImplementedError,
3300 "wxSound is not available on this platform.");
3301 wxPyEndBlockThreads(blocked);
3302 }
3303
3304 ~wxSound() {};
3305
3306 bool Create(const wxString&/*, bool*/) { return false; }
3307 bool Create(int, const wxByte*) { return false; };
3308 bool IsOk() { return false; };
3309 bool Play(unsigned) const { return false; }
3310 static bool Play(const wxString&, unsigned) { return false; }
3311 static void Stop() {}
3312 };
3313
3314 #endif
3315
3316 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3317 if (fileName.Length() == 0)
3318 return new wxSound;
3319 else
3320 return new wxSound(fileName);
3321 }
3322 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3323 unsigned char* buffer; int size;
3324 wxSound *sound = NULL;
3325
3326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3327 if (!PyArg_Parse(data, "t#", &buffer, &size))
3328 goto done;
3329 sound = new wxSound(size, buffer);
3330 done:
3331 wxPyEndBlockThreads(blocked);
3332 return sound;
3333 }
3334 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3335 #ifndef __WXMAC__
3336 unsigned char* buffer;
3337 int size;
3338 bool rv = false;
3339
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 if (!PyArg_Parse(data, "t#", &buffer, &size))
3342 goto done;
3343 rv = self->Create(size, buffer);
3344 done:
3345 wxPyEndBlockThreads(blocked);
3346 return rv;
3347 #else
3348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3349 PyErr_SetString(PyExc_NotImplementedError,
3350 "Create from data is not available on this platform.");
3351 wxPyEndBlockThreads(blocked);
3352 return false;
3353 #endif
3354 }
3355
3356 #include <wx/mimetype.h>
3357
3358 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3359 wxString str;
3360 if (self->GetMimeType(&str))
3361 return wx2PyString(str);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetMimeTypes(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3373 wxArrayString arr;
3374 if (self->GetExtensions(arr))
3375 return wxArrayString2PyList_helper(arr);
3376 else
3377 RETURN_NONE();
3378 }
3379 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc))
3382 return new wxIcon(loc);
3383 else
3384 return NULL;
3385 }
3386 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3387 wxIconLocation loc;
3388 if (self->GetIcon(&loc)) {
3389 wxString iconFile = loc.GetFileName();
3390 int iconIndex = -1;
3391
3392
3393
3394 // Make a tuple and put the values in it
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 PyObject* tuple = PyTuple_New(3);
3397 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3398 wxT("wxIcon"), true));
3399 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3400 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3401 wxPyEndBlockThreads(blocked);
3402 return tuple;
3403 }
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3408 wxString str;
3409 if (self->GetDescription(&str))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxString str;
3423 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3424 return wx2PyString(str);
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 wxArrayString verbs;
3430 wxArrayString commands;
3431 if (self->GetAllCommands(&verbs, &commands,
3432 wxFileType::MessageParameters(filename, mimetype))) {
3433 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3434 PyObject* tuple = PyTuple_New(2);
3435 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3436 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3437 wxPyEndBlockThreads(blocked);
3438 return tuple;
3439 }
3440 else
3441 RETURN_NONE();
3442 }
3443 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3444 return wxFileType::ExpandCommand(command,
3445 wxFileType::MessageParameters(filename, mimetype));
3446 }
3447 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3448 wxArrayString arr;
3449 self->EnumAllFileTypes(arr);
3450 return wxArrayString2PyList_helper(arr);
3451 }
3452
3453 #include <wx/artprov.h>
3454
3455 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3456 static const wxString wxPyART_MENU(wxART_MENU);
3457 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3458 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3459 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3460 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3461 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3462 static const wxString wxPyART_OTHER(wxART_OTHER);
3463 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3464 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3465 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3466 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3467 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3468 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3469 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3470 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3471 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3472 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3473 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3474 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3475 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3476 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3477 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3478 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3479 static const wxString wxPyART_PRINT(wxART_PRINT);
3480 static const wxString wxPyART_HELP(wxART_HELP);
3481 static const wxString wxPyART_TIP(wxART_TIP);
3482 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3483 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3484 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3485 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3486 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3487 static const wxString wxPyART_CDROM(wxART_CDROM);
3488 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3489 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3490 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3491 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3492 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3493 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3494 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3495 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3496 static const wxString wxPyART_ERROR(wxART_ERROR);
3497 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3498 static const wxString wxPyART_WARNING(wxART_WARNING);
3499 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3500 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3501 static const wxString wxPyART_COPY(wxART_COPY);
3502 static const wxString wxPyART_CUT(wxART_CUT);
3503 static const wxString wxPyART_PASTE(wxART_PASTE);
3504 static const wxString wxPyART_DELETE(wxART_DELETE);
3505 static const wxString wxPyART_NEW(wxART_NEW);
3506 static const wxString wxPyART_UNDO(wxART_UNDO);
3507 static const wxString wxPyART_REDO(wxART_REDO);
3508 static const wxString wxPyART_QUIT(wxART_QUIT);
3509 static const wxString wxPyART_FIND(wxART_FIND);
3510 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3511 // Python aware wxArtProvider
3512 class wxPyArtProvider : public wxArtProvider {
3513 public:
3514
3515 virtual wxBitmap CreateBitmap(const wxArtID& id,
3516 const wxArtClient& client,
3517 const wxSize& size) {
3518 wxBitmap rval = wxNullBitmap;
3519 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3520 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3521 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3522 PyObject* ro;
3523 wxBitmap* ptr;
3524 PyObject* s1, *s2;
3525 s1 = wx2PyString(id);
3526 s2 = wx2PyString(client);
3527 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3528 Py_DECREF(so);
3529 Py_DECREF(s1);
3530 Py_DECREF(s2);
3531 if (ro) {
3532 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3533 rval = *ptr;
3534 Py_DECREF(ro);
3535 }
3536 }
3537 wxPyEndBlockThreads(blocked);
3538 return rval;
3539 }
3540
3541 PYPRIVATE;
3542 };
3543
3544 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3545
3546
3547
3548 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3549 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3550 PyObject* ret = PyTuple_New(3);
3551 if (ret) {
3552 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3553 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3554 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3555 }
3556 wxPyEndBlockThreads(blocked);
3557 return ret;
3558 }
3559
3560 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3561 bool cont;
3562 long index = 0;
3563 wxString value;
3564
3565 cont = self->GetFirstGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3569 bool cont;
3570 wxString value;
3571
3572 cont = self->GetNextGroup(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3576 bool cont;
3577 long index = 0;
3578 wxString value;
3579
3580 cont = self->GetFirstEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3584 bool cont;
3585 wxString value;
3586
3587 cont = self->GetNextEntry(value, index);
3588 return __EnumerationHelper(cont, value, index);
3589 }
3590 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3591 long rv;
3592 self->Read(key, &rv, defaultVal);
3593 return rv;
3594 }
3595
3596 SWIGINTERN int
3597 SWIG_AsVal_double (PyObject *obj, double* val)
3598 {
3599 if (PyNumber_Check(obj)) {
3600 if (val) *val = PyFloat_AsDouble(obj);
3601 return SWIG_OK;
3602 }
3603 return SWIG_TypeError;
3604 }
3605
3606 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3607 double rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #define SWIG_From_double PyFloat_FromDouble
3613
3614 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3615 bool rv;
3616 self->Read(key, &rv, defaultVal);
3617 return rv;
3618 }
3619
3620 #include <wx/datetime.h>
3621
3622 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3623 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3624
3625 #define LOCAL_TZ wxDateTime::Local
3626
3627 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3628 wxString am;
3629 wxString pm;
3630 wxDateTime::GetAmPmStrings(&am, &pm);
3631 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3632 PyObject* tup = PyTuple_New(2);
3633 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3634 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3635 wxPyEndBlockThreads(blocked);
3636 return tup;
3637 }
3638
3639 SWIGINTERNINLINE PyObject *
3640 SWIG_From_unsigned_SS_int (unsigned int value)
3641 {
3642 return SWIG_From_unsigned_SS_long (value);
3643 }
3644
3645 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3646 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3647 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3648 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3649 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3650 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3652 return (*self < *other);
3653 }
3654 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3656 return (*self <= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3660 return (*self > *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3664 return (*self >= *other);
3665 }
3666 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3667 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3668 return (*self == *other);
3669 }
3670 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3671 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3672 return (*self != *other);
3673 }
3674 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseRfc822Date(_date);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3682 const wxChar* rv;
3683 const wxChar* _date = date;
3684 rv = self->ParseFormat(_date, format, dateDef);
3685 if (rv == NULL) return -1;
3686 return rv - _date;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3689 const wxChar* rv;
3690 const wxChar* _datetime = datetime;
3691 rv = self->ParseDateTime(_datetime);
3692 if (rv == NULL) return -1;
3693 return rv - _datetime;
3694 }
3695 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3696 const wxChar* rv;
3697 const wxChar* _date = date;
3698 rv = self->ParseDate(_date);
3699 if (rv == NULL) return -1;
3700 return rv - _date;
3701 }
3702 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3703 const wxChar* rv;
3704 const wxChar* _time = time;
3705 rv = self->ParseTime(_time);
3706 if (rv == NULL) return -1;
3707 return rv - _time;
3708 }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3712 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3713 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3714 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3716 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3717 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3718 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3719 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3720 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3721 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3722 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3723 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3724 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3725
3726 #include <wx/dataobj.h>
3727
3728 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3729 size_t count = self->GetFormatCount(dir);
3730 wxDataFormat* formats = new wxDataFormat[count];
3731 self->GetAllFormats(formats, dir);
3732
3733 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3734 PyObject* list = PyList_New(count);
3735 for (size_t i=0; i<count; i++) {
3736 wxDataFormat* format = new wxDataFormat(formats[i]);
3737 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3738 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 delete [] formats;
3742 return list;
3743 }
3744 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3745 PyObject* rval = NULL;
3746 size_t size = self->GetDataSize(format);
3747 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3748 if (size) {
3749 char* buf = new char[size];
3750 if (self->GetDataHere(format, buf))
3751 rval = PyString_FromStringAndSize(buf, size);
3752 delete [] buf;
3753 }
3754 if (! rval) {
3755 rval = Py_None;
3756 Py_INCREF(rval);
3757 }
3758 wxPyEndBlockThreads(blocked);
3759 return rval;
3760 }
3761 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3762 bool rval;
3763 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3764 if (PyString_Check(data)) {
3765 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3766 }
3767 else {
3768 // raise a TypeError if not a string
3769 PyErr_SetString(PyExc_TypeError, "String expected.");
3770 rval = false;
3771 }
3772 wxPyEndBlockThreads(blocked);
3773 return rval;
3774 }
3775 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3776 PyObject* rval = NULL;
3777 size_t size = self->GetDataSize();
3778 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3779 if (size) {
3780 char* buf = new char[size];
3781 if (self->GetDataHere(buf))
3782 rval = PyString_FromStringAndSize(buf, size);
3783 delete [] buf;
3784 }
3785 if (! rval) {
3786 rval = Py_None;
3787 Py_INCREF(rval);
3788 }
3789 wxPyEndBlockThreads(blocked);
3790 return rval;
3791 }
3792 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3793 bool rval;
3794 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3795 if (PyString_Check(data)) {
3796 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3797 }
3798 else {
3799 // raise a TypeError if not a string
3800 PyErr_SetString(PyExc_TypeError, "String expected.");
3801 rval = false;
3802 }
3803 wxPyEndBlockThreads(blocked);
3804 return rval;
3805 }
3806 // Create a new class for wxPython to use
3807 class wxPyDataObjectSimple : public wxDataObjectSimple {
3808 public:
3809 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3810 : wxDataObjectSimple(format) {}
3811
3812 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3813 bool GetDataHere(void *buf) const;
3814 bool SetData(size_t len, const void *buf);
3815 PYPRIVATE;
3816 };
3817
3818 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3819
3820 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3821 // We need to get the data for this object and write it to buf. I think
3822 // the best way to do this for wxPython is to have the Python method
3823 // return either a string or None and then act appropriately with the
3824 // C++ version.
3825
3826 bool rval = false;
3827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3828 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3829 PyObject* ro;
3830 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3831 if (ro) {
3832 rval = (ro != Py_None && PyString_Check(ro));
3833 if (rval)
3834 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3835 Py_DECREF(ro);
3836 }
3837 }
3838 wxPyEndBlockThreads(blocked);
3839 return rval;
3840 }
3841
3842 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3843 // For this one we simply need to make a string from buf and len
3844 // and send it to the Python method.
3845 bool rval = false;
3846 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3847 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3848 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3849 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3850 Py_DECREF(data);
3851 }
3852 wxPyEndBlockThreads(blocked);
3853 return rval;
3854 }
3855
3856 // Create a new class for wxPython to use
3857 class wxPyTextDataObject : public wxTextDataObject {
3858 public:
3859 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3860 : wxTextDataObject(text) {}
3861
3862 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3863 DEC_PYCALLBACK_STRING__const(GetText);
3864 DEC_PYCALLBACK__STRING(SetText);
3865 PYPRIVATE;
3866 };
3867
3868 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3869 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3870 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3871
3872
3873 // Create a new class for wxPython to use
3874 class wxPyBitmapDataObject : public wxBitmapDataObject {
3875 public:
3876 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3877 : wxBitmapDataObject(bitmap) {}
3878
3879 wxBitmap GetBitmap() const;
3880 void SetBitmap(const wxBitmap& bitmap);
3881 PYPRIVATE;
3882 };
3883
3884 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3885 wxBitmap* rval = &wxNullBitmap;
3886 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3887 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3888 PyObject* ro;
3889 wxBitmap* ptr;
3890 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3891 if (ro) {
3892 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3893 rval = ptr;
3894 Py_DECREF(ro);
3895 }
3896 }
3897 wxPyEndBlockThreads(blocked);
3898 return *rval;
3899 }
3900
3901 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3902 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3903 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3904 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3905 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3906 Py_DECREF(bo);
3907 }
3908 wxPyEndBlockThreads(blocked);
3909 }
3910
3911 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3912 return new wxCustomDataObject(wxDataFormat(formatName));
3913 }
3914 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3915 bool rval;
3916 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3917 if (PyString_Check(data)) {
3918 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3919 }
3920 else {
3921 // raise a TypeError if not a string
3922 PyErr_SetString(PyExc_TypeError, "String expected.");
3923 rval = false;
3924 }
3925 wxPyEndBlockThreads(blocked);
3926 return rval;
3927 }
3928 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3929 PyObject* obj;
3930 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3931 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3932 wxPyEndBlockThreads(blocked);
3933 return obj;
3934 }
3935
3936 class wxMetafileDataObject : public wxDataObjectSimple
3937 {
3938 public:
3939 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3940 };
3941
3942
3943 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3944
3945
3946 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3947 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3948 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3949 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3950 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3951
3952
3953 class wxPyTextDropTarget : public wxTextDropTarget {
3954 public:
3955 wxPyTextDropTarget() {}
3956
3957 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3958
3959 DEC_PYCALLBACK__(OnLeave);
3960 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3961 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3962 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3963 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3964
3965 PYPRIVATE;
3966 };
3967
3968 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3969 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3970 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3971 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3972 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3973 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3974
3975
3976
3977 class wxPyFileDropTarget : public wxFileDropTarget {
3978 public:
3979 wxPyFileDropTarget() {}
3980
3981 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3982
3983 DEC_PYCALLBACK__(OnLeave);
3984 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3985 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3986 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3987 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3988
3989 PYPRIVATE;
3990 };
3991
3992 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3993 const wxArrayString& filenames) {
3994 bool rval = false;
3995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3996 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3997 PyObject* list = wxArrayString2PyList_helper(filenames);
3998 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3999 Py_DECREF(list);
4000 }
4001 wxPyEndBlockThreads(blocked);
4002 return rval;
4003 }
4004
4005
4006
4007 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4008 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4009 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4010 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4011 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4012
4013
4014
4015
4016 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4017
4018 #include <wx/display.h>
4019
4020 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4021 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4022
4023 #if !wxUSE_DISPLAY
4024 const wxVideoMode wxDefaultVideoMode;
4025 #endif
4026
4027 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4028 #if wxUSE_DISPLAY
4029 PyObject* pyList = NULL;
4030 wxArrayVideoModes arr = self->GetModes(mode);
4031 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4032 pyList = PyList_New(0);
4033 for (size_t i=0; i < arr.GetCount(); i++)
4034 {
4035 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4036 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4037 PyList_Append(pyList, pyObj);
4038 Py_DECREF(pyObj);
4039 }
4040 wxPyEndBlockThreads(blocked);
4041 return pyList;
4042 #else
4043 wxPyRaiseNotImplemented();
4044 return NULL;
4045 #endif
4046 }
4047 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4048 #if wxUSE_DISPLAY
4049 return self->GetCurrentMode();
4050 #else
4051 wxPyRaiseNotImplemented();
4052 return wxDefaultVideoMode;
4053 #endif
4054 }
4055 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4056 #if wxUSE_DISPLAY
4057 return self->ChangeMode(mode);
4058 #else
4059 wxPyRaiseNotImplemented();
4060 return false;
4061 #endif
4062 }
4063 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4064 #if wxUSE_DISPLAY
4065 self->ResetMode();
4066 #else
4067 wxPyRaiseNotImplemented();
4068 #endif
4069 }
4070
4071 #include <wx/stdpaths.h>
4072
4073 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4074 return (wxStandardPaths*) &wxStandardPaths::Get();
4075 }
4076
4077 #ifndef wxHAS_POWER_EVENTS
4078 // Dummy class and other definitions for platforms that don't have them
4079
4080 // See wxPython_int.h for wxPowerEvent
4081
4082 enum {
4083 wxEVT_POWER_SUSPENDING,
4084 wxEVT_POWER_SUSPENDED,
4085 wxEVT_POWER_SUSPEND_CANCEL,
4086 wxEVT_POWER_RESUME,
4087 };
4088
4089 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4090 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4091
4092 #endif
4093
4094
4095 #include <wx/aboutdlg.h>
4096
4097 #ifdef __cplusplus
4098 extern "C" {
4099 #endif
4100 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj = 0;
4102 wxSystemColour arg1 ;
4103 wxColour result;
4104 int val1 ;
4105 int ecode1 = 0 ;
4106 PyObject * obj0 = 0 ;
4107 char * kwnames[] = {
4108 (char *) "index", NULL
4109 };
4110
4111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4112 ecode1 = SWIG_AsVal_int(obj0, &val1);
4113 if (!SWIG_IsOK(ecode1)) {
4114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4115 }
4116 arg1 = static_cast< wxSystemColour >(val1);
4117 {
4118 if (!wxPyCheckForApp()) SWIG_fail;
4119 PyThreadState* __tstate = wxPyBeginAllowThreads();
4120 result = wxSystemSettings::GetColour(arg1);
4121 wxPyEndAllowThreads(__tstate);
4122 if (PyErr_Occurred()) SWIG_fail;
4123 }
4124 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4125 return resultobj;
4126 fail:
4127 return NULL;
4128 }
4129
4130
4131 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4132 PyObject *resultobj = 0;
4133 wxSystemFont arg1 ;
4134 wxFont result;
4135 int val1 ;
4136 int ecode1 = 0 ;
4137 PyObject * obj0 = 0 ;
4138 char * kwnames[] = {
4139 (char *) "index", NULL
4140 };
4141
4142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4143 ecode1 = SWIG_AsVal_int(obj0, &val1);
4144 if (!SWIG_IsOK(ecode1)) {
4145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4146 }
4147 arg1 = static_cast< wxSystemFont >(val1);
4148 {
4149 if (!wxPyCheckForApp()) SWIG_fail;
4150 PyThreadState* __tstate = wxPyBeginAllowThreads();
4151 result = wxSystemSettings::GetFont(arg1);
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4163 PyObject *resultobj = 0;
4164 wxSystemMetric arg1 ;
4165 wxWindow *arg2 = (wxWindow *) NULL ;
4166 int result;
4167 int val1 ;
4168 int ecode1 = 0 ;
4169 void *argp2 = 0 ;
4170 int res2 = 0 ;
4171 PyObject * obj0 = 0 ;
4172 PyObject * obj1 = 0 ;
4173 char * kwnames[] = {
4174 (char *) "index",(char *) "win", NULL
4175 };
4176
4177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4178 ecode1 = SWIG_AsVal_int(obj0, &val1);
4179 if (!SWIG_IsOK(ecode1)) {
4180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4181 }
4182 arg1 = static_cast< wxSystemMetric >(val1);
4183 if (obj1) {
4184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4185 if (!SWIG_IsOK(res2)) {
4186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4187 }
4188 arg2 = reinterpret_cast< wxWindow * >(argp2);
4189 }
4190 {
4191 if (!wxPyCheckForApp()) SWIG_fail;
4192 PyThreadState* __tstate = wxPyBeginAllowThreads();
4193 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4194 wxPyEndAllowThreads(__tstate);
4195 if (PyErr_Occurred()) SWIG_fail;
4196 }
4197 resultobj = SWIG_From_int(static_cast< int >(result));
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj = 0;
4206 wxSystemFeature arg1 ;
4207 bool result;
4208 int val1 ;
4209 int ecode1 = 0 ;
4210 PyObject * obj0 = 0 ;
4211 char * kwnames[] = {
4212 (char *) "index", NULL
4213 };
4214
4215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4216 ecode1 = SWIG_AsVal_int(obj0, &val1);
4217 if (!SWIG_IsOK(ecode1)) {
4218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4219 }
4220 arg1 = static_cast< wxSystemFeature >(val1);
4221 {
4222 if (!wxPyCheckForApp()) SWIG_fail;
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = (bool)wxSystemSettings::HasFeature(arg1);
4225 wxPyEndAllowThreads(__tstate);
4226 if (PyErr_Occurred()) SWIG_fail;
4227 }
4228 {
4229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4230 }
4231 return resultobj;
4232 fail:
4233 return NULL;
4234 }
4235
4236
4237 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4238 PyObject *resultobj = 0;
4239 wxSystemScreenType result;
4240
4241 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4242 {
4243 if (!wxPyCheckForApp()) SWIG_fail;
4244 PyThreadState* __tstate = wxPyBeginAllowThreads();
4245 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 resultobj = SWIG_From_int(static_cast< int >(result));
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj = 0;
4258 wxSystemScreenType arg1 ;
4259 int val1 ;
4260 int ecode1 = 0 ;
4261 PyObject * obj0 = 0 ;
4262 char * kwnames[] = {
4263 (char *) "screen", NULL
4264 };
4265
4266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4267 ecode1 = SWIG_AsVal_int(obj0, &val1);
4268 if (!SWIG_IsOK(ecode1)) {
4269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4270 }
4271 arg1 = static_cast< wxSystemScreenType >(val1);
4272 {
4273 if (!wxPyCheckForApp()) SWIG_fail;
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 wxSystemSettings::SetScreenType(arg1);
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 resultobj = SWIG_Py_Void();
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4287 PyObject *obj;
4288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4289 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4290 return SWIG_Py_Void();
4291 }
4292
4293 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4294 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4295 return 1;
4296 }
4297
4298
4299 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4300 PyObject *pyobj = 0;
4301
4302 {
4303 #if wxUSE_UNICODE
4304 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4305 #else
4306 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4307 #endif
4308 }
4309 return pyobj;
4310 }
4311
4312
4313 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4314 PyObject *resultobj = 0;
4315 wxSystemOptions *result = 0 ;
4316
4317 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 result = (wxSystemOptions *)new wxSystemOptions();
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4325 return resultobj;
4326 fail:
4327 return NULL;
4328 }
4329
4330
4331 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4332 PyObject *resultobj = 0;
4333 wxString *arg1 = 0 ;
4334 wxString *arg2 = 0 ;
4335 bool temp1 = false ;
4336 bool temp2 = false ;
4337 PyObject * obj0 = 0 ;
4338 PyObject * obj1 = 0 ;
4339 char * kwnames[] = {
4340 (char *) "name",(char *) "value", NULL
4341 };
4342
4343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4344 {
4345 arg1 = wxString_in_helper(obj0);
4346 if (arg1 == NULL) SWIG_fail;
4347 temp1 = true;
4348 }
4349 {
4350 arg2 = wxString_in_helper(obj1);
4351 if (arg2 == NULL) SWIG_fail;
4352 temp2 = true;
4353 }
4354 {
4355 PyThreadState* __tstate = wxPyBeginAllowThreads();
4356 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4357 wxPyEndAllowThreads(__tstate);
4358 if (PyErr_Occurred()) SWIG_fail;
4359 }
4360 resultobj = SWIG_Py_Void();
4361 {
4362 if (temp1)
4363 delete arg1;
4364 }
4365 {
4366 if (temp2)
4367 delete arg2;
4368 }
4369 return resultobj;
4370 fail:
4371 {
4372 if (temp1)
4373 delete arg1;
4374 }
4375 {
4376 if (temp2)
4377 delete arg2;
4378 }
4379 return NULL;
4380 }
4381
4382
4383 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4384 PyObject *resultobj = 0;
4385 wxString *arg1 = 0 ;
4386 int arg2 ;
4387 bool temp1 = false ;
4388 int val2 ;
4389 int ecode2 = 0 ;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4392 char * kwnames[] = {
4393 (char *) "name",(char *) "value", NULL
4394 };
4395
4396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4397 {
4398 arg1 = wxString_in_helper(obj0);
4399 if (arg1 == NULL) SWIG_fail;
4400 temp1 = true;
4401 }
4402 ecode2 = SWIG_AsVal_int(obj1, &val2);
4403 if (!SWIG_IsOK(ecode2)) {
4404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4405 }
4406 arg2 = static_cast< int >(val2);
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4410 wxPyEndAllowThreads(__tstate);
4411 if (PyErr_Occurred()) SWIG_fail;
4412 }
4413 resultobj = SWIG_Py_Void();
4414 {
4415 if (temp1)
4416 delete arg1;
4417 }
4418 return resultobj;
4419 fail:
4420 {
4421 if (temp1)
4422 delete arg1;
4423 }
4424 return NULL;
4425 }
4426
4427
4428 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4429 PyObject *resultobj = 0;
4430 wxString *arg1 = 0 ;
4431 wxString result;
4432 bool temp1 = false ;
4433 PyObject * obj0 = 0 ;
4434 char * kwnames[] = {
4435 (char *) "name", NULL
4436 };
4437
4438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4439 {
4440 arg1 = wxString_in_helper(obj0);
4441 if (arg1 == NULL) SWIG_fail;
4442 temp1 = true;
4443 }
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4447 wxPyEndAllowThreads(__tstate);
4448 if (PyErr_Occurred()) SWIG_fail;
4449 }
4450 {
4451 #if wxUSE_UNICODE
4452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4453 #else
4454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4455 #endif
4456 }
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return resultobj;
4462 fail:
4463 {
4464 if (temp1)
4465 delete arg1;
4466 }
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj = 0;
4473 wxString *arg1 = 0 ;
4474 int result;
4475 bool temp1 = false ;
4476 PyObject * obj0 = 0 ;
4477 char * kwnames[] = {
4478 (char *) "name", NULL
4479 };
4480
4481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4482 {
4483 arg1 = wxString_in_helper(obj0);
4484 if (arg1 == NULL) SWIG_fail;
4485 temp1 = true;
4486 }
4487 {
4488 PyThreadState* __tstate = wxPyBeginAllowThreads();
4489 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 resultobj = SWIG_From_int(static_cast< int >(result));
4494 {
4495 if (temp1)
4496 delete arg1;
4497 }
4498 return resultobj;
4499 fail:
4500 {
4501 if (temp1)
4502 delete arg1;
4503 }
4504 return NULL;
4505 }
4506
4507
4508 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4509 PyObject *resultobj = 0;
4510 wxString *arg1 = 0 ;
4511 bool result;
4512 bool temp1 = false ;
4513 PyObject * obj0 = 0 ;
4514 char * kwnames[] = {
4515 (char *) "name", NULL
4516 };
4517
4518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4519 {
4520 arg1 = wxString_in_helper(obj0);
4521 if (arg1 == NULL) SWIG_fail;
4522 temp1 = true;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4527 wxPyEndAllowThreads(__tstate);
4528 if (PyErr_Occurred()) SWIG_fail;
4529 }
4530 {
4531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4532 }
4533 {
4534 if (temp1)
4535 delete arg1;
4536 }
4537 return resultobj;
4538 fail:
4539 {
4540 if (temp1)
4541 delete arg1;
4542 }
4543 return NULL;
4544 }
4545
4546
4547 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj = 0;
4549 wxString *arg1 = 0 ;
4550 bool result;
4551 bool temp1 = false ;
4552 PyObject * obj0 = 0 ;
4553 char * kwnames[] = {
4554 (char *) "name", NULL
4555 };
4556
4557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4558 {
4559 arg1 = wxString_in_helper(obj0);
4560 if (arg1 == NULL) SWIG_fail;
4561 temp1 = true;
4562 }
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 {
4570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4571 }
4572 {
4573 if (temp1)
4574 delete arg1;
4575 }
4576 return resultobj;
4577 fail:
4578 {
4579 if (temp1)
4580 delete arg1;
4581 }
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4587 PyObject *obj;
4588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4589 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4590 return SWIG_Py_Void();
4591 }
4592
4593 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4594 return SWIG_Python_InitShadowInstance(args);
4595 }
4596
4597 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4598 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4599 return 1;
4600 }
4601
4602
4603 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4604 PyObject *pyobj = 0;
4605
4606 {
4607 #if wxUSE_UNICODE
4608 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4609 #else
4610 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4611 #endif
4612 }
4613 return pyobj;
4614 }
4615
4616
4617 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4618 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4619 return 1;
4620 }
4621
4622
4623 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4624 PyObject *pyobj = 0;
4625
4626 {
4627 #if wxUSE_UNICODE
4628 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4629 #else
4630 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4631 #endif
4632 }
4633 return pyobj;
4634 }
4635
4636
4637 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4638 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4639 return 1;
4640 }
4641
4642
4643 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4644 PyObject *pyobj = 0;
4645
4646 {
4647 #if wxUSE_UNICODE
4648 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4649 #else
4650 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4651 #endif
4652 }
4653 return pyobj;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658 PyObject *resultobj = 0;
4659 long result;
4660
4661 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4662 {
4663 PyThreadState* __tstate = wxPyBeginAllowThreads();
4664 result = (long)wxNewId();
4665 wxPyEndAllowThreads(__tstate);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 resultobj = SWIG_From_long(static_cast< long >(result));
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 long arg1 ;
4678 long val1 ;
4679 int ecode1 = 0 ;
4680 PyObject * obj0 = 0 ;
4681 char * kwnames[] = {
4682 (char *) "id", NULL
4683 };
4684
4685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4686 ecode1 = SWIG_AsVal_long(obj0, &val1);
4687 if (!SWIG_IsOK(ecode1)) {
4688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4689 }
4690 arg1 = static_cast< long >(val1);
4691 {
4692 PyThreadState* __tstate = wxPyBeginAllowThreads();
4693 wxRegisterId(arg1);
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_Py_Void();
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4705 PyObject *resultobj = 0;
4706 long result;
4707
4708 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 result = (long)wxGetCurrentId();
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 resultobj = SWIG_From_long(static_cast< long >(result));
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj = 0;
4724 int arg1 ;
4725 bool result;
4726 int val1 ;
4727 int ecode1 = 0 ;
4728 PyObject * obj0 = 0 ;
4729 char * kwnames[] = {
4730 (char *) "id", NULL
4731 };
4732
4733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4734 ecode1 = SWIG_AsVal_int(obj0, &val1);
4735 if (!SWIG_IsOK(ecode1)) {
4736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4737 }
4738 arg1 = static_cast< int >(val1);
4739 {
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 result = (bool)wxIsStockID(arg1);
4742 wxPyEndAllowThreads(__tstate);
4743 if (PyErr_Occurred()) SWIG_fail;
4744 }
4745 {
4746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4747 }
4748 return resultobj;
4749 fail:
4750 return NULL;
4751 }
4752
4753
4754 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4755 PyObject *resultobj = 0;
4756 int arg1 ;
4757 wxString *arg2 = 0 ;
4758 bool result;
4759 int val1 ;
4760 int ecode1 = 0 ;
4761 bool temp2 = false ;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 char * kwnames[] = {
4765 (char *) "id",(char *) "label", NULL
4766 };
4767
4768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4769 ecode1 = SWIG_AsVal_int(obj0, &val1);
4770 if (!SWIG_IsOK(ecode1)) {
4771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4772 }
4773 arg1 = static_cast< int >(val1);
4774 {
4775 arg2 = wxString_in_helper(obj1);
4776 if (arg2 == NULL) SWIG_fail;
4777 temp2 = true;
4778 }
4779 {
4780 PyThreadState* __tstate = wxPyBeginAllowThreads();
4781 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4782 wxPyEndAllowThreads(__tstate);
4783 if (PyErr_Occurred()) SWIG_fail;
4784 }
4785 {
4786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4787 }
4788 {
4789 if (temp2)
4790 delete arg2;
4791 }
4792 return resultobj;
4793 fail:
4794 {
4795 if (temp2)
4796 delete arg2;
4797 }
4798 return NULL;
4799 }
4800
4801
4802 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4803 PyObject *resultobj = 0;
4804 int arg1 ;
4805 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4806 wxString result;
4807 int val1 ;
4808 int ecode1 = 0 ;
4809 long val2 ;
4810 int ecode2 = 0 ;
4811 PyObject * obj0 = 0 ;
4812 PyObject * obj1 = 0 ;
4813 char * kwnames[] = {
4814 (char *) "id",(char *) "flags", NULL
4815 };
4816
4817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4818 ecode1 = SWIG_AsVal_int(obj0, &val1);
4819 if (!SWIG_IsOK(ecode1)) {
4820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4821 }
4822 arg1 = static_cast< int >(val1);
4823 if (obj1) {
4824 ecode2 = SWIG_AsVal_long(obj1, &val2);
4825 if (!SWIG_IsOK(ecode2)) {
4826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4827 }
4828 arg2 = static_cast< long >(val2);
4829 }
4830 {
4831 PyThreadState* __tstate = wxPyBeginAllowThreads();
4832 result = wxGetStockLabel(arg1,arg2);
4833 wxPyEndAllowThreads(__tstate);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 {
4837 #if wxUSE_UNICODE
4838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4839 #else
4840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4841 #endif
4842 }
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 int arg1 ;
4852 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4853 wxString result;
4854 int val1 ;
4855 int ecode1 = 0 ;
4856 int val2 ;
4857 int ecode2 = 0 ;
4858 PyObject * obj0 = 0 ;
4859 PyObject * obj1 = 0 ;
4860 char * kwnames[] = {
4861 (char *) "id",(char *) "client", NULL
4862 };
4863
4864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4865 ecode1 = SWIG_AsVal_int(obj0, &val1);
4866 if (!SWIG_IsOK(ecode1)) {
4867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4868 }
4869 arg1 = static_cast< int >(val1);
4870 if (obj1) {
4871 ecode2 = SWIG_AsVal_int(obj1, &val2);
4872 if (!SWIG_IsOK(ecode2)) {
4873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4874 }
4875 arg2 = static_cast< wxStockHelpStringClient >(val2);
4876 }
4877 {
4878 PyThreadState* __tstate = wxPyBeginAllowThreads();
4879 result = wxGetStockHelpString(arg1,arg2);
4880 wxPyEndAllowThreads(__tstate);
4881 if (PyErr_Occurred()) SWIG_fail;
4882 }
4883 {
4884 #if wxUSE_UNICODE
4885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4886 #else
4887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4888 #endif
4889 }
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4897 PyObject *resultobj = 0;
4898
4899 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4900 {
4901 if (!wxPyCheckForApp()) SWIG_fail;
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 wxBell();
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 resultobj = SWIG_Py_Void();
4908 return resultobj;
4909 fail:
4910 return NULL;
4911 }
4912
4913
4914 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4915 PyObject *resultobj = 0;
4916
4917 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4918 {
4919 if (!wxPyCheckForApp()) SWIG_fail;
4920 PyThreadState* __tstate = wxPyBeginAllowThreads();
4921 wxEndBusyCursor();
4922 wxPyEndAllowThreads(__tstate);
4923 if (PyErr_Occurred()) SWIG_fail;
4924 }
4925 resultobj = SWIG_Py_Void();
4926 return resultobj;
4927 fail:
4928 return NULL;
4929 }
4930
4931
4932 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4933 PyObject *resultobj = 0;
4934 bool arg1 = (bool) true ;
4935 long result;
4936 bool val1 ;
4937 int ecode1 = 0 ;
4938 PyObject * obj0 = 0 ;
4939 char * kwnames[] = {
4940 (char *) "resetTimer", NULL
4941 };
4942
4943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4944 if (obj0) {
4945 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4946 if (!SWIG_IsOK(ecode1)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4948 }
4949 arg1 = static_cast< bool >(val1);
4950 }
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 result = (long)wxGetElapsedTime(arg1);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_From_long(static_cast< long >(result));
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4965 PyObject *resultobj = 0;
4966 bool result;
4967
4968 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4969 {
4970 PyThreadState* __tstate = wxPyBeginAllowThreads();
4971 result = (bool)wxIsBusy();
4972 wxPyEndAllowThreads(__tstate);
4973 if (PyErr_Occurred()) SWIG_fail;
4974 }
4975 {
4976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4977 }
4978 return resultobj;
4979 fail:
4980 return NULL;
4981 }
4982
4983
4984 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4985 PyObject *resultobj = 0;
4986 wxString result;
4987
4988 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 result = wxNow();
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 {
4996 #if wxUSE_UNICODE
4997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4998 #else
4999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5000 #endif
5001 }
5002 return resultobj;
5003 fail:
5004 return NULL;
5005 }
5006
5007
5008 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5009 PyObject *resultobj = 0;
5010 wxString const &arg1_defvalue = wxPyEmptyString ;
5011 wxString *arg1 = (wxString *) &arg1_defvalue ;
5012 bool result;
5013 bool temp1 = false ;
5014 PyObject * obj0 = 0 ;
5015 char * kwnames[] = {
5016 (char *) "command", NULL
5017 };
5018
5019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5020 if (obj0) {
5021 {
5022 arg1 = wxString_in_helper(obj0);
5023 if (arg1 == NULL) SWIG_fail;
5024 temp1 = true;
5025 }
5026 }
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 result = (bool)wxShell((wxString const &)*arg1);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 {
5034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5035 }
5036 {
5037 if (temp1)
5038 delete arg1;
5039 }
5040 return resultobj;
5041 fail:
5042 {
5043 if (temp1)
5044 delete arg1;
5045 }
5046 return NULL;
5047 }
5048
5049
5050 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5051 PyObject *resultobj = 0;
5052
5053 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5054 {
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 wxStartTimer();
5057 wxPyEndAllowThreads(__tstate);
5058 if (PyErr_Occurred()) SWIG_fail;
5059 }
5060 resultobj = SWIG_Py_Void();
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068 PyObject *resultobj = 0;
5069 int *arg1 = (int *) 0 ;
5070 int *arg2 = (int *) 0 ;
5071 int result;
5072 int temp1 ;
5073 int res1 = SWIG_TMPOBJ ;
5074 int temp2 ;
5075 int res2 = SWIG_TMPOBJ ;
5076
5077 arg1 = &temp1;
5078 arg2 = &temp2;
5079 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5080 {
5081 PyThreadState* __tstate = wxPyBeginAllowThreads();
5082 result = (int)wxGetOsVersion(arg1,arg2);
5083 wxPyEndAllowThreads(__tstate);
5084 if (PyErr_Occurred()) SWIG_fail;
5085 }
5086 resultobj = SWIG_From_int(static_cast< int >(result));
5087 if (SWIG_IsTmpObj(res1)) {
5088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5089 } else {
5090 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5092 }
5093 if (SWIG_IsTmpObj(res2)) {
5094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5095 } else {
5096 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5098 }
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5106 PyObject *resultobj = 0;
5107 wxString result;
5108
5109 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = wxGetOsDescription();
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 #if wxUSE_UNICODE
5118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5119 #else
5120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5121 #endif
5122 }
5123 return resultobj;
5124 fail:
5125 return NULL;
5126 }
5127
5128
5129 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5130 PyObject *resultobj = 0;
5131 bool result;
5132
5133 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5134 {
5135 PyThreadState* __tstate = wxPyBeginAllowThreads();
5136 result = (bool)wxIsPlatformLittleEndian();
5137 wxPyEndAllowThreads(__tstate);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 {
5141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5142 }
5143 return resultobj;
5144 fail:
5145 return NULL;
5146 }
5147
5148
5149 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5150 PyObject *resultobj = 0;
5151 bool result;
5152
5153 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5154 {
5155 PyThreadState* __tstate = wxPyBeginAllowThreads();
5156 result = (bool)wxIsPlatform64Bit();
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 {
5161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5162 }
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5170 PyObject *resultobj = 0;
5171 wxMemorySize result;
5172
5173 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5174 {
5175 PyThreadState* __tstate = wxPyBeginAllowThreads();
5176 result = wxGetFreeMemory();
5177 wxPyEndAllowThreads(__tstate);
5178 if (PyErr_Occurred()) SWIG_fail;
5179 }
5180 {
5181 #if wxUSE_LONGLONG
5182 resultobj = PyLong_FromLongLong((&result)->GetValue());
5183 #else
5184 resultobj = PyInt_FromLong(result);
5185 #endif
5186 }
5187 return resultobj;
5188 fail:
5189 return NULL;
5190 }
5191
5192
5193 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5194 PyObject *resultobj = 0;
5195 wxShutdownFlags arg1 ;
5196 bool result;
5197 int val1 ;
5198 int ecode1 = 0 ;
5199 PyObject * obj0 = 0 ;
5200 char * kwnames[] = {
5201 (char *) "wFlags", NULL
5202 };
5203
5204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5205 ecode1 = SWIG_AsVal_int(obj0, &val1);
5206 if (!SWIG_IsOK(ecode1)) {
5207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5208 }
5209 arg1 = static_cast< wxShutdownFlags >(val1);
5210 {
5211 if (!wxPyCheckForApp()) SWIG_fail;
5212 PyThreadState* __tstate = wxPyBeginAllowThreads();
5213 result = (bool)wxShutdown(arg1);
5214 wxPyEndAllowThreads(__tstate);
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 {
5218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5219 }
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj = 0;
5228 int arg1 ;
5229 int val1 ;
5230 int ecode1 = 0 ;
5231 PyObject * obj0 = 0 ;
5232 char * kwnames[] = {
5233 (char *) "secs", NULL
5234 };
5235
5236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5237 ecode1 = SWIG_AsVal_int(obj0, &val1);
5238 if (!SWIG_IsOK(ecode1)) {
5239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5240 }
5241 arg1 = static_cast< int >(val1);
5242 {
5243 PyThreadState* __tstate = wxPyBeginAllowThreads();
5244 wxSleep(arg1);
5245 wxPyEndAllowThreads(__tstate);
5246 if (PyErr_Occurred()) SWIG_fail;
5247 }
5248 resultobj = SWIG_Py_Void();
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5256 PyObject *resultobj = 0;
5257 unsigned long arg1 ;
5258 unsigned long val1 ;
5259 int ecode1 = 0 ;
5260 PyObject * obj0 = 0 ;
5261 char * kwnames[] = {
5262 (char *) "milliseconds", NULL
5263 };
5264
5265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5266 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5267 if (!SWIG_IsOK(ecode1)) {
5268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5269 }
5270 arg1 = static_cast< unsigned long >(val1);
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 wxMilliSleep(arg1);
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5285 PyObject *resultobj = 0;
5286 unsigned long arg1 ;
5287 unsigned long val1 ;
5288 int ecode1 = 0 ;
5289 PyObject * obj0 = 0 ;
5290 char * kwnames[] = {
5291 (char *) "microseconds", NULL
5292 };
5293
5294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5295 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5296 if (!SWIG_IsOK(ecode1)) {
5297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5298 }
5299 arg1 = static_cast< unsigned long >(val1);
5300 {
5301 PyThreadState* __tstate = wxPyBeginAllowThreads();
5302 wxMicroSleep(arg1);
5303 wxPyEndAllowThreads(__tstate);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 resultobj = SWIG_Py_Void();
5307 return resultobj;
5308 fail:
5309 return NULL;
5310 }
5311
5312
5313 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5314 PyObject *resultobj = 0;
5315 bool arg1 ;
5316 bool val1 ;
5317 int ecode1 = 0 ;
5318 PyObject * obj0 = 0 ;
5319 char * kwnames[] = {
5320 (char *) "enable", NULL
5321 };
5322
5323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5324 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5327 }
5328 arg1 = static_cast< bool >(val1);
5329 {
5330 PyThreadState* __tstate = wxPyBeginAllowThreads();
5331 wxEnableTopLevelWindows(arg1);
5332 wxPyEndAllowThreads(__tstate);
5333 if (PyErr_Occurred()) SWIG_fail;
5334 }
5335 resultobj = SWIG_Py_Void();
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj = 0;
5344 wxString *arg1 = 0 ;
5345 wxString result;
5346 bool temp1 = false ;
5347 PyObject * obj0 = 0 ;
5348 char * kwnames[] = {
5349 (char *) "in", NULL
5350 };
5351
5352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5353 {
5354 arg1 = wxString_in_helper(obj0);
5355 if (arg1 == NULL) SWIG_fail;
5356 temp1 = true;
5357 }
5358 {
5359 PyThreadState* __tstate = wxPyBeginAllowThreads();
5360 result = wxStripMenuCodes((wxString const &)*arg1);
5361 wxPyEndAllowThreads(__tstate);
5362 if (PyErr_Occurred()) SWIG_fail;
5363 }
5364 {
5365 #if wxUSE_UNICODE
5366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5367 #else
5368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5369 #endif
5370 }
5371 {
5372 if (temp1)
5373 delete arg1;
5374 }
5375 return resultobj;
5376 fail:
5377 {
5378 if (temp1)
5379 delete arg1;
5380 }
5381 return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5386 PyObject *resultobj = 0;
5387 wxString result;
5388
5389 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 result = wxGetEmailAddress();
5393 wxPyEndAllowThreads(__tstate);
5394 if (PyErr_Occurred()) SWIG_fail;
5395 }
5396 {
5397 #if wxUSE_UNICODE
5398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5399 #else
5400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5401 #endif
5402 }
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5410 PyObject *resultobj = 0;
5411 wxString result;
5412
5413 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5414 {
5415 PyThreadState* __tstate = wxPyBeginAllowThreads();
5416 result = wxGetHostName();
5417 wxPyEndAllowThreads(__tstate);
5418 if (PyErr_Occurred()) SWIG_fail;
5419 }
5420 {
5421 #if wxUSE_UNICODE
5422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5423 #else
5424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5425 #endif
5426 }
5427 return resultobj;
5428 fail:
5429 return NULL;
5430 }
5431
5432
5433 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5434 PyObject *resultobj = 0;
5435 wxString result;
5436
5437 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5438 {
5439 PyThreadState* __tstate = wxPyBeginAllowThreads();
5440 result = wxGetFullHostName();
5441 wxPyEndAllowThreads(__tstate);
5442 if (PyErr_Occurred()) SWIG_fail;
5443 }
5444 {
5445 #if wxUSE_UNICODE
5446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5447 #else
5448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5449 #endif
5450 }
5451 return resultobj;
5452 fail:
5453 return NULL;
5454 }
5455
5456
5457 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5458 PyObject *resultobj = 0;
5459 wxString result;
5460
5461 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = wxGetUserId();
5465 wxPyEndAllowThreads(__tstate);
5466 if (PyErr_Occurred()) SWIG_fail;
5467 }
5468 {
5469 #if wxUSE_UNICODE
5470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5471 #else
5472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5473 #endif
5474 }
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5482 PyObject *resultobj = 0;
5483 wxString result;
5484
5485 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5486 {
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = wxGetUserName();
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 {
5493 #if wxUSE_UNICODE
5494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5495 #else
5496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5497 #endif
5498 }
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5506 PyObject *resultobj = 0;
5507 wxString result;
5508
5509 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5510 {
5511 PyThreadState* __tstate = wxPyBeginAllowThreads();
5512 result = wxGetHomeDir();
5513 wxPyEndAllowThreads(__tstate);
5514 if (PyErr_Occurred()) SWIG_fail;
5515 }
5516 {
5517 #if wxUSE_UNICODE
5518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5519 #else
5520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5521 #endif
5522 }
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj = 0;
5531 wxString const &arg1_defvalue = wxPyEmptyString ;
5532 wxString *arg1 = (wxString *) &arg1_defvalue ;
5533 wxString result;
5534 bool temp1 = false ;
5535 PyObject * obj0 = 0 ;
5536 char * kwnames[] = {
5537 (char *) "user", NULL
5538 };
5539
5540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5541 if (obj0) {
5542 {
5543 arg1 = wxString_in_helper(obj0);
5544 if (arg1 == NULL) SWIG_fail;
5545 temp1 = true;
5546 }
5547 }
5548 {
5549 PyThreadState* __tstate = wxPyBeginAllowThreads();
5550 result = wxGetUserHome((wxString const &)*arg1);
5551 wxPyEndAllowThreads(__tstate);
5552 if (PyErr_Occurred()) SWIG_fail;
5553 }
5554 {
5555 #if wxUSE_UNICODE
5556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5557 #else
5558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5559 #endif
5560 }
5561 {
5562 if (temp1)
5563 delete arg1;
5564 }
5565 return resultobj;
5566 fail:
5567 {
5568 if (temp1)
5569 delete arg1;
5570 }
5571 return NULL;
5572 }
5573
5574
5575 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5576 PyObject *resultobj = 0;
5577 unsigned long result;
5578
5579 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (unsigned long)wxGetProcessId();
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *resultobj = 0;
5595
5596 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5597 {
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 wxTrap();
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 resultobj = SWIG_Py_Void();
5604 return resultobj;
5605 fail:
5606 return NULL;
5607 }
5608
5609
5610 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5611 PyObject *resultobj = 0;
5612 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5613 wxString *arg1 = (wxString *) &arg1_defvalue ;
5614 wxString const &arg2_defvalue = wxPyEmptyString ;
5615 wxString *arg2 = (wxString *) &arg2_defvalue ;
5616 wxString const &arg3_defvalue = wxPyEmptyString ;
5617 wxString *arg3 = (wxString *) &arg3_defvalue ;
5618 wxString const &arg4_defvalue = wxPyEmptyString ;
5619 wxString *arg4 = (wxString *) &arg4_defvalue ;
5620 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5621 wxString *arg5 = (wxString *) &arg5_defvalue ;
5622 int arg6 = (int) 0 ;
5623 wxWindow *arg7 = (wxWindow *) NULL ;
5624 int arg8 = (int) -1 ;
5625 int arg9 = (int) -1 ;
5626 wxString result;
5627 bool temp1 = false ;
5628 bool temp2 = false ;
5629 bool temp3 = false ;
5630 bool temp4 = false ;
5631 bool temp5 = false ;
5632 int val6 ;
5633 int ecode6 = 0 ;
5634 void *argp7 = 0 ;
5635 int res7 = 0 ;
5636 int val8 ;
5637 int ecode8 = 0 ;
5638 int val9 ;
5639 int ecode9 = 0 ;
5640 PyObject * obj0 = 0 ;
5641 PyObject * obj1 = 0 ;
5642 PyObject * obj2 = 0 ;
5643 PyObject * obj3 = 0 ;
5644 PyObject * obj4 = 0 ;
5645 PyObject * obj5 = 0 ;
5646 PyObject * obj6 = 0 ;
5647 PyObject * obj7 = 0 ;
5648 PyObject * obj8 = 0 ;
5649 char * kwnames[] = {
5650 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5651 };
5652
5653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5654 if (obj0) {
5655 {
5656 arg1 = wxString_in_helper(obj0);
5657 if (arg1 == NULL) SWIG_fail;
5658 temp1 = true;
5659 }
5660 }
5661 if (obj1) {
5662 {
5663 arg2 = wxString_in_helper(obj1);
5664 if (arg2 == NULL) SWIG_fail;
5665 temp2 = true;
5666 }
5667 }
5668 if (obj2) {
5669 {
5670 arg3 = wxString_in_helper(obj2);
5671 if (arg3 == NULL) SWIG_fail;
5672 temp3 = true;
5673 }
5674 }
5675 if (obj3) {
5676 {
5677 arg4 = wxString_in_helper(obj3);
5678 if (arg4 == NULL) SWIG_fail;
5679 temp4 = true;
5680 }
5681 }
5682 if (obj4) {
5683 {
5684 arg5 = wxString_in_helper(obj4);
5685 if (arg5 == NULL) SWIG_fail;
5686 temp5 = true;
5687 }
5688 }
5689 if (obj5) {
5690 ecode6 = SWIG_AsVal_int(obj5, &val6);
5691 if (!SWIG_IsOK(ecode6)) {
5692 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5693 }
5694 arg6 = static_cast< int >(val6);
5695 }
5696 if (obj6) {
5697 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5698 if (!SWIG_IsOK(res7)) {
5699 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5700 }
5701 arg7 = reinterpret_cast< wxWindow * >(argp7);
5702 }
5703 if (obj7) {
5704 ecode8 = SWIG_AsVal_int(obj7, &val8);
5705 if (!SWIG_IsOK(ecode8)) {
5706 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5707 }
5708 arg8 = static_cast< int >(val8);
5709 }
5710 if (obj8) {
5711 ecode9 = SWIG_AsVal_int(obj8, &val9);
5712 if (!SWIG_IsOK(ecode9)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5714 }
5715 arg9 = static_cast< int >(val9);
5716 }
5717 {
5718 if (!wxPyCheckForApp()) SWIG_fail;
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5721 wxPyEndAllowThreads(__tstate);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 {
5725 #if wxUSE_UNICODE
5726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5727 #else
5728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5729 #endif
5730 }
5731 {
5732 if (temp1)
5733 delete arg1;
5734 }
5735 {
5736 if (temp2)
5737 delete arg2;
5738 }
5739 {
5740 if (temp3)
5741 delete arg3;
5742 }
5743 {
5744 if (temp4)
5745 delete arg4;
5746 }
5747 {
5748 if (temp5)
5749 delete arg5;
5750 }
5751 return resultobj;
5752 fail:
5753 {
5754 if (temp1)
5755 delete arg1;
5756 }
5757 {
5758 if (temp2)
5759 delete arg2;
5760 }
5761 {
5762 if (temp3)
5763 delete arg3;
5764 }
5765 {
5766 if (temp4)
5767 delete arg4;
5768 }
5769 {
5770 if (temp5)
5771 delete arg5;
5772 }
5773 return NULL;
5774 }
5775
5776
5777 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj = 0;
5779 wxString *arg1 = 0 ;
5780 wxString *arg2 = 0 ;
5781 wxString const &arg3_defvalue = wxPyEmptyString ;
5782 wxString *arg3 = (wxString *) &arg3_defvalue ;
5783 wxWindow *arg4 = (wxWindow *) NULL ;
5784 wxString result;
5785 bool temp1 = false ;
5786 bool temp2 = false ;
5787 bool temp3 = false ;
5788 void *argp4 = 0 ;
5789 int res4 = 0 ;
5790 PyObject * obj0 = 0 ;
5791 PyObject * obj1 = 0 ;
5792 PyObject * obj2 = 0 ;
5793 PyObject * obj3 = 0 ;
5794 char * kwnames[] = {
5795 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5796 };
5797
5798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5799 {
5800 arg1 = wxString_in_helper(obj0);
5801 if (arg1 == NULL) SWIG_fail;
5802 temp1 = true;
5803 }
5804 {
5805 arg2 = wxString_in_helper(obj1);
5806 if (arg2 == NULL) SWIG_fail;
5807 temp2 = true;
5808 }
5809 if (obj2) {
5810 {
5811 arg3 = wxString_in_helper(obj2);
5812 if (arg3 == NULL) SWIG_fail;
5813 temp3 = true;
5814 }
5815 }
5816 if (obj3) {
5817 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5818 if (!SWIG_IsOK(res4)) {
5819 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5820 }
5821 arg4 = reinterpret_cast< wxWindow * >(argp4);
5822 }
5823 {
5824 if (!wxPyCheckForApp()) SWIG_fail;
5825 PyThreadState* __tstate = wxPyBeginAllowThreads();
5826 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5827 wxPyEndAllowThreads(__tstate);
5828 if (PyErr_Occurred()) SWIG_fail;
5829 }
5830 {
5831 #if wxUSE_UNICODE
5832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5833 #else
5834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5835 #endif
5836 }
5837 {
5838 if (temp1)
5839 delete arg1;
5840 }
5841 {
5842 if (temp2)
5843 delete arg2;
5844 }
5845 {
5846 if (temp3)
5847 delete arg3;
5848 }
5849 return resultobj;
5850 fail:
5851 {
5852 if (temp1)
5853 delete arg1;
5854 }
5855 {
5856 if (temp2)
5857 delete arg2;
5858 }
5859 {
5860 if (temp3)
5861 delete arg3;
5862 }
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5868 PyObject *resultobj = 0;
5869 wxString *arg1 = 0 ;
5870 wxString *arg2 = 0 ;
5871 wxString const &arg3_defvalue = wxPyEmptyString ;
5872 wxString *arg3 = (wxString *) &arg3_defvalue ;
5873 wxWindow *arg4 = (wxWindow *) NULL ;
5874 wxString result;
5875 bool temp1 = false ;
5876 bool temp2 = false ;
5877 bool temp3 = false ;
5878 void *argp4 = 0 ;
5879 int res4 = 0 ;
5880 PyObject * obj0 = 0 ;
5881 PyObject * obj1 = 0 ;
5882 PyObject * obj2 = 0 ;
5883 PyObject * obj3 = 0 ;
5884 char * kwnames[] = {
5885 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5886 };
5887
5888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5889 {
5890 arg1 = wxString_in_helper(obj0);
5891 if (arg1 == NULL) SWIG_fail;
5892 temp1 = true;
5893 }
5894 {
5895 arg2 = wxString_in_helper(obj1);
5896 if (arg2 == NULL) SWIG_fail;
5897 temp2 = true;
5898 }
5899 if (obj2) {
5900 {
5901 arg3 = wxString_in_helper(obj2);
5902 if (arg3 == NULL) SWIG_fail;
5903 temp3 = true;
5904 }
5905 }
5906 if (obj3) {
5907 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5908 if (!SWIG_IsOK(res4)) {
5909 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5910 }
5911 arg4 = reinterpret_cast< wxWindow * >(argp4);
5912 }
5913 {
5914 if (!wxPyCheckForApp()) SWIG_fail;
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 {
5921 #if wxUSE_UNICODE
5922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5923 #else
5924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5925 #endif
5926 }
5927 {
5928 if (temp1)
5929 delete arg1;
5930 }
5931 {
5932 if (temp2)
5933 delete arg2;
5934 }
5935 {
5936 if (temp3)
5937 delete arg3;
5938 }
5939 return resultobj;
5940 fail:
5941 {
5942 if (temp1)
5943 delete arg1;
5944 }
5945 {
5946 if (temp2)
5947 delete arg2;
5948 }
5949 {
5950 if (temp3)
5951 delete arg3;
5952 }
5953 return NULL;
5954 }
5955
5956
5957 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5958 PyObject *resultobj = 0;
5959 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5960 wxString *arg1 = (wxString *) &arg1_defvalue ;
5961 wxString const &arg2_defvalue = wxPyEmptyString ;
5962 wxString *arg2 = (wxString *) &arg2_defvalue ;
5963 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5964 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5965 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5966 wxWindow *arg5 = (wxWindow *) NULL ;
5967 wxString result;
5968 bool temp1 = false ;
5969 bool temp2 = false ;
5970 long val3 ;
5971 int ecode3 = 0 ;
5972 wxPoint temp4 ;
5973 void *argp5 = 0 ;
5974 int res5 = 0 ;
5975 PyObject * obj0 = 0 ;
5976 PyObject * obj1 = 0 ;
5977 PyObject * obj2 = 0 ;
5978 PyObject * obj3 = 0 ;
5979 PyObject * obj4 = 0 ;
5980 char * kwnames[] = {
5981 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5982 };
5983
5984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5985 if (obj0) {
5986 {
5987 arg1 = wxString_in_helper(obj0);
5988 if (arg1 == NULL) SWIG_fail;
5989 temp1 = true;
5990 }
5991 }
5992 if (obj1) {
5993 {
5994 arg2 = wxString_in_helper(obj1);
5995 if (arg2 == NULL) SWIG_fail;
5996 temp2 = true;
5997 }
5998 }
5999 if (obj2) {
6000 ecode3 = SWIG_AsVal_long(obj2, &val3);
6001 if (!SWIG_IsOK(ecode3)) {
6002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6003 }
6004 arg3 = static_cast< long >(val3);
6005 }
6006 if (obj3) {
6007 {
6008 arg4 = &temp4;
6009 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6010 }
6011 }
6012 if (obj4) {
6013 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6014 if (!SWIG_IsOK(res5)) {
6015 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6016 }
6017 arg5 = reinterpret_cast< wxWindow * >(argp5);
6018 }
6019 {
6020 if (!wxPyCheckForApp()) SWIG_fail;
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 {
6027 #if wxUSE_UNICODE
6028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6029 #else
6030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6031 #endif
6032 }
6033 {
6034 if (temp1)
6035 delete arg1;
6036 }
6037 {
6038 if (temp2)
6039 delete arg2;
6040 }
6041 return resultobj;
6042 fail:
6043 {
6044 if (temp1)
6045 delete arg1;
6046 }
6047 {
6048 if (temp2)
6049 delete arg2;
6050 }
6051 return NULL;
6052 }
6053
6054
6055 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6056 PyObject *resultobj = 0;
6057 wxString *arg1 = 0 ;
6058 wxString const &arg2_defvalue = wxPyEmptyString ;
6059 wxString *arg2 = (wxString *) &arg2_defvalue ;
6060 wxString const &arg3_defvalue = wxPyEmptyString ;
6061 wxString *arg3 = (wxString *) &arg3_defvalue ;
6062 wxWindow *arg4 = (wxWindow *) NULL ;
6063 int arg5 = (int) -1 ;
6064 int arg6 = (int) -1 ;
6065 bool arg7 = (bool) true ;
6066 wxString result;
6067 bool temp1 = false ;
6068 bool temp2 = false ;
6069 bool temp3 = false ;
6070 void *argp4 = 0 ;
6071 int res4 = 0 ;
6072 int val5 ;
6073 int ecode5 = 0 ;
6074 int val6 ;
6075 int ecode6 = 0 ;
6076 bool val7 ;
6077 int ecode7 = 0 ;
6078 PyObject * obj0 = 0 ;
6079 PyObject * obj1 = 0 ;
6080 PyObject * obj2 = 0 ;
6081 PyObject * obj3 = 0 ;
6082 PyObject * obj4 = 0 ;
6083 PyObject * obj5 = 0 ;
6084 PyObject * obj6 = 0 ;
6085 char * kwnames[] = {
6086 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6087 };
6088
6089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6090 {
6091 arg1 = wxString_in_helper(obj0);
6092 if (arg1 == NULL) SWIG_fail;
6093 temp1 = true;
6094 }
6095 if (obj1) {
6096 {
6097 arg2 = wxString_in_helper(obj1);
6098 if (arg2 == NULL) SWIG_fail;
6099 temp2 = true;
6100 }
6101 }
6102 if (obj2) {
6103 {
6104 arg3 = wxString_in_helper(obj2);
6105 if (arg3 == NULL) SWIG_fail;
6106 temp3 = true;
6107 }
6108 }
6109 if (obj3) {
6110 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6111 if (!SWIG_IsOK(res4)) {
6112 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6113 }
6114 arg4 = reinterpret_cast< wxWindow * >(argp4);
6115 }
6116 if (obj4) {
6117 ecode5 = SWIG_AsVal_int(obj4, &val5);
6118 if (!SWIG_IsOK(ecode5)) {
6119 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6120 }
6121 arg5 = static_cast< int >(val5);
6122 }
6123 if (obj5) {
6124 ecode6 = SWIG_AsVal_int(obj5, &val6);
6125 if (!SWIG_IsOK(ecode6)) {
6126 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6127 }
6128 arg6 = static_cast< int >(val6);
6129 }
6130 if (obj6) {
6131 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6132 if (!SWIG_IsOK(ecode7)) {
6133 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6134 }
6135 arg7 = static_cast< bool >(val7);
6136 }
6137 {
6138 if (!wxPyCheckForApp()) SWIG_fail;
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 {
6145 #if wxUSE_UNICODE
6146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6147 #else
6148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6149 #endif
6150 }
6151 {
6152 if (temp1)
6153 delete arg1;
6154 }
6155 {
6156 if (temp2)
6157 delete arg2;
6158 }
6159 {
6160 if (temp3)
6161 delete arg3;
6162 }
6163 return resultobj;
6164 fail:
6165 {
6166 if (temp1)
6167 delete arg1;
6168 }
6169 {
6170 if (temp2)
6171 delete arg2;
6172 }
6173 {
6174 if (temp3)
6175 delete arg3;
6176 }
6177 return NULL;
6178 }
6179
6180
6181 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj = 0;
6183 wxString *arg1 = 0 ;
6184 wxString const &arg2_defvalue = wxPyEmptyString ;
6185 wxString *arg2 = (wxString *) &arg2_defvalue ;
6186 wxString const &arg3_defvalue = wxPyEmptyString ;
6187 wxString *arg3 = (wxString *) &arg3_defvalue ;
6188 wxWindow *arg4 = (wxWindow *) NULL ;
6189 wxString result;
6190 bool temp1 = false ;
6191 bool temp2 = false ;
6192 bool temp3 = false ;
6193 void *argp4 = 0 ;
6194 int res4 = 0 ;
6195 PyObject * obj0 = 0 ;
6196 PyObject * obj1 = 0 ;
6197 PyObject * obj2 = 0 ;
6198 PyObject * obj3 = 0 ;
6199 char * kwnames[] = {
6200 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6201 };
6202
6203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6204 {
6205 arg1 = wxString_in_helper(obj0);
6206 if (arg1 == NULL) SWIG_fail;
6207 temp1 = true;
6208 }
6209 if (obj1) {
6210 {
6211 arg2 = wxString_in_helper(obj1);
6212 if (arg2 == NULL) SWIG_fail;
6213 temp2 = true;
6214 }
6215 }
6216 if (obj2) {
6217 {
6218 arg3 = wxString_in_helper(obj2);
6219 if (arg3 == NULL) SWIG_fail;
6220 temp3 = true;
6221 }
6222 }
6223 if (obj3) {
6224 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6225 if (!SWIG_IsOK(res4)) {
6226 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6227 }
6228 arg4 = reinterpret_cast< wxWindow * >(argp4);
6229 }
6230 {
6231 if (!wxPyCheckForApp()) SWIG_fail;
6232 PyThreadState* __tstate = wxPyBeginAllowThreads();
6233 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6234 wxPyEndAllowThreads(__tstate);
6235 if (PyErr_Occurred()) SWIG_fail;
6236 }
6237 {
6238 #if wxUSE_UNICODE
6239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6240 #else
6241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6242 #endif
6243 }
6244 {
6245 if (temp1)
6246 delete arg1;
6247 }
6248 {
6249 if (temp2)
6250 delete arg2;
6251 }
6252 {
6253 if (temp3)
6254 delete arg3;
6255 }
6256 return resultobj;
6257 fail:
6258 {
6259 if (temp1)
6260 delete arg1;
6261 }
6262 {
6263 if (temp2)
6264 delete arg2;
6265 }
6266 {
6267 if (temp3)
6268 delete arg3;
6269 }
6270 return NULL;
6271 }
6272
6273
6274 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6275 PyObject *resultobj = 0;
6276 wxString *arg1 = 0 ;
6277 wxString *arg2 = 0 ;
6278 int arg3 ;
6279 wxString *arg4 = (wxString *) 0 ;
6280 wxWindow *arg5 = (wxWindow *) NULL ;
6281 int arg6 = (int) -1 ;
6282 int arg7 = (int) -1 ;
6283 bool arg8 = (bool) true ;
6284 int arg9 = (int) 150 ;
6285 int arg10 = (int) 200 ;
6286 wxString result;
6287 bool temp1 = false ;
6288 bool temp2 = false ;
6289 void *argp5 = 0 ;
6290 int res5 = 0 ;
6291 int val6 ;
6292 int ecode6 = 0 ;
6293 int val7 ;
6294 int ecode7 = 0 ;
6295 bool val8 ;
6296 int ecode8 = 0 ;
6297 int val9 ;
6298 int ecode9 = 0 ;
6299 int val10 ;
6300 int ecode10 = 0 ;
6301 PyObject * obj0 = 0 ;
6302 PyObject * obj1 = 0 ;
6303 PyObject * obj2 = 0 ;
6304 PyObject * obj3 = 0 ;
6305 PyObject * obj4 = 0 ;
6306 PyObject * obj5 = 0 ;
6307 PyObject * obj6 = 0 ;
6308 PyObject * obj7 = 0 ;
6309 PyObject * obj8 = 0 ;
6310 char * kwnames[] = {
6311 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6312 };
6313
6314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6315 {
6316 arg1 = wxString_in_helper(obj0);
6317 if (arg1 == NULL) SWIG_fail;
6318 temp1 = true;
6319 }
6320 {
6321 arg2 = wxString_in_helper(obj1);
6322 if (arg2 == NULL) SWIG_fail;
6323 temp2 = true;
6324 }
6325 {
6326 arg3 = PyList_Size(obj2);
6327 arg4 = wxString_LIST_helper(obj2);
6328 if (arg4 == NULL) SWIG_fail;
6329 }
6330 if (obj3) {
6331 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6332 if (!SWIG_IsOK(res5)) {
6333 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6334 }
6335 arg5 = reinterpret_cast< wxWindow * >(argp5);
6336 }
6337 if (obj4) {
6338 ecode6 = SWIG_AsVal_int(obj4, &val6);
6339 if (!SWIG_IsOK(ecode6)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6341 }
6342 arg6 = static_cast< int >(val6);
6343 }
6344 if (obj5) {
6345 ecode7 = SWIG_AsVal_int(obj5, &val7);
6346 if (!SWIG_IsOK(ecode7)) {
6347 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6348 }
6349 arg7 = static_cast< int >(val7);
6350 }
6351 if (obj6) {
6352 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6353 if (!SWIG_IsOK(ecode8)) {
6354 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6355 }
6356 arg8 = static_cast< bool >(val8);
6357 }
6358 if (obj7) {
6359 ecode9 = SWIG_AsVal_int(obj7, &val9);
6360 if (!SWIG_IsOK(ecode9)) {
6361 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6362 }
6363 arg9 = static_cast< int >(val9);
6364 }
6365 if (obj8) {
6366 ecode10 = SWIG_AsVal_int(obj8, &val10);
6367 if (!SWIG_IsOK(ecode10)) {
6368 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6369 }
6370 arg10 = static_cast< int >(val10);
6371 }
6372 {
6373 if (!wxPyCheckForApp()) SWIG_fail;
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6376 wxPyEndAllowThreads(__tstate);
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 {
6380 #if wxUSE_UNICODE
6381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6382 #else
6383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6384 #endif
6385 }
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 resultobj;
6398 fail:
6399 {
6400 if (temp1)
6401 delete arg1;
6402 }
6403 {
6404 if (temp2)
6405 delete arg2;
6406 }
6407 {
6408 if (arg4) delete [] arg4;
6409 }
6410 return NULL;
6411 }
6412
6413
6414 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj = 0;
6416 wxString *arg1 = 0 ;
6417 wxString *arg2 = 0 ;
6418 int arg3 ;
6419 wxString *arg4 = (wxString *) 0 ;
6420 wxWindow *arg5 = (wxWindow *) NULL ;
6421 int arg6 = (int) -1 ;
6422 int arg7 = (int) -1 ;
6423 bool arg8 = (bool) true ;
6424 int arg9 = (int) 150 ;
6425 int arg10 = (int) 200 ;
6426 int result;
6427 bool temp1 = false ;
6428 bool temp2 = false ;
6429 void *argp5 = 0 ;
6430 int res5 = 0 ;
6431 int val6 ;
6432 int ecode6 = 0 ;
6433 int val7 ;
6434 int ecode7 = 0 ;
6435 bool val8 ;
6436 int ecode8 = 0 ;
6437 int val9 ;
6438 int ecode9 = 0 ;
6439 int val10 ;
6440 int ecode10 = 0 ;
6441 PyObject * obj0 = 0 ;
6442 PyObject * obj1 = 0 ;
6443 PyObject * obj2 = 0 ;
6444 PyObject * obj3 = 0 ;
6445 PyObject * obj4 = 0 ;
6446 PyObject * obj5 = 0 ;
6447 PyObject * obj6 = 0 ;
6448 PyObject * obj7 = 0 ;
6449 PyObject * obj8 = 0 ;
6450 char * kwnames[] = {
6451 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6452 };
6453
6454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6455 {
6456 arg1 = wxString_in_helper(obj0);
6457 if (arg1 == NULL) SWIG_fail;
6458 temp1 = true;
6459 }
6460 {
6461 arg2 = wxString_in_helper(obj1);
6462 if (arg2 == NULL) SWIG_fail;
6463 temp2 = true;
6464 }
6465 {
6466 arg3 = PyList_Size(obj2);
6467 arg4 = wxString_LIST_helper(obj2);
6468 if (arg4 == NULL) SWIG_fail;
6469 }
6470 if (obj3) {
6471 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6472 if (!SWIG_IsOK(res5)) {
6473 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6474 }
6475 arg5 = reinterpret_cast< wxWindow * >(argp5);
6476 }
6477 if (obj4) {
6478 ecode6 = SWIG_AsVal_int(obj4, &val6);
6479 if (!SWIG_IsOK(ecode6)) {
6480 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6481 }
6482 arg6 = static_cast< int >(val6);
6483 }
6484 if (obj5) {
6485 ecode7 = SWIG_AsVal_int(obj5, &val7);
6486 if (!SWIG_IsOK(ecode7)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6488 }
6489 arg7 = static_cast< int >(val7);
6490 }
6491 if (obj6) {
6492 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6493 if (!SWIG_IsOK(ecode8)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6495 }
6496 arg8 = static_cast< bool >(val8);
6497 }
6498 if (obj7) {
6499 ecode9 = SWIG_AsVal_int(obj7, &val9);
6500 if (!SWIG_IsOK(ecode9)) {
6501 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6502 }
6503 arg9 = static_cast< int >(val9);
6504 }
6505 if (obj8) {
6506 ecode10 = SWIG_AsVal_int(obj8, &val10);
6507 if (!SWIG_IsOK(ecode10)) {
6508 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6509 }
6510 arg10 = static_cast< int >(val10);
6511 }
6512 {
6513 if (!wxPyCheckForApp()) SWIG_fail;
6514 PyThreadState* __tstate = wxPyBeginAllowThreads();
6515 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6516 wxPyEndAllowThreads(__tstate);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 resultobj = SWIG_From_int(static_cast< int >(result));
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 resultobj;
6532 fail:
6533 {
6534 if (temp1)
6535 delete arg1;
6536 }
6537 {
6538 if (temp2)
6539 delete arg2;
6540 }
6541 {
6542 if (arg4) delete [] arg4;
6543 }
6544 return NULL;
6545 }
6546
6547
6548 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj = 0;
6550 wxString *arg1 = 0 ;
6551 wxString const &arg2_defvalue = wxPyEmptyString ;
6552 wxString *arg2 = (wxString *) &arg2_defvalue ;
6553 int arg3 = (int) wxOK|wxCENTRE ;
6554 wxWindow *arg4 = (wxWindow *) NULL ;
6555 int arg5 = (int) -1 ;
6556 int arg6 = (int) -1 ;
6557 int result;
6558 bool temp1 = false ;
6559 bool temp2 = false ;
6560 int val3 ;
6561 int ecode3 = 0 ;
6562 void *argp4 = 0 ;
6563 int res4 = 0 ;
6564 int val5 ;
6565 int ecode5 = 0 ;
6566 int val6 ;
6567 int ecode6 = 0 ;
6568 PyObject * obj0 = 0 ;
6569 PyObject * obj1 = 0 ;
6570 PyObject * obj2 = 0 ;
6571 PyObject * obj3 = 0 ;
6572 PyObject * obj4 = 0 ;
6573 PyObject * obj5 = 0 ;
6574 char * kwnames[] = {
6575 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6576 };
6577
6578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6579 {
6580 arg1 = wxString_in_helper(obj0);
6581 if (arg1 == NULL) SWIG_fail;
6582 temp1 = true;
6583 }
6584 if (obj1) {
6585 {
6586 arg2 = wxString_in_helper(obj1);
6587 if (arg2 == NULL) SWIG_fail;
6588 temp2 = true;
6589 }
6590 }
6591 if (obj2) {
6592 ecode3 = SWIG_AsVal_int(obj2, &val3);
6593 if (!SWIG_IsOK(ecode3)) {
6594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6595 }
6596 arg3 = static_cast< int >(val3);
6597 }
6598 if (obj3) {
6599 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6600 if (!SWIG_IsOK(res4)) {
6601 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6602 }
6603 arg4 = reinterpret_cast< wxWindow * >(argp4);
6604 }
6605 if (obj4) {
6606 ecode5 = SWIG_AsVal_int(obj4, &val5);
6607 if (!SWIG_IsOK(ecode5)) {
6608 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6609 }
6610 arg5 = static_cast< int >(val5);
6611 }
6612 if (obj5) {
6613 ecode6 = SWIG_AsVal_int(obj5, &val6);
6614 if (!SWIG_IsOK(ecode6)) {
6615 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6616 }
6617 arg6 = static_cast< int >(val6);
6618 }
6619 {
6620 if (!wxPyCheckForApp()) SWIG_fail;
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_From_int(static_cast< int >(result));
6627 {
6628 if (temp1)
6629 delete arg1;
6630 }
6631 {
6632 if (temp2)
6633 delete arg2;
6634 }
6635 return resultobj;
6636 fail:
6637 {
6638 if (temp1)
6639 delete arg1;
6640 }
6641 {
6642 if (temp2)
6643 delete arg2;
6644 }
6645 return NULL;
6646 }
6647
6648
6649 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6650 PyObject *resultobj = 0;
6651 wxString *arg1 = 0 ;
6652 wxString *arg2 = 0 ;
6653 wxString *arg3 = 0 ;
6654 long arg4 ;
6655 long arg5 = (long) 0 ;
6656 long arg6 = (long) 100 ;
6657 wxWindow *arg7 = (wxWindow *) NULL ;
6658 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6659 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6660 long result;
6661 bool temp1 = false ;
6662 bool temp2 = false ;
6663 bool temp3 = false ;
6664 long val4 ;
6665 int ecode4 = 0 ;
6666 long val5 ;
6667 int ecode5 = 0 ;
6668 long val6 ;
6669 int ecode6 = 0 ;
6670 void *argp7 = 0 ;
6671 int res7 = 0 ;
6672 wxPoint temp8 ;
6673 PyObject * obj0 = 0 ;
6674 PyObject * obj1 = 0 ;
6675 PyObject * obj2 = 0 ;
6676 PyObject * obj3 = 0 ;
6677 PyObject * obj4 = 0 ;
6678 PyObject * obj5 = 0 ;
6679 PyObject * obj6 = 0 ;
6680 PyObject * obj7 = 0 ;
6681 char * kwnames[] = {
6682 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6683 };
6684
6685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6686 {
6687 arg1 = wxString_in_helper(obj0);
6688 if (arg1 == NULL) SWIG_fail;
6689 temp1 = true;
6690 }
6691 {
6692 arg2 = wxString_in_helper(obj1);
6693 if (arg2 == NULL) SWIG_fail;
6694 temp2 = true;
6695 }
6696 {
6697 arg3 = wxString_in_helper(obj2);
6698 if (arg3 == NULL) SWIG_fail;
6699 temp3 = true;
6700 }
6701 ecode4 = SWIG_AsVal_long(obj3, &val4);
6702 if (!SWIG_IsOK(ecode4)) {
6703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6704 }
6705 arg4 = static_cast< long >(val4);
6706 if (obj4) {
6707 ecode5 = SWIG_AsVal_long(obj4, &val5);
6708 if (!SWIG_IsOK(ecode5)) {
6709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6710 }
6711 arg5 = static_cast< long >(val5);
6712 }
6713 if (obj5) {
6714 ecode6 = SWIG_AsVal_long(obj5, &val6);
6715 if (!SWIG_IsOK(ecode6)) {
6716 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6717 }
6718 arg6 = static_cast< long >(val6);
6719 }
6720 if (obj6) {
6721 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6722 if (!SWIG_IsOK(res7)) {
6723 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6724 }
6725 arg7 = reinterpret_cast< wxWindow * >(argp7);
6726 }
6727 if (obj7) {
6728 {
6729 arg8 = &temp8;
6730 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6731 }
6732 }
6733 {
6734 if (!wxPyCheckForApp()) SWIG_fail;
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 resultobj = SWIG_From_long(static_cast< long >(result));
6741 {
6742 if (temp1)
6743 delete arg1;
6744 }
6745 {
6746 if (temp2)
6747 delete arg2;
6748 }
6749 {
6750 if (temp3)
6751 delete arg3;
6752 }
6753 return resultobj;
6754 fail:
6755 {
6756 if (temp1)
6757 delete arg1;
6758 }
6759 {
6760 if (temp2)
6761 delete arg2;
6762 }
6763 {
6764 if (temp3)
6765 delete arg3;
6766 }
6767 return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6772 PyObject *resultobj = 0;
6773 bool result;
6774
6775 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6776 {
6777 if (!wxPyCheckForApp()) SWIG_fail;
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = (bool)wxColourDisplay();
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 {
6784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6785 }
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6793 PyObject *resultobj = 0;
6794 int result;
6795
6796 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6797 {
6798 if (!wxPyCheckForApp()) SWIG_fail;
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 result = (int)wxDisplayDepth();
6801 wxPyEndAllowThreads(__tstate);
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 resultobj = SWIG_From_int(static_cast< int >(result));
6805 return resultobj;
6806 fail:
6807 return NULL;
6808 }
6809
6810
6811 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6812 PyObject *resultobj = 0;
6813 int result;
6814
6815 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6816 {
6817 if (!wxPyCheckForApp()) SWIG_fail;
6818 PyThreadState* __tstate = wxPyBeginAllowThreads();
6819 result = (int)wxGetDisplayDepth();
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 resultobj = SWIG_From_int(static_cast< int >(result));
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6831 PyObject *resultobj = 0;
6832 int *arg1 = (int *) 0 ;
6833 int *arg2 = (int *) 0 ;
6834 int temp1 ;
6835 int res1 = SWIG_TMPOBJ ;
6836 int temp2 ;
6837 int res2 = SWIG_TMPOBJ ;
6838
6839 arg1 = &temp1;
6840 arg2 = &temp2;
6841 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6842 {
6843 if (!wxPyCheckForApp()) SWIG_fail;
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 wxDisplaySize(arg1,arg2);
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_Py_Void();
6850 if (SWIG_IsTmpObj(res1)) {
6851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6852 } else {
6853 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6855 }
6856 if (SWIG_IsTmpObj(res2)) {
6857 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6858 } else {
6859 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6860 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6861 }
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6869 PyObject *resultobj = 0;
6870 wxSize result;
6871
6872 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6873 {
6874 if (!wxPyCheckForApp()) SWIG_fail;
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = wxGetDisplaySize();
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6881 return resultobj;
6882 fail:
6883 return NULL;
6884 }
6885
6886
6887 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6888 PyObject *resultobj = 0;
6889 int *arg1 = (int *) 0 ;
6890 int *arg2 = (int *) 0 ;
6891 int temp1 ;
6892 int res1 = SWIG_TMPOBJ ;
6893 int temp2 ;
6894 int res2 = SWIG_TMPOBJ ;
6895
6896 arg1 = &temp1;
6897 arg2 = &temp2;
6898 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6899 {
6900 if (!wxPyCheckForApp()) SWIG_fail;
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 wxDisplaySizeMM(arg1,arg2);
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 resultobj = SWIG_Py_Void();
6907 if (SWIG_IsTmpObj(res1)) {
6908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6909 } else {
6910 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6912 }
6913 if (SWIG_IsTmpObj(res2)) {
6914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6915 } else {
6916 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6918 }
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6926 PyObject *resultobj = 0;
6927 wxSize result;
6928
6929 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6930 {
6931 if (!wxPyCheckForApp()) SWIG_fail;
6932 PyThreadState* __tstate = wxPyBeginAllowThreads();
6933 result = wxGetDisplaySizeMM();
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6945 PyObject *resultobj = 0;
6946 int *arg1 = (int *) 0 ;
6947 int *arg2 = (int *) 0 ;
6948 int *arg3 = (int *) 0 ;
6949 int *arg4 = (int *) 0 ;
6950 int temp1 ;
6951 int res1 = SWIG_TMPOBJ ;
6952 int temp2 ;
6953 int res2 = SWIG_TMPOBJ ;
6954 int temp3 ;
6955 int res3 = SWIG_TMPOBJ ;
6956 int temp4 ;
6957 int res4 = SWIG_TMPOBJ ;
6958
6959 arg1 = &temp1;
6960 arg2 = &temp2;
6961 arg3 = &temp3;
6962 arg4 = &temp4;
6963 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6964 {
6965 if (!wxPyCheckForApp()) SWIG_fail;
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 if (SWIG_IsTmpObj(res1)) {
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6974 } else {
6975 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6977 }
6978 if (SWIG_IsTmpObj(res2)) {
6979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6980 } else {
6981 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6983 }
6984 if (SWIG_IsTmpObj(res3)) {
6985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6986 } else {
6987 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6989 }
6990 if (SWIG_IsTmpObj(res4)) {
6991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6992 } else {
6993 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6995 }
6996 return resultobj;
6997 fail:
6998 return NULL;
6999 }
7000
7001
7002 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7003 PyObject *resultobj = 0;
7004 wxRect result;
7005
7006 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7007 {
7008 if (!wxPyCheckForApp()) SWIG_fail;
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 result = wxGetClientDisplayRect();
7011 wxPyEndAllowThreads(__tstate);
7012 if (PyErr_Occurred()) SWIG_fail;
7013 }
7014 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7015 return resultobj;
7016 fail:
7017 return NULL;
7018 }
7019
7020
7021 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7022 PyObject *resultobj = 0;
7023 wxCursor *arg1 = 0 ;
7024 void *argp1 = 0 ;
7025 int res1 = 0 ;
7026 PyObject * obj0 = 0 ;
7027 char * kwnames[] = {
7028 (char *) "cursor", NULL
7029 };
7030
7031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7032 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7033 if (!SWIG_IsOK(res1)) {
7034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7035 }
7036 if (!argp1) {
7037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7038 }
7039 arg1 = reinterpret_cast< wxCursor * >(argp1);
7040 {
7041 if (!wxPyCheckForApp()) SWIG_fail;
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 wxSetCursor(*arg1);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_Py_Void();
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7055 PyObject *resultobj = 0;
7056 void *result = 0 ;
7057
7058 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7059 {
7060 if (!wxPyCheckForApp()) SWIG_fail;
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 result = (void *)wxGetXDisplay();
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj = 0;
7075 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7076 void *argp1 = 0 ;
7077 int res1 = 0 ;
7078 PyObject * obj0 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "cursor", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7084 if (obj0) {
7085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7088 }
7089 arg1 = reinterpret_cast< wxCursor * >(argp1);
7090 }
7091 {
7092 if (!wxPyCheckForApp()) SWIG_fail;
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 wxBeginBusyCursor(arg1);
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 resultobj = SWIG_Py_Void();
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7106 PyObject *resultobj = 0;
7107 wxPoint result;
7108
7109 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7110 {
7111 if (!wxPyCheckForApp()) SWIG_fail;
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 result = wxGetMousePosition();
7114 wxPyEndAllowThreads(__tstate);
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7125 PyObject *resultobj = 0;
7126 wxWindow *result = 0 ;
7127
7128 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7129 {
7130 if (!wxPyCheckForApp()) SWIG_fail;
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (wxWindow *)FindWindowAtPointer();
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 {
7137 resultobj = wxPyMake_wxObject(result, 0);
7138 }
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7146 PyObject *resultobj = 0;
7147 wxWindow *result = 0 ;
7148
7149 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7150 {
7151 if (!wxPyCheckForApp()) SWIG_fail;
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 result = (wxWindow *)wxGetActiveWindow();
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 {
7158 resultobj = wxPyMake_wxObject(result, 0);
7159 }
7160 return resultobj;
7161 fail:
7162 return NULL;
7163 }
7164
7165
7166 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7167 PyObject *resultobj = 0;
7168 wxPoint *arg1 = 0 ;
7169 wxWindow *result = 0 ;
7170 wxPoint temp1 ;
7171 PyObject * obj0 = 0 ;
7172 char * kwnames[] = {
7173 (char *) "pt", NULL
7174 };
7175
7176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7177 {
7178 arg1 = &temp1;
7179 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7180 }
7181 {
7182 if (!wxPyCheckForApp()) SWIG_fail;
7183 PyThreadState* __tstate = wxPyBeginAllowThreads();
7184 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7185 wxPyEndAllowThreads(__tstate);
7186 if (PyErr_Occurred()) SWIG_fail;
7187 }
7188 {
7189 resultobj = wxPyMake_wxObject(result, 0);
7190 }
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7198 PyObject *resultobj = 0;
7199 wxPoint *arg1 = 0 ;
7200 wxWindow *result = 0 ;
7201 wxPoint temp1 ;
7202 PyObject * obj0 = 0 ;
7203 char * kwnames[] = {
7204 (char *) "pt", NULL
7205 };
7206
7207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7208 {
7209 arg1 = &temp1;
7210 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7211 }
7212 {
7213 if (!wxPyCheckForApp()) SWIG_fail;
7214 PyThreadState* __tstate = wxPyBeginAllowThreads();
7215 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 {
7220 resultobj = wxPyMake_wxObject(result, 0);
7221 }
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj = 0;
7230 wxWindow *arg1 = (wxWindow *) 0 ;
7231 wxWindow *result = 0 ;
7232 void *argp1 = 0 ;
7233 int res1 = 0 ;
7234 PyObject * obj0 = 0 ;
7235 char * kwnames[] = {
7236 (char *) "win", NULL
7237 };
7238
7239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7243 }
7244 arg1 = reinterpret_cast< wxWindow * >(argp1);
7245 {
7246 if (!wxPyCheckForApp()) SWIG_fail;
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (wxWindow *)wxGetTopLevelParent(arg1);
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 {
7253 resultobj = wxPyMake_wxObject(result, 0);
7254 }
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj = 0;
7263 wxString *arg1 = 0 ;
7264 bool result;
7265 bool temp1 = false ;
7266 PyObject * obj0 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "url", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7272 {
7273 arg1 = wxString_in_helper(obj0);
7274 if (arg1 == NULL) SWIG_fail;
7275 temp1 = true;
7276 }
7277 {
7278 PyThreadState* __tstate = wxPyBeginAllowThreads();
7279 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7280 wxPyEndAllowThreads(__tstate);
7281 if (PyErr_Occurred()) SWIG_fail;
7282 }
7283 {
7284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7285 }
7286 {
7287 if (temp1)
7288 delete arg1;
7289 }
7290 return resultobj;
7291 fail:
7292 {
7293 if (temp1)
7294 delete arg1;
7295 }
7296 return NULL;
7297 }
7298
7299
7300 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj = 0;
7302 wxKeyCode arg1 ;
7303 bool result;
7304 int val1 ;
7305 int ecode1 = 0 ;
7306 PyObject * obj0 = 0 ;
7307 char * kwnames[] = {
7308 (char *) "key", NULL
7309 };
7310
7311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7312 ecode1 = SWIG_AsVal_int(obj0, &val1);
7313 if (!SWIG_IsOK(ecode1)) {
7314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7315 }
7316 arg1 = static_cast< wxKeyCode >(val1);
7317 {
7318 if (!wxPyCheckForApp()) SWIG_fail;
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (bool)wxGetKeyState(arg1);
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 {
7325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7326 }
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7334 PyObject *resultobj = 0;
7335 wxMouseState *result = 0 ;
7336
7337 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (wxMouseState *)new wxMouseState();
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7352 PyObject *resultobj = 0;
7353 wxMouseState *arg1 = (wxMouseState *) 0 ;
7354 void *argp1 = 0 ;
7355 int res1 = 0 ;
7356 PyObject *swig_obj[1] ;
7357
7358 if (!args) SWIG_fail;
7359 swig_obj[0] = args;
7360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7361 if (!SWIG_IsOK(res1)) {
7362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7363 }
7364 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7365 {
7366 PyThreadState* __tstate = wxPyBeginAllowThreads();
7367 delete arg1;
7368
7369 wxPyEndAllowThreads(__tstate);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 resultobj = SWIG_Py_Void();
7373 return resultobj;
7374 fail:
7375 return NULL;
7376 }
7377
7378
7379 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7380 PyObject *resultobj = 0;
7381 wxMouseState *arg1 = (wxMouseState *) 0 ;
7382 int result;
7383 void *argp1 = 0 ;
7384 int res1 = 0 ;
7385 PyObject *swig_obj[1] ;
7386
7387 if (!args) SWIG_fail;
7388 swig_obj[0] = args;
7389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7392 }
7393 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 result = (int)(arg1)->GetX();
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 resultobj = SWIG_From_int(static_cast< int >(result));
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7408 PyObject *resultobj = 0;
7409 wxMouseState *arg1 = (wxMouseState *) 0 ;
7410 int result;
7411 void *argp1 = 0 ;
7412 int res1 = 0 ;
7413 PyObject *swig_obj[1] ;
7414
7415 if (!args) SWIG_fail;
7416 swig_obj[0] = args;
7417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7418 if (!SWIG_IsOK(res1)) {
7419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7420 }
7421 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7422 {
7423 PyThreadState* __tstate = wxPyBeginAllowThreads();
7424 result = (int)(arg1)->GetY();
7425 wxPyEndAllowThreads(__tstate);
7426 if (PyErr_Occurred()) SWIG_fail;
7427 }
7428 resultobj = SWIG_From_int(static_cast< int >(result));
7429 return resultobj;
7430 fail:
7431 return NULL;
7432 }
7433
7434
7435 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7436 PyObject *resultobj = 0;
7437 wxMouseState *arg1 = (wxMouseState *) 0 ;
7438 bool result;
7439 void *argp1 = 0 ;
7440 int res1 = 0 ;
7441 PyObject *swig_obj[1] ;
7442
7443 if (!args) SWIG_fail;
7444 swig_obj[0] = args;
7445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7446 if (!SWIG_IsOK(res1)) {
7447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7448 }
7449 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (bool)(arg1)->LeftDown();
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7466 PyObject *resultobj = 0;
7467 wxMouseState *arg1 = (wxMouseState *) 0 ;
7468 bool result;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 PyObject *swig_obj[1] ;
7472
7473 if (!args) SWIG_fail;
7474 swig_obj[0] = args;
7475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7478 }
7479 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7480 {
7481 PyThreadState* __tstate = wxPyBeginAllowThreads();
7482 result = (bool)(arg1)->MiddleDown();
7483 wxPyEndAllowThreads(__tstate);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 {
7487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7488 }
7489 return resultobj;
7490 fail:
7491 return NULL;
7492 }
7493
7494
7495 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7496 PyObject *resultobj = 0;
7497 wxMouseState *arg1 = (wxMouseState *) 0 ;
7498 bool result;
7499 void *argp1 = 0 ;
7500 int res1 = 0 ;
7501 PyObject *swig_obj[1] ;
7502
7503 if (!args) SWIG_fail;
7504 swig_obj[0] = args;
7505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7506 if (!SWIG_IsOK(res1)) {
7507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7508 }
7509 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 result = (bool)(arg1)->RightDown();
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 {
7517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7518 }
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7526 PyObject *resultobj = 0;
7527 wxMouseState *arg1 = (wxMouseState *) 0 ;
7528 bool result;
7529 void *argp1 = 0 ;
7530 int res1 = 0 ;
7531 PyObject *swig_obj[1] ;
7532
7533 if (!args) SWIG_fail;
7534 swig_obj[0] = args;
7535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7536 if (!SWIG_IsOK(res1)) {
7537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7538 }
7539 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (bool)(arg1)->ControlDown();
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 {
7547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7548 }
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7556 PyObject *resultobj = 0;
7557 wxMouseState *arg1 = (wxMouseState *) 0 ;
7558 bool result;
7559 void *argp1 = 0 ;
7560 int res1 = 0 ;
7561 PyObject *swig_obj[1] ;
7562
7563 if (!args) SWIG_fail;
7564 swig_obj[0] = args;
7565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7566 if (!SWIG_IsOK(res1)) {
7567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7568 }
7569 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = (bool)(arg1)->ShiftDown();
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 {
7577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7578 }
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7586 PyObject *resultobj = 0;
7587 wxMouseState *arg1 = (wxMouseState *) 0 ;
7588 bool result;
7589 void *argp1 = 0 ;
7590 int res1 = 0 ;
7591 PyObject *swig_obj[1] ;
7592
7593 if (!args) SWIG_fail;
7594 swig_obj[0] = args;
7595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7596 if (!SWIG_IsOK(res1)) {
7597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7598 }
7599 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7600 {
7601 PyThreadState* __tstate = wxPyBeginAllowThreads();
7602 result = (bool)(arg1)->AltDown();
7603 wxPyEndAllowThreads(__tstate);
7604 if (PyErr_Occurred()) SWIG_fail;
7605 }
7606 {
7607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7608 }
7609 return resultobj;
7610 fail:
7611 return NULL;
7612 }
7613
7614
7615 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7616 PyObject *resultobj = 0;
7617 wxMouseState *arg1 = (wxMouseState *) 0 ;
7618 bool result;
7619 void *argp1 = 0 ;
7620 int res1 = 0 ;
7621 PyObject *swig_obj[1] ;
7622
7623 if (!args) SWIG_fail;
7624 swig_obj[0] = args;
7625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7626 if (!SWIG_IsOK(res1)) {
7627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7628 }
7629 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 result = (bool)(arg1)->MetaDown();
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 {
7637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7638 }
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7646 PyObject *resultobj = 0;
7647 wxMouseState *arg1 = (wxMouseState *) 0 ;
7648 bool result;
7649 void *argp1 = 0 ;
7650 int res1 = 0 ;
7651 PyObject *swig_obj[1] ;
7652
7653 if (!args) SWIG_fail;
7654 swig_obj[0] = args;
7655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7656 if (!SWIG_IsOK(res1)) {
7657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7658 }
7659 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (bool)(arg1)->CmdDown();
7663 wxPyEndAllowThreads(__tstate);
7664 if (PyErr_Occurred()) SWIG_fail;
7665 }
7666 {
7667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7668 }
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7676 PyObject *resultobj = 0;
7677 wxMouseState *arg1 = (wxMouseState *) 0 ;
7678 int arg2 ;
7679 void *argp1 = 0 ;
7680 int res1 = 0 ;
7681 int val2 ;
7682 int ecode2 = 0 ;
7683 PyObject * obj0 = 0 ;
7684 PyObject * obj1 = 0 ;
7685 char * kwnames[] = {
7686 (char *) "self",(char *) "x", NULL
7687 };
7688
7689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7691 if (!SWIG_IsOK(res1)) {
7692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7693 }
7694 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7695 ecode2 = SWIG_AsVal_int(obj1, &val2);
7696 if (!SWIG_IsOK(ecode2)) {
7697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7698 }
7699 arg2 = static_cast< int >(val2);
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 (arg1)->SetX(arg2);
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 resultobj = SWIG_Py_Void();
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7714 PyObject *resultobj = 0;
7715 wxMouseState *arg1 = (wxMouseState *) 0 ;
7716 int arg2 ;
7717 void *argp1 = 0 ;
7718 int res1 = 0 ;
7719 int val2 ;
7720 int ecode2 = 0 ;
7721 PyObject * obj0 = 0 ;
7722 PyObject * obj1 = 0 ;
7723 char * kwnames[] = {
7724 (char *) "self",(char *) "y", NULL
7725 };
7726
7727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7729 if (!SWIG_IsOK(res1)) {
7730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7731 }
7732 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7733 ecode2 = SWIG_AsVal_int(obj1, &val2);
7734 if (!SWIG_IsOK(ecode2)) {
7735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7736 }
7737 arg2 = static_cast< int >(val2);
7738 {
7739 PyThreadState* __tstate = wxPyBeginAllowThreads();
7740 (arg1)->SetY(arg2);
7741 wxPyEndAllowThreads(__tstate);
7742 if (PyErr_Occurred()) SWIG_fail;
7743 }
7744 resultobj = SWIG_Py_Void();
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7752 PyObject *resultobj = 0;
7753 wxMouseState *arg1 = (wxMouseState *) 0 ;
7754 bool arg2 ;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 bool val2 ;
7758 int ecode2 = 0 ;
7759 PyObject * obj0 = 0 ;
7760 PyObject * obj1 = 0 ;
7761 char * kwnames[] = {
7762 (char *) "self",(char *) "down", NULL
7763 };
7764
7765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7767 if (!SWIG_IsOK(res1)) {
7768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7769 }
7770 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7772 if (!SWIG_IsOK(ecode2)) {
7773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7774 }
7775 arg2 = static_cast< bool >(val2);
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 (arg1)->SetLeftDown(arg2);
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 resultobj = SWIG_Py_Void();
7783 return resultobj;
7784 fail:
7785 return NULL;
7786 }
7787
7788
7789 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7790 PyObject *resultobj = 0;
7791 wxMouseState *arg1 = (wxMouseState *) 0 ;
7792 bool arg2 ;
7793 void *argp1 = 0 ;
7794 int res1 = 0 ;
7795 bool val2 ;
7796 int ecode2 = 0 ;
7797 PyObject * obj0 = 0 ;
7798 PyObject * obj1 = 0 ;
7799 char * kwnames[] = {
7800 (char *) "self",(char *) "down", NULL
7801 };
7802
7803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7805 if (!SWIG_IsOK(res1)) {
7806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7807 }
7808 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7810 if (!SWIG_IsOK(ecode2)) {
7811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7812 }
7813 arg2 = static_cast< bool >(val2);
7814 {
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 (arg1)->SetMiddleDown(arg2);
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 resultobj = SWIG_Py_Void();
7821 return resultobj;
7822 fail:
7823 return NULL;
7824 }
7825
7826
7827 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7828 PyObject *resultobj = 0;
7829 wxMouseState *arg1 = (wxMouseState *) 0 ;
7830 bool arg2 ;
7831 void *argp1 = 0 ;
7832 int res1 = 0 ;
7833 bool val2 ;
7834 int ecode2 = 0 ;
7835 PyObject * obj0 = 0 ;
7836 PyObject * obj1 = 0 ;
7837 char * kwnames[] = {
7838 (char *) "self",(char *) "down", NULL
7839 };
7840
7841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7843 if (!SWIG_IsOK(res1)) {
7844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7845 }
7846 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7848 if (!SWIG_IsOK(ecode2)) {
7849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7850 }
7851 arg2 = static_cast< bool >(val2);
7852 {
7853 PyThreadState* __tstate = wxPyBeginAllowThreads();
7854 (arg1)->SetRightDown(arg2);
7855 wxPyEndAllowThreads(__tstate);
7856 if (PyErr_Occurred()) SWIG_fail;
7857 }
7858 resultobj = SWIG_Py_Void();
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7866 PyObject *resultobj = 0;
7867 wxMouseState *arg1 = (wxMouseState *) 0 ;
7868 bool arg2 ;
7869 void *argp1 = 0 ;
7870 int res1 = 0 ;
7871 bool val2 ;
7872 int ecode2 = 0 ;
7873 PyObject * obj0 = 0 ;
7874 PyObject * obj1 = 0 ;
7875 char * kwnames[] = {
7876 (char *) "self",(char *) "down", NULL
7877 };
7878
7879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7881 if (!SWIG_IsOK(res1)) {
7882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7883 }
7884 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7885 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7886 if (!SWIG_IsOK(ecode2)) {
7887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7888 }
7889 arg2 = static_cast< bool >(val2);
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 (arg1)->SetControlDown(arg2);
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 resultobj = SWIG_Py_Void();
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7904 PyObject *resultobj = 0;
7905 wxMouseState *arg1 = (wxMouseState *) 0 ;
7906 bool arg2 ;
7907 void *argp1 = 0 ;
7908 int res1 = 0 ;
7909 bool val2 ;
7910 int ecode2 = 0 ;
7911 PyObject * obj0 = 0 ;
7912 PyObject * obj1 = 0 ;
7913 char * kwnames[] = {
7914 (char *) "self",(char *) "down", NULL
7915 };
7916
7917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7919 if (!SWIG_IsOK(res1)) {
7920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7921 }
7922 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7923 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7924 if (!SWIG_IsOK(ecode2)) {
7925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7926 }
7927 arg2 = static_cast< bool >(val2);
7928 {
7929 PyThreadState* __tstate = wxPyBeginAllowThreads();
7930 (arg1)->SetShiftDown(arg2);
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 resultobj = SWIG_Py_Void();
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7942 PyObject *resultobj = 0;
7943 wxMouseState *arg1 = (wxMouseState *) 0 ;
7944 bool arg2 ;
7945 void *argp1 = 0 ;
7946 int res1 = 0 ;
7947 bool val2 ;
7948 int ecode2 = 0 ;
7949 PyObject * obj0 = 0 ;
7950 PyObject * obj1 = 0 ;
7951 char * kwnames[] = {
7952 (char *) "self",(char *) "down", NULL
7953 };
7954
7955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7957 if (!SWIG_IsOK(res1)) {
7958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7959 }
7960 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7961 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7962 if (!SWIG_IsOK(ecode2)) {
7963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7964 }
7965 arg2 = static_cast< bool >(val2);
7966 {
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 (arg1)->SetAltDown(arg2);
7969 wxPyEndAllowThreads(__tstate);
7970 if (PyErr_Occurred()) SWIG_fail;
7971 }
7972 resultobj = SWIG_Py_Void();
7973 return resultobj;
7974 fail:
7975 return NULL;
7976 }
7977
7978
7979 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7980 PyObject *resultobj = 0;
7981 wxMouseState *arg1 = (wxMouseState *) 0 ;
7982 bool arg2 ;
7983 void *argp1 = 0 ;
7984 int res1 = 0 ;
7985 bool val2 ;
7986 int ecode2 = 0 ;
7987 PyObject * obj0 = 0 ;
7988 PyObject * obj1 = 0 ;
7989 char * kwnames[] = {
7990 (char *) "self",(char *) "down", NULL
7991 };
7992
7993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7995 if (!SWIG_IsOK(res1)) {
7996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7997 }
7998 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7999 ecode2 = SWIG_AsVal_bool(obj1, &val2);
8000 if (!SWIG_IsOK(ecode2)) {
8001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8002 }
8003 arg2 = static_cast< bool >(val2);
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 (arg1)->SetMetaDown(arg2);
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 resultobj = SWIG_Py_Void();
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8018 PyObject *obj;
8019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8020 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8021 return SWIG_Py_Void();
8022 }
8023
8024 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 return SWIG_Python_InitShadowInstance(args);
8026 }
8027
8028 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8029 PyObject *resultobj = 0;
8030 wxMouseState result;
8031
8032 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = wxGetMouseState();
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8047 PyObject *resultobj = 0;
8048
8049 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8050 {
8051 if (!wxPyCheckForApp()) SWIG_fail;
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 wxWakeUpMainThread();
8054 wxPyEndAllowThreads(__tstate);
8055 if (PyErr_Occurred()) SWIG_fail;
8056 }
8057 resultobj = SWIG_Py_Void();
8058 return resultobj;
8059 fail:
8060 return NULL;
8061 }
8062
8063
8064 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8065 PyObject *resultobj = 0;
8066
8067 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8068 {
8069 if (!wxPyCheckForApp()) SWIG_fail;
8070 PyThreadState* __tstate = wxPyBeginAllowThreads();
8071 wxMutexGuiEnter();
8072 wxPyEndAllowThreads(__tstate);
8073 if (PyErr_Occurred()) SWIG_fail;
8074 }
8075 resultobj = SWIG_Py_Void();
8076 return resultobj;
8077 fail:
8078 return NULL;
8079 }
8080
8081
8082 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8083 PyObject *resultobj = 0;
8084
8085 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8086 {
8087 if (!wxPyCheckForApp()) SWIG_fail;
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 wxMutexGuiLeave();
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 resultobj = SWIG_Py_Void();
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8101 PyObject *resultobj = 0;
8102 wxMutexGuiLocker *result = 0 ;
8103
8104 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8105 {
8106 if (!wxPyCheckForApp()) SWIG_fail;
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8120 PyObject *resultobj = 0;
8121 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8122 void *argp1 = 0 ;
8123 int res1 = 0 ;
8124 PyObject *swig_obj[1] ;
8125
8126 if (!args) SWIG_fail;
8127 swig_obj[0] = args;
8128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8129 if (!SWIG_IsOK(res1)) {
8130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8131 }
8132 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 delete arg1;
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8148 PyObject *obj;
8149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8150 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8151 return SWIG_Py_Void();
8152 }
8153
8154 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8155 return SWIG_Python_InitShadowInstance(args);
8156 }
8157
8158 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8159 PyObject *resultobj = 0;
8160 bool result;
8161
8162 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (bool)wxThread_IsMain();
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 {
8170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8171 }
8172 return resultobj;
8173 fail:
8174 return NULL;
8175 }
8176
8177
8178 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8179 PyObject *resultobj = 0;
8180 wxString *arg1 = 0 ;
8181 wxToolTip *result = 0 ;
8182 bool temp1 = false ;
8183 PyObject * obj0 = 0 ;
8184 char * kwnames[] = {
8185 (char *) "tip", NULL
8186 };
8187
8188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8189 {
8190 arg1 = wxString_in_helper(obj0);
8191 if (arg1 == NULL) SWIG_fail;
8192 temp1 = true;
8193 }
8194 {
8195 if (!wxPyCheckForApp()) SWIG_fail;
8196 PyThreadState* __tstate = wxPyBeginAllowThreads();
8197 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8202 {
8203 if (temp1)
8204 delete arg1;
8205 }
8206 return resultobj;
8207 fail:
8208 {
8209 if (temp1)
8210 delete arg1;
8211 }
8212 return NULL;
8213 }
8214
8215
8216 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8217 PyObject *resultobj = 0;
8218 wxToolTip *arg1 = (wxToolTip *) 0 ;
8219 void *argp1 = 0 ;
8220 int res1 = 0 ;
8221 PyObject *swig_obj[1] ;
8222
8223 if (!args) SWIG_fail;
8224 swig_obj[0] = args;
8225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8226 if (!SWIG_IsOK(res1)) {
8227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8228 }
8229 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 delete arg1;
8233
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = SWIG_Py_Void();
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj = 0;
8246 wxToolTip *arg1 = (wxToolTip *) 0 ;
8247 wxString *arg2 = 0 ;
8248 void *argp1 = 0 ;
8249 int res1 = 0 ;
8250 bool temp2 = false ;
8251 PyObject * obj0 = 0 ;
8252 PyObject * obj1 = 0 ;
8253 char * kwnames[] = {
8254 (char *) "self",(char *) "tip", NULL
8255 };
8256
8257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8259 if (!SWIG_IsOK(res1)) {
8260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8261 }
8262 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8263 {
8264 arg2 = wxString_in_helper(obj1);
8265 if (arg2 == NULL) SWIG_fail;
8266 temp2 = true;
8267 }
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 (arg1)->SetTip((wxString const &)*arg2);
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = SWIG_Py_Void();
8275 {
8276 if (temp2)
8277 delete arg2;
8278 }
8279 return resultobj;
8280 fail:
8281 {
8282 if (temp2)
8283 delete arg2;
8284 }
8285 return NULL;
8286 }
8287
8288
8289 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8290 PyObject *resultobj = 0;
8291 wxToolTip *arg1 = (wxToolTip *) 0 ;
8292 wxString result;
8293 void *argp1 = 0 ;
8294 int res1 = 0 ;
8295 PyObject *swig_obj[1] ;
8296
8297 if (!args) SWIG_fail;
8298 swig_obj[0] = args;
8299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8300 if (!SWIG_IsOK(res1)) {
8301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8302 }
8303 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8304 {
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (arg1)->GetTip();
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 {
8311 #if wxUSE_UNICODE
8312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8313 #else
8314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8315 #endif
8316 }
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8324 PyObject *resultobj = 0;
8325 wxToolTip *arg1 = (wxToolTip *) 0 ;
8326 wxWindow *result = 0 ;
8327 void *argp1 = 0 ;
8328 int res1 = 0 ;
8329 PyObject *swig_obj[1] ;
8330
8331 if (!args) SWIG_fail;
8332 swig_obj[0] = args;
8333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8334 if (!SWIG_IsOK(res1)) {
8335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8336 }
8337 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8338 {
8339 PyThreadState* __tstate = wxPyBeginAllowThreads();
8340 result = (wxWindow *)(arg1)->GetWindow();
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 {
8345 resultobj = wxPyMake_wxObject(result, 0);
8346 }
8347 return resultobj;
8348 fail:
8349 return NULL;
8350 }
8351
8352
8353 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8354 PyObject *resultobj = 0;
8355 bool arg1 ;
8356 bool val1 ;
8357 int ecode1 = 0 ;
8358 PyObject * obj0 = 0 ;
8359 char * kwnames[] = {
8360 (char *) "flag", NULL
8361 };
8362
8363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8364 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8365 if (!SWIG_IsOK(ecode1)) {
8366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8367 }
8368 arg1 = static_cast< bool >(val1);
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 wxToolTip::Enable(arg1);
8372 wxPyEndAllowThreads(__tstate);
8373 if (PyErr_Occurred()) SWIG_fail;
8374 }
8375 resultobj = SWIG_Py_Void();
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj = 0;
8384 long arg1 ;
8385 long val1 ;
8386 int ecode1 = 0 ;
8387 PyObject * obj0 = 0 ;
8388 char * kwnames[] = {
8389 (char *) "milliseconds", NULL
8390 };
8391
8392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8393 ecode1 = SWIG_AsVal_long(obj0, &val1);
8394 if (!SWIG_IsOK(ecode1)) {
8395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8396 }
8397 arg1 = static_cast< long >(val1);
8398 {
8399 PyThreadState* __tstate = wxPyBeginAllowThreads();
8400 wxToolTip::SetDelay(arg1);
8401 wxPyEndAllowThreads(__tstate);
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 resultobj = SWIG_Py_Void();
8405 return resultobj;
8406 fail:
8407 return NULL;
8408 }
8409
8410
8411 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8412 PyObject *obj;
8413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8414 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8415 return SWIG_Py_Void();
8416 }
8417
8418 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8419 return SWIG_Python_InitShadowInstance(args);
8420 }
8421
8422 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8423 PyObject *resultobj = 0;
8424 wxWindow *arg1 = (wxWindow *) 0 ;
8425 wxSize *arg2 = 0 ;
8426 wxCaret *result = 0 ;
8427 void *argp1 = 0 ;
8428 int res1 = 0 ;
8429 wxSize temp2 ;
8430 PyObject * obj0 = 0 ;
8431 PyObject * obj1 = 0 ;
8432 char * kwnames[] = {
8433 (char *) "window",(char *) "size", NULL
8434 };
8435
8436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8438 if (!SWIG_IsOK(res1)) {
8439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8440 }
8441 arg1 = reinterpret_cast< wxWindow * >(argp1);
8442 {
8443 arg2 = &temp2;
8444 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8445 }
8446 {
8447 if (!wxPyCheckForApp()) SWIG_fail;
8448 PyThreadState* __tstate = wxPyBeginAllowThreads();
8449 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8454 return resultobj;
8455 fail:
8456 return NULL;
8457 }
8458
8459
8460 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8461 PyObject *resultobj = 0;
8462 wxCaret *arg1 = (wxCaret *) 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 PyObject *swig_obj[1] ;
8466
8467 if (!args) SWIG_fail;
8468 swig_obj[0] = args;
8469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8470 if (!SWIG_IsOK(res1)) {
8471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8472 }
8473 arg1 = reinterpret_cast< wxCaret * >(argp1);
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 delete arg1;
8477
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 resultobj = SWIG_Py_Void();
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8489 PyObject *resultobj = 0;
8490 wxCaret *arg1 = (wxCaret *) 0 ;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 PyObject *swig_obj[1] ;
8494
8495 if (!args) SWIG_fail;
8496 swig_obj[0] = args;
8497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8500 }
8501 arg1 = reinterpret_cast< wxCaret * >(argp1);
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 wxCaret_Destroy(arg1);
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 resultobj = SWIG_Py_Void();
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8516 PyObject *resultobj = 0;
8517 wxCaret *arg1 = (wxCaret *) 0 ;
8518 bool result;
8519 void *argp1 = 0 ;
8520 int res1 = 0 ;
8521 PyObject *swig_obj[1] ;
8522
8523 if (!args) SWIG_fail;
8524 swig_obj[0] = args;
8525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8526 if (!SWIG_IsOK(res1)) {
8527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8528 }
8529 arg1 = reinterpret_cast< wxCaret * >(argp1);
8530 {
8531 PyThreadState* __tstate = wxPyBeginAllowThreads();
8532 result = (bool)(arg1)->IsOk();
8533 wxPyEndAllowThreads(__tstate);
8534 if (PyErr_Occurred()) SWIG_fail;
8535 }
8536 {
8537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8538 }
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxCaret *arg1 = (wxCaret *) 0 ;
8548 bool result;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 PyObject *swig_obj[1] ;
8552
8553 if (!args) SWIG_fail;
8554 swig_obj[0] = args;
8555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8558 }
8559 arg1 = reinterpret_cast< wxCaret * >(argp1);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (bool)(arg1)->IsVisible();
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 {
8567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8568 }
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8576 PyObject *resultobj = 0;
8577 wxCaret *arg1 = (wxCaret *) 0 ;
8578 wxPoint result;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 PyObject *swig_obj[1] ;
8582
8583 if (!args) SWIG_fail;
8584 swig_obj[0] = args;
8585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8586 if (!SWIG_IsOK(res1)) {
8587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8588 }
8589 arg1 = reinterpret_cast< wxCaret * >(argp1);
8590 {
8591 PyThreadState* __tstate = wxPyBeginAllowThreads();
8592 result = (arg1)->GetPosition();
8593 wxPyEndAllowThreads(__tstate);
8594 if (PyErr_Occurred()) SWIG_fail;
8595 }
8596 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8597 return resultobj;
8598 fail:
8599 return NULL;
8600 }
8601
8602
8603 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8604 PyObject *resultobj = 0;
8605 wxCaret *arg1 = (wxCaret *) 0 ;
8606 int *arg2 = (int *) 0 ;
8607 int *arg3 = (int *) 0 ;
8608 void *argp1 = 0 ;
8609 int res1 = 0 ;
8610 int temp2 ;
8611 int res2 = SWIG_TMPOBJ ;
8612 int temp3 ;
8613 int res3 = SWIG_TMPOBJ ;
8614 PyObject *swig_obj[1] ;
8615
8616 arg2 = &temp2;
8617 arg3 = &temp3;
8618 if (!args) SWIG_fail;
8619 swig_obj[0] = args;
8620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8621 if (!SWIG_IsOK(res1)) {
8622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8623 }
8624 arg1 = reinterpret_cast< wxCaret * >(argp1);
8625 {
8626 PyThreadState* __tstate = wxPyBeginAllowThreads();
8627 (arg1)->GetPosition(arg2,arg3);
8628 wxPyEndAllowThreads(__tstate);
8629 if (PyErr_Occurred()) SWIG_fail;
8630 }
8631 resultobj = SWIG_Py_Void();
8632 if (SWIG_IsTmpObj(res2)) {
8633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8634 } else {
8635 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8637 }
8638 if (SWIG_IsTmpObj(res3)) {
8639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8640 } else {
8641 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8643 }
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8651 PyObject *resultobj = 0;
8652 wxCaret *arg1 = (wxCaret *) 0 ;
8653 wxSize result;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 PyObject *swig_obj[1] ;
8657
8658 if (!args) SWIG_fail;
8659 swig_obj[0] = args;
8660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8661 if (!SWIG_IsOK(res1)) {
8662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8663 }
8664 arg1 = reinterpret_cast< wxCaret * >(argp1);
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 result = (arg1)->GetSize();
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8679 PyObject *resultobj = 0;
8680 wxCaret *arg1 = (wxCaret *) 0 ;
8681 int *arg2 = (int *) 0 ;
8682 int *arg3 = (int *) 0 ;
8683 void *argp1 = 0 ;
8684 int res1 = 0 ;
8685 int temp2 ;
8686 int res2 = SWIG_TMPOBJ ;
8687 int temp3 ;
8688 int res3 = SWIG_TMPOBJ ;
8689 PyObject *swig_obj[1] ;
8690
8691 arg2 = &temp2;
8692 arg3 = &temp3;
8693 if (!args) SWIG_fail;
8694 swig_obj[0] = args;
8695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8696 if (!SWIG_IsOK(res1)) {
8697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8698 }
8699 arg1 = reinterpret_cast< wxCaret * >(argp1);
8700 {
8701 PyThreadState* __tstate = wxPyBeginAllowThreads();
8702 (arg1)->GetSize(arg2,arg3);
8703 wxPyEndAllowThreads(__tstate);
8704 if (PyErr_Occurred()) SWIG_fail;
8705 }
8706 resultobj = SWIG_Py_Void();
8707 if (SWIG_IsTmpObj(res2)) {
8708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8709 } else {
8710 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8712 }
8713 if (SWIG_IsTmpObj(res3)) {
8714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8715 } else {
8716 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8718 }
8719 return resultobj;
8720 fail:
8721 return NULL;
8722 }
8723
8724
8725 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8726 PyObject *resultobj = 0;
8727 wxCaret *arg1 = (wxCaret *) 0 ;
8728 wxWindow *result = 0 ;
8729 void *argp1 = 0 ;
8730 int res1 = 0 ;
8731 PyObject *swig_obj[1] ;
8732
8733 if (!args) SWIG_fail;
8734 swig_obj[0] = args;
8735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8736 if (!SWIG_IsOK(res1)) {
8737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8738 }
8739 arg1 = reinterpret_cast< wxCaret * >(argp1);
8740 {
8741 PyThreadState* __tstate = wxPyBeginAllowThreads();
8742 result = (wxWindow *)(arg1)->GetWindow();
8743 wxPyEndAllowThreads(__tstate);
8744 if (PyErr_Occurred()) SWIG_fail;
8745 }
8746 {
8747 resultobj = wxPyMake_wxObject(result, 0);
8748 }
8749 return resultobj;
8750 fail:
8751 return NULL;
8752 }
8753
8754
8755 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8756 PyObject *resultobj = 0;
8757 wxCaret *arg1 = (wxCaret *) 0 ;
8758 int arg2 ;
8759 int arg3 ;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 int val2 ;
8763 int ecode2 = 0 ;
8764 int val3 ;
8765 int ecode3 = 0 ;
8766 PyObject * obj0 = 0 ;
8767 PyObject * obj1 = 0 ;
8768 PyObject * obj2 = 0 ;
8769 char * kwnames[] = {
8770 (char *) "self",(char *) "x",(char *) "y", NULL
8771 };
8772
8773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8775 if (!SWIG_IsOK(res1)) {
8776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8777 }
8778 arg1 = reinterpret_cast< wxCaret * >(argp1);
8779 ecode2 = SWIG_AsVal_int(obj1, &val2);
8780 if (!SWIG_IsOK(ecode2)) {
8781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8782 }
8783 arg2 = static_cast< int >(val2);
8784 ecode3 = SWIG_AsVal_int(obj2, &val3);
8785 if (!SWIG_IsOK(ecode3)) {
8786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8787 }
8788 arg3 = static_cast< int >(val3);
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 (arg1)->Move(arg2,arg3);
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 resultobj = SWIG_Py_Void();
8796 return resultobj;
8797 fail:
8798 return NULL;
8799 }
8800
8801
8802 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8803 PyObject *resultobj = 0;
8804 wxCaret *arg1 = (wxCaret *) 0 ;
8805 wxPoint *arg2 = 0 ;
8806 void *argp1 = 0 ;
8807 int res1 = 0 ;
8808 wxPoint temp2 ;
8809 PyObject * obj0 = 0 ;
8810 PyObject * obj1 = 0 ;
8811 char * kwnames[] = {
8812 (char *) "self",(char *) "pt", NULL
8813 };
8814
8815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8817 if (!SWIG_IsOK(res1)) {
8818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8819 }
8820 arg1 = reinterpret_cast< wxCaret * >(argp1);
8821 {
8822 arg2 = &temp2;
8823 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8824 }
8825 {
8826 PyThreadState* __tstate = wxPyBeginAllowThreads();
8827 (arg1)->Move((wxPoint const &)*arg2);
8828 wxPyEndAllowThreads(__tstate);
8829 if (PyErr_Occurred()) SWIG_fail;
8830 }
8831 resultobj = SWIG_Py_Void();
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj = 0;
8840 wxCaret *arg1 = (wxCaret *) 0 ;
8841 int arg2 ;
8842 int arg3 ;
8843 void *argp1 = 0 ;
8844 int res1 = 0 ;
8845 int val2 ;
8846 int ecode2 = 0 ;
8847 int val3 ;
8848 int ecode3 = 0 ;
8849 PyObject * obj0 = 0 ;
8850 PyObject * obj1 = 0 ;
8851 PyObject * obj2 = 0 ;
8852 char * kwnames[] = {
8853 (char *) "self",(char *) "width",(char *) "height", NULL
8854 };
8855
8856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8858 if (!SWIG_IsOK(res1)) {
8859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8860 }
8861 arg1 = reinterpret_cast< wxCaret * >(argp1);
8862 ecode2 = SWIG_AsVal_int(obj1, &val2);
8863 if (!SWIG_IsOK(ecode2)) {
8864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8865 }
8866 arg2 = static_cast< int >(val2);
8867 ecode3 = SWIG_AsVal_int(obj2, &val3);
8868 if (!SWIG_IsOK(ecode3)) {
8869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8870 }
8871 arg3 = static_cast< int >(val3);
8872 {
8873 PyThreadState* __tstate = wxPyBeginAllowThreads();
8874 (arg1)->SetSize(arg2,arg3);
8875 wxPyEndAllowThreads(__tstate);
8876 if (PyErr_Occurred()) SWIG_fail;
8877 }
8878 resultobj = SWIG_Py_Void();
8879 return resultobj;
8880 fail:
8881 return NULL;
8882 }
8883
8884
8885 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8886 PyObject *resultobj = 0;
8887 wxCaret *arg1 = (wxCaret *) 0 ;
8888 wxSize *arg2 = 0 ;
8889 void *argp1 = 0 ;
8890 int res1 = 0 ;
8891 wxSize temp2 ;
8892 PyObject * obj0 = 0 ;
8893 PyObject * obj1 = 0 ;
8894 char * kwnames[] = {
8895 (char *) "self",(char *) "size", NULL
8896 };
8897
8898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8900 if (!SWIG_IsOK(res1)) {
8901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8902 }
8903 arg1 = reinterpret_cast< wxCaret * >(argp1);
8904 {
8905 arg2 = &temp2;
8906 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8907 }
8908 {
8909 PyThreadState* __tstate = wxPyBeginAllowThreads();
8910 (arg1)->SetSize((wxSize const &)*arg2);
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 resultobj = SWIG_Py_Void();
8915 return resultobj;
8916 fail:
8917 return NULL;
8918 }
8919
8920
8921 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8922 PyObject *resultobj = 0;
8923 wxCaret *arg1 = (wxCaret *) 0 ;
8924 int arg2 = (int) true ;
8925 void *argp1 = 0 ;
8926 int res1 = 0 ;
8927 int val2 ;
8928 int ecode2 = 0 ;
8929 PyObject * obj0 = 0 ;
8930 PyObject * obj1 = 0 ;
8931 char * kwnames[] = {
8932 (char *) "self",(char *) "show", NULL
8933 };
8934
8935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8937 if (!SWIG_IsOK(res1)) {
8938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8939 }
8940 arg1 = reinterpret_cast< wxCaret * >(argp1);
8941 if (obj1) {
8942 ecode2 = SWIG_AsVal_int(obj1, &val2);
8943 if (!SWIG_IsOK(ecode2)) {
8944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8945 }
8946 arg2 = static_cast< int >(val2);
8947 }
8948 {
8949 PyThreadState* __tstate = wxPyBeginAllowThreads();
8950 (arg1)->Show(arg2);
8951 wxPyEndAllowThreads(__tstate);
8952 if (PyErr_Occurred()) SWIG_fail;
8953 }
8954 resultobj = SWIG_Py_Void();
8955 return resultobj;
8956 fail:
8957 return NULL;
8958 }
8959
8960
8961 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8962 PyObject *resultobj = 0;
8963 wxCaret *arg1 = (wxCaret *) 0 ;
8964 void *argp1 = 0 ;
8965 int res1 = 0 ;
8966 PyObject *swig_obj[1] ;
8967
8968 if (!args) SWIG_fail;
8969 swig_obj[0] = args;
8970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8971 if (!SWIG_IsOK(res1)) {
8972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8973 }
8974 arg1 = reinterpret_cast< wxCaret * >(argp1);
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 (arg1)->Hide();
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 resultobj = SWIG_Py_Void();
8982 return resultobj;
8983 fail:
8984 return NULL;
8985 }
8986
8987
8988 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8989 PyObject *resultobj = 0;
8990 int result;
8991
8992 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8993 {
8994 PyThreadState* __tstate = wxPyBeginAllowThreads();
8995 result = (int)wxCaret::GetBlinkTime();
8996 wxPyEndAllowThreads(__tstate);
8997 if (PyErr_Occurred()) SWIG_fail;
8998 }
8999 resultobj = SWIG_From_int(static_cast< int >(result));
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj = 0;
9008 int arg1 ;
9009 int val1 ;
9010 int ecode1 = 0 ;
9011 PyObject * obj0 = 0 ;
9012 char * kwnames[] = {
9013 (char *) "milliseconds", NULL
9014 };
9015
9016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9017 ecode1 = SWIG_AsVal_int(obj0, &val1);
9018 if (!SWIG_IsOK(ecode1)) {
9019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9020 }
9021 arg1 = static_cast< int >(val1);
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 wxCaret::SetBlinkTime(arg1);
9025 wxPyEndAllowThreads(__tstate);
9026 if (PyErr_Occurred()) SWIG_fail;
9027 }
9028 resultobj = SWIG_Py_Void();
9029 return resultobj;
9030 fail:
9031 return NULL;
9032 }
9033
9034
9035 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9036 PyObject *obj;
9037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9038 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9039 return SWIG_Py_Void();
9040 }
9041
9042 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9043 return SWIG_Python_InitShadowInstance(args);
9044 }
9045
9046 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj = 0;
9048 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9049 wxBusyCursor *result = 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 PyObject * obj0 = 0 ;
9053 char * kwnames[] = {
9054 (char *) "cursor", NULL
9055 };
9056
9057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9058 if (obj0) {
9059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9060 if (!SWIG_IsOK(res1)) {
9061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9062 }
9063 arg1 = reinterpret_cast< wxCursor * >(argp1);
9064 }
9065 {
9066 if (!wxPyCheckForApp()) SWIG_fail;
9067 PyThreadState* __tstate = wxPyBeginAllowThreads();
9068 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9080 PyObject *resultobj = 0;
9081 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9082 void *argp1 = 0 ;
9083 int res1 = 0 ;
9084 PyObject *swig_obj[1] ;
9085
9086 if (!args) SWIG_fail;
9087 swig_obj[0] = args;
9088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9089 if (!SWIG_IsOK(res1)) {
9090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9091 }
9092 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9093 {
9094 PyThreadState* __tstate = wxPyBeginAllowThreads();
9095 delete arg1;
9096
9097 wxPyEndAllowThreads(__tstate);
9098 if (PyErr_Occurred()) SWIG_fail;
9099 }
9100 resultobj = SWIG_Py_Void();
9101 return resultobj;
9102 fail:
9103 return NULL;
9104 }
9105
9106
9107 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9108 PyObject *obj;
9109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9110 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9111 return SWIG_Py_Void();
9112 }
9113
9114 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 return SWIG_Python_InitShadowInstance(args);
9116 }
9117
9118 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9119 PyObject *resultobj = 0;
9120 wxWindow *arg1 = (wxWindow *) NULL ;
9121 wxWindowDisabler *result = 0 ;
9122 void *argp1 = 0 ;
9123 int res1 = 0 ;
9124 PyObject * obj0 = 0 ;
9125 char * kwnames[] = {
9126 (char *) "winToSkip", NULL
9127 };
9128
9129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9130 if (obj0) {
9131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9132 if (!SWIG_IsOK(res1)) {
9133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9134 }
9135 arg1 = reinterpret_cast< wxWindow * >(argp1);
9136 }
9137 {
9138 if (!wxPyCheckForApp()) SWIG_fail;
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9141 wxPyEndAllowThreads(__tstate);
9142 if (PyErr_Occurred()) SWIG_fail;
9143 }
9144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9145 return resultobj;
9146 fail:
9147 return NULL;
9148 }
9149
9150
9151 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9152 PyObject *resultobj = 0;
9153 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9154 void *argp1 = 0 ;
9155 int res1 = 0 ;
9156 PyObject *swig_obj[1] ;
9157
9158 if (!args) SWIG_fail;
9159 swig_obj[0] = args;
9160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9161 if (!SWIG_IsOK(res1)) {
9162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9163 }
9164 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9165 {
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 delete arg1;
9168
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_Py_Void();
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9180 PyObject *obj;
9181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9182 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9183 return SWIG_Py_Void();
9184 }
9185
9186 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9187 return SWIG_Python_InitShadowInstance(args);
9188 }
9189
9190 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9191 PyObject *resultobj = 0;
9192 wxString *arg1 = 0 ;
9193 wxBusyInfo *result = 0 ;
9194 bool temp1 = false ;
9195 PyObject * obj0 = 0 ;
9196 char * kwnames[] = {
9197 (char *) "message", NULL
9198 };
9199
9200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9201 {
9202 arg1 = wxString_in_helper(obj0);
9203 if (arg1 == NULL) SWIG_fail;
9204 temp1 = true;
9205 }
9206 {
9207 if (!wxPyCheckForApp()) SWIG_fail;
9208 PyThreadState* __tstate = wxPyBeginAllowThreads();
9209 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9210 wxPyEndAllowThreads(__tstate);
9211 if (PyErr_Occurred()) SWIG_fail;
9212 }
9213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9214 {
9215 if (temp1)
9216 delete arg1;
9217 }
9218 return resultobj;
9219 fail:
9220 {
9221 if (temp1)
9222 delete arg1;
9223 }
9224 return NULL;
9225 }
9226
9227
9228 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9229 PyObject *resultobj = 0;
9230 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9231 void *argp1 = 0 ;
9232 int res1 = 0 ;
9233 PyObject *swig_obj[1] ;
9234
9235 if (!args) SWIG_fail;
9236 swig_obj[0] = args;
9237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9238 if (!SWIG_IsOK(res1)) {
9239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9240 }
9241 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9242 {
9243 PyThreadState* __tstate = wxPyBeginAllowThreads();
9244 delete arg1;
9245
9246 wxPyEndAllowThreads(__tstate);
9247 if (PyErr_Occurred()) SWIG_fail;
9248 }
9249 resultobj = SWIG_Py_Void();
9250 return resultobj;
9251 fail:
9252 return NULL;
9253 }
9254
9255
9256 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9257 PyObject *obj;
9258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9259 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9260 return SWIG_Py_Void();
9261 }
9262
9263 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9264 return SWIG_Python_InitShadowInstance(args);
9265 }
9266
9267 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9268 PyObject *resultobj = 0;
9269 wxStopWatch *result = 0 ;
9270
9271 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 result = (wxStopWatch *)new wxStopWatch();
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9286 PyObject *resultobj = 0;
9287 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 PyObject *swig_obj[1] ;
9291
9292 if (!args) SWIG_fail;
9293 swig_obj[0] = args;
9294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9295 if (!SWIG_IsOK(res1)) {
9296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9297 }
9298 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9299 {
9300 PyThreadState* __tstate = wxPyBeginAllowThreads();
9301 delete arg1;
9302
9303 wxPyEndAllowThreads(__tstate);
9304 if (PyErr_Occurred()) SWIG_fail;
9305 }
9306 resultobj = SWIG_Py_Void();
9307 return resultobj;
9308 fail:
9309 return NULL;
9310 }
9311
9312
9313 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9314 PyObject *resultobj = 0;
9315 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9316 long arg2 = (long) 0 ;
9317 void *argp1 = 0 ;
9318 int res1 = 0 ;
9319 long val2 ;
9320 int ecode2 = 0 ;
9321 PyObject * obj0 = 0 ;
9322 PyObject * obj1 = 0 ;
9323 char * kwnames[] = {
9324 (char *) "self",(char *) "t0", NULL
9325 };
9326
9327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9329 if (!SWIG_IsOK(res1)) {
9330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9331 }
9332 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9333 if (obj1) {
9334 ecode2 = SWIG_AsVal_long(obj1, &val2);
9335 if (!SWIG_IsOK(ecode2)) {
9336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9337 }
9338 arg2 = static_cast< long >(val2);
9339 }
9340 {
9341 PyThreadState* __tstate = wxPyBeginAllowThreads();
9342 (arg1)->Start(arg2);
9343 wxPyEndAllowThreads(__tstate);
9344 if (PyErr_Occurred()) SWIG_fail;
9345 }
9346 resultobj = SWIG_Py_Void();
9347 return resultobj;
9348 fail:
9349 return NULL;
9350 }
9351
9352
9353 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9354 PyObject *resultobj = 0;
9355 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9356 void *argp1 = 0 ;
9357 int res1 = 0 ;
9358 PyObject *swig_obj[1] ;
9359
9360 if (!args) SWIG_fail;
9361 swig_obj[0] = args;
9362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9363 if (!SWIG_IsOK(res1)) {
9364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9365 }
9366 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9367 {
9368 PyThreadState* __tstate = wxPyBeginAllowThreads();
9369 (arg1)->Pause();
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 resultobj = SWIG_Py_Void();
9374 return resultobj;
9375 fail:
9376 return NULL;
9377 }
9378
9379
9380 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9381 PyObject *resultobj = 0;
9382 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9383 void *argp1 = 0 ;
9384 int res1 = 0 ;
9385 PyObject *swig_obj[1] ;
9386
9387 if (!args) SWIG_fail;
9388 swig_obj[0] = args;
9389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9390 if (!SWIG_IsOK(res1)) {
9391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9392 }
9393 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9394 {
9395 PyThreadState* __tstate = wxPyBeginAllowThreads();
9396 (arg1)->Resume();
9397 wxPyEndAllowThreads(__tstate);
9398 if (PyErr_Occurred()) SWIG_fail;
9399 }
9400 resultobj = SWIG_Py_Void();
9401 return resultobj;
9402 fail:
9403 return NULL;
9404 }
9405
9406
9407 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9408 PyObject *resultobj = 0;
9409 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9410 long result;
9411 void *argp1 = 0 ;
9412 int res1 = 0 ;
9413 PyObject *swig_obj[1] ;
9414
9415 if (!args) SWIG_fail;
9416 swig_obj[0] = args;
9417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9418 if (!SWIG_IsOK(res1)) {
9419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9420 }
9421 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (long)((wxStopWatch const *)arg1)->Time();
9425 wxPyEndAllowThreads(__tstate);
9426 if (PyErr_Occurred()) SWIG_fail;
9427 }
9428 resultobj = SWIG_From_long(static_cast< long >(result));
9429 return resultobj;
9430 fail:
9431 return NULL;
9432 }
9433
9434
9435 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9436 PyObject *obj;
9437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9438 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9439 return SWIG_Py_Void();
9440 }
9441
9442 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9443 return SWIG_Python_InitShadowInstance(args);
9444 }
9445
9446 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9447 PyObject *resultobj = 0;
9448 int arg1 = (int) 9 ;
9449 int arg2 = (int) wxID_FILE1 ;
9450 wxFileHistory *result = 0 ;
9451 int val1 ;
9452 int ecode1 = 0 ;
9453 int val2 ;
9454 int ecode2 = 0 ;
9455 PyObject * obj0 = 0 ;
9456 PyObject * obj1 = 0 ;
9457 char * kwnames[] = {
9458 (char *) "maxFiles",(char *) "idBase", NULL
9459 };
9460
9461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9462 if (obj0) {
9463 ecode1 = SWIG_AsVal_int(obj0, &val1);
9464 if (!SWIG_IsOK(ecode1)) {
9465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9466 }
9467 arg1 = static_cast< int >(val1);
9468 }
9469 if (obj1) {
9470 ecode2 = SWIG_AsVal_int(obj1, &val2);
9471 if (!SWIG_IsOK(ecode2)) {
9472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9473 }
9474 arg2 = static_cast< int >(val2);
9475 }
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9490 PyObject *resultobj = 0;
9491 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 PyObject *swig_obj[1] ;
9495
9496 if (!args) SWIG_fail;
9497 swig_obj[0] = args;
9498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9499 if (!SWIG_IsOK(res1)) {
9500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9501 }
9502 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9503 {
9504 PyThreadState* __tstate = wxPyBeginAllowThreads();
9505 delete arg1;
9506
9507 wxPyEndAllowThreads(__tstate);
9508 if (PyErr_Occurred()) SWIG_fail;
9509 }
9510 resultobj = SWIG_Py_Void();
9511 return resultobj;
9512 fail:
9513 return NULL;
9514 }
9515
9516
9517 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj = 0;
9519 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9520 wxString *arg2 = 0 ;
9521 void *argp1 = 0 ;
9522 int res1 = 0 ;
9523 bool temp2 = false ;
9524 PyObject * obj0 = 0 ;
9525 PyObject * obj1 = 0 ;
9526 char * kwnames[] = {
9527 (char *) "self",(char *) "file", NULL
9528 };
9529
9530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9534 }
9535 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9536 {
9537 arg2 = wxString_in_helper(obj1);
9538 if (arg2 == NULL) SWIG_fail;
9539 temp2 = true;
9540 }
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 (arg1)->AddFileToHistory((wxString const &)*arg2);
9544 wxPyEndAllowThreads(__tstate);
9545 if (PyErr_Occurred()) SWIG_fail;
9546 }
9547 resultobj = SWIG_Py_Void();
9548 {
9549 if (temp2)
9550 delete arg2;
9551 }
9552 return resultobj;
9553 fail:
9554 {
9555 if (temp2)
9556 delete arg2;
9557 }
9558 return NULL;
9559 }
9560
9561
9562 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9563 PyObject *resultobj = 0;
9564 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9565 int arg2 ;
9566 void *argp1 = 0 ;
9567 int res1 = 0 ;
9568 int val2 ;
9569 int ecode2 = 0 ;
9570 PyObject * obj0 = 0 ;
9571 PyObject * obj1 = 0 ;
9572 char * kwnames[] = {
9573 (char *) "self",(char *) "i", NULL
9574 };
9575
9576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9578 if (!SWIG_IsOK(res1)) {
9579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9580 }
9581 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9582 ecode2 = SWIG_AsVal_int(obj1, &val2);
9583 if (!SWIG_IsOK(ecode2)) {
9584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9585 }
9586 arg2 = static_cast< int >(val2);
9587 {
9588 PyThreadState* __tstate = wxPyBeginAllowThreads();
9589 (arg1)->RemoveFileFromHistory(arg2);
9590 wxPyEndAllowThreads(__tstate);
9591 if (PyErr_Occurred()) SWIG_fail;
9592 }
9593 resultobj = SWIG_Py_Void();
9594 return resultobj;
9595 fail:
9596 return NULL;
9597 }
9598
9599
9600 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9601 PyObject *resultobj = 0;
9602 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9603 int result;
9604 void *argp1 = 0 ;
9605 int res1 = 0 ;
9606 PyObject *swig_obj[1] ;
9607
9608 if (!args) SWIG_fail;
9609 swig_obj[0] = args;
9610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9611 if (!SWIG_IsOK(res1)) {
9612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9613 }
9614 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9618 wxPyEndAllowThreads(__tstate);
9619 if (PyErr_Occurred()) SWIG_fail;
9620 }
9621 resultobj = SWIG_From_int(static_cast< int >(result));
9622 return resultobj;
9623 fail:
9624 return NULL;
9625 }
9626
9627
9628 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9629 PyObject *resultobj = 0;
9630 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9631 wxMenu *arg2 = (wxMenu *) 0 ;
9632 void *argp1 = 0 ;
9633 int res1 = 0 ;
9634 void *argp2 = 0 ;
9635 int res2 = 0 ;
9636 PyObject * obj0 = 0 ;
9637 PyObject * obj1 = 0 ;
9638 char * kwnames[] = {
9639 (char *) "self",(char *) "menu", NULL
9640 };
9641
9642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9644 if (!SWIG_IsOK(res1)) {
9645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9646 }
9647 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9648 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9649 if (!SWIG_IsOK(res2)) {
9650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9651 }
9652 arg2 = reinterpret_cast< wxMenu * >(argp2);
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 (arg1)->UseMenu(arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9667 PyObject *resultobj = 0;
9668 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9669 wxMenu *arg2 = (wxMenu *) 0 ;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 void *argp2 = 0 ;
9673 int res2 = 0 ;
9674 PyObject * obj0 = 0 ;
9675 PyObject * obj1 = 0 ;
9676 char * kwnames[] = {
9677 (char *) "self",(char *) "menu", NULL
9678 };
9679
9680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9682 if (!SWIG_IsOK(res1)) {
9683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9684 }
9685 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9686 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9687 if (!SWIG_IsOK(res2)) {
9688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9689 }
9690 arg2 = reinterpret_cast< wxMenu * >(argp2);
9691 {
9692 PyThreadState* __tstate = wxPyBeginAllowThreads();
9693 (arg1)->RemoveMenu(arg2);
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 resultobj = SWIG_Py_Void();
9698 return resultobj;
9699 fail:
9700 return NULL;
9701 }
9702
9703
9704 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj = 0;
9706 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9707 wxConfigBase *arg2 = 0 ;
9708 void *argp1 = 0 ;
9709 int res1 = 0 ;
9710 void *argp2 = 0 ;
9711 int res2 = 0 ;
9712 PyObject * obj0 = 0 ;
9713 PyObject * obj1 = 0 ;
9714 char * kwnames[] = {
9715 (char *) "self",(char *) "config", NULL
9716 };
9717
9718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9720 if (!SWIG_IsOK(res1)) {
9721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9722 }
9723 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9725 if (!SWIG_IsOK(res2)) {
9726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9727 }
9728 if (!argp2) {
9729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9730 }
9731 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 (arg1)->Load(*arg2);
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_Py_Void();
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9746 PyObject *resultobj = 0;
9747 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9748 wxConfigBase *arg2 = 0 ;
9749 void *argp1 = 0 ;
9750 int res1 = 0 ;
9751 void *argp2 = 0 ;
9752 int res2 = 0 ;
9753 PyObject * obj0 = 0 ;
9754 PyObject * obj1 = 0 ;
9755 char * kwnames[] = {
9756 (char *) "self",(char *) "config", NULL
9757 };
9758
9759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9761 if (!SWIG_IsOK(res1)) {
9762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9763 }
9764 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9766 if (!SWIG_IsOK(res2)) {
9767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9768 }
9769 if (!argp2) {
9770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9771 }
9772 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9773 {
9774 PyThreadState* __tstate = wxPyBeginAllowThreads();
9775 (arg1)->Save(*arg2);
9776 wxPyEndAllowThreads(__tstate);
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 resultobj = SWIG_Py_Void();
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9787 PyObject *resultobj = 0;
9788 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9789 void *argp1 = 0 ;
9790 int res1 = 0 ;
9791 PyObject *swig_obj[1] ;
9792
9793 if (!args) SWIG_fail;
9794 swig_obj[0] = args;
9795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9796 if (!SWIG_IsOK(res1)) {
9797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9798 }
9799 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 (arg1)->AddFilesToMenu();
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 resultobj = SWIG_Py_Void();
9807 return resultobj;
9808 fail:
9809 return NULL;
9810 }
9811
9812
9813 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9814 PyObject *resultobj = 0;
9815 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9816 wxMenu *arg2 = (wxMenu *) 0 ;
9817 void *argp1 = 0 ;
9818 int res1 = 0 ;
9819 void *argp2 = 0 ;
9820 int res2 = 0 ;
9821 PyObject * obj0 = 0 ;
9822 PyObject * obj1 = 0 ;
9823 char * kwnames[] = {
9824 (char *) "self",(char *) "menu", NULL
9825 };
9826
9827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9829 if (!SWIG_IsOK(res1)) {
9830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9831 }
9832 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9834 if (!SWIG_IsOK(res2)) {
9835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9836 }
9837 arg2 = reinterpret_cast< wxMenu * >(argp2);
9838 {
9839 PyThreadState* __tstate = wxPyBeginAllowThreads();
9840 (arg1)->AddFilesToMenu(arg2);
9841 wxPyEndAllowThreads(__tstate);
9842 if (PyErr_Occurred()) SWIG_fail;
9843 }
9844 resultobj = SWIG_Py_Void();
9845 return resultobj;
9846 fail:
9847 return NULL;
9848 }
9849
9850
9851 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9852 PyObject *resultobj = 0;
9853 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9854 int arg2 ;
9855 wxString result;
9856 void *argp1 = 0 ;
9857 int res1 = 0 ;
9858 int val2 ;
9859 int ecode2 = 0 ;
9860 PyObject * obj0 = 0 ;
9861 PyObject * obj1 = 0 ;
9862 char * kwnames[] = {
9863 (char *) "self",(char *) "i", NULL
9864 };
9865
9866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9868 if (!SWIG_IsOK(res1)) {
9869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9870 }
9871 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9872 ecode2 = SWIG_AsVal_int(obj1, &val2);
9873 if (!SWIG_IsOK(ecode2)) {
9874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9875 }
9876 arg2 = static_cast< int >(val2);
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9880 wxPyEndAllowThreads(__tstate);
9881 if (PyErr_Occurred()) SWIG_fail;
9882 }
9883 {
9884 #if wxUSE_UNICODE
9885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9886 #else
9887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9888 #endif
9889 }
9890 return resultobj;
9891 fail:
9892 return NULL;
9893 }
9894
9895
9896 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9897 PyObject *resultobj = 0;
9898 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9899 int result;
9900 void *argp1 = 0 ;
9901 int res1 = 0 ;
9902 PyObject *swig_obj[1] ;
9903
9904 if (!args) SWIG_fail;
9905 swig_obj[0] = args;
9906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9909 }
9910 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 result = (int)((wxFileHistory const *)arg1)->GetCount();
9914 wxPyEndAllowThreads(__tstate);
9915 if (PyErr_Occurred()) SWIG_fail;
9916 }
9917 resultobj = SWIG_From_int(static_cast< int >(result));
9918 return resultobj;
9919 fail:
9920 return NULL;
9921 }
9922
9923
9924 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9925 PyObject *obj;
9926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9927 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9928 return SWIG_Py_Void();
9929 }
9930
9931 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9932 return SWIG_Python_InitShadowInstance(args);
9933 }
9934
9935 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj = 0;
9937 wxString *arg1 = 0 ;
9938 wxString const &arg2_defvalue = wxPyEmptyString ;
9939 wxString *arg2 = (wxString *) &arg2_defvalue ;
9940 wxSingleInstanceChecker *result = 0 ;
9941 bool temp1 = false ;
9942 bool temp2 = false ;
9943 PyObject * obj0 = 0 ;
9944 PyObject * obj1 = 0 ;
9945 char * kwnames[] = {
9946 (char *) "name",(char *) "path", NULL
9947 };
9948
9949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9950 {
9951 arg1 = wxString_in_helper(obj0);
9952 if (arg1 == NULL) SWIG_fail;
9953 temp1 = true;
9954 }
9955 if (obj1) {
9956 {
9957 arg2 = wxString_in_helper(obj1);
9958 if (arg2 == NULL) SWIG_fail;
9959 temp2 = true;
9960 }
9961 }
9962 {
9963 PyThreadState* __tstate = wxPyBeginAllowThreads();
9964 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9965 wxPyEndAllowThreads(__tstate);
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9969 {
9970 if (temp1)
9971 delete arg1;
9972 }
9973 {
9974 if (temp2)
9975 delete arg2;
9976 }
9977 return resultobj;
9978 fail:
9979 {
9980 if (temp1)
9981 delete arg1;
9982 }
9983 {
9984 if (temp2)
9985 delete arg2;
9986 }
9987 return NULL;
9988 }
9989
9990
9991 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9992 PyObject *resultobj = 0;
9993 wxSingleInstanceChecker *result = 0 ;
9994
9995 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9999 wxPyEndAllowThreads(__tstate);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10010 PyObject *resultobj = 0;
10011 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10012 void *argp1 = 0 ;
10013 int res1 = 0 ;
10014 PyObject *swig_obj[1] ;
10015
10016 if (!args) SWIG_fail;
10017 swig_obj[0] = args;
10018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10019 if (!SWIG_IsOK(res1)) {
10020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10021 }
10022 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10023 {
10024 PyThreadState* __tstate = wxPyBeginAllowThreads();
10025 delete arg1;
10026
10027 wxPyEndAllowThreads(__tstate);
10028 if (PyErr_Occurred()) SWIG_fail;
10029 }
10030 resultobj = SWIG_Py_Void();
10031 return resultobj;
10032 fail:
10033 return NULL;
10034 }
10035
10036
10037 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj = 0;
10039 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10040 wxString *arg2 = 0 ;
10041 wxString const &arg3_defvalue = wxPyEmptyString ;
10042 wxString *arg3 = (wxString *) &arg3_defvalue ;
10043 bool result;
10044 void *argp1 = 0 ;
10045 int res1 = 0 ;
10046 bool temp2 = false ;
10047 bool temp3 = false ;
10048 PyObject * obj0 = 0 ;
10049 PyObject * obj1 = 0 ;
10050 PyObject * obj2 = 0 ;
10051 char * kwnames[] = {
10052 (char *) "self",(char *) "name",(char *) "path", NULL
10053 };
10054
10055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10057 if (!SWIG_IsOK(res1)) {
10058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10059 }
10060 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10061 {
10062 arg2 = wxString_in_helper(obj1);
10063 if (arg2 == NULL) SWIG_fail;
10064 temp2 = true;
10065 }
10066 if (obj2) {
10067 {
10068 arg3 = wxString_in_helper(obj2);
10069 if (arg3 == NULL) SWIG_fail;
10070 temp3 = true;
10071 }
10072 }
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10076 wxPyEndAllowThreads(__tstate);
10077 if (PyErr_Occurred()) SWIG_fail;
10078 }
10079 {
10080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10081 }
10082 {
10083 if (temp2)
10084 delete arg2;
10085 }
10086 {
10087 if (temp3)
10088 delete arg3;
10089 }
10090 return resultobj;
10091 fail:
10092 {
10093 if (temp2)
10094 delete arg2;
10095 }
10096 {
10097 if (temp3)
10098 delete arg3;
10099 }
10100 return NULL;
10101 }
10102
10103
10104 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10105 PyObject *resultobj = 0;
10106 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10107 bool result;
10108 void *argp1 = 0 ;
10109 int res1 = 0 ;
10110 PyObject *swig_obj[1] ;
10111
10112 if (!args) SWIG_fail;
10113 swig_obj[0] = args;
10114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10115 if (!SWIG_IsOK(res1)) {
10116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10117 }
10118 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10119 {
10120 PyThreadState* __tstate = wxPyBeginAllowThreads();
10121 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10122 wxPyEndAllowThreads(__tstate);
10123 if (PyErr_Occurred()) SWIG_fail;
10124 }
10125 {
10126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10127 }
10128 return resultobj;
10129 fail:
10130 return NULL;
10131 }
10132
10133
10134 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10135 PyObject *obj;
10136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10137 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10138 return SWIG_Py_Void();
10139 }
10140
10141 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10142 return SWIG_Python_InitShadowInstance(args);
10143 }
10144
10145 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10146 PyObject *resultobj = 0;
10147 wxPlatformInfo *result = 0 ;
10148
10149 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10150 {
10151 PyThreadState* __tstate = wxPyBeginAllowThreads();
10152 result = (wxPlatformInfo *)new wxPlatformInfo();
10153 wxPyEndAllowThreads(__tstate);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10166 wxPlatformInfo *arg2 = 0 ;
10167 bool result;
10168 void *argp1 = 0 ;
10169 int res1 = 0 ;
10170 void *argp2 = 0 ;
10171 int res2 = 0 ;
10172 PyObject * obj0 = 0 ;
10173 PyObject * obj1 = 0 ;
10174 char * kwnames[] = {
10175 (char *) "self",(char *) "t", NULL
10176 };
10177
10178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10180 if (!SWIG_IsOK(res1)) {
10181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10182 }
10183 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10184 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10185 if (!SWIG_IsOK(res2)) {
10186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10187 }
10188 if (!argp2) {
10189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10190 }
10191 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10192 {
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10195 wxPyEndAllowThreads(__tstate);
10196 if (PyErr_Occurred()) SWIG_fail;
10197 }
10198 {
10199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10200 }
10201 return resultobj;
10202 fail:
10203 return NULL;
10204 }
10205
10206
10207 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10208 PyObject *resultobj = 0;
10209 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10210 wxPlatformInfo *arg2 = 0 ;
10211 bool result;
10212 void *argp1 = 0 ;
10213 int res1 = 0 ;
10214 void *argp2 = 0 ;
10215 int res2 = 0 ;
10216 PyObject * obj0 = 0 ;
10217 PyObject * obj1 = 0 ;
10218 char * kwnames[] = {
10219 (char *) "self",(char *) "t", NULL
10220 };
10221
10222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10224 if (!SWIG_IsOK(res1)) {
10225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10226 }
10227 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10228 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10229 if (!SWIG_IsOK(res2)) {
10230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10231 }
10232 if (!argp2) {
10233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10234 }
10235 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10236 {
10237 PyThreadState* __tstate = wxPyBeginAllowThreads();
10238 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10239 wxPyEndAllowThreads(__tstate);
10240 if (PyErr_Occurred()) SWIG_fail;
10241 }
10242 {
10243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10244 }
10245 return resultobj;
10246 fail:
10247 return NULL;
10248 }
10249
10250
10251 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10252 PyObject *resultobj = 0;
10253 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10254 int result;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 PyObject *swig_obj[1] ;
10258
10259 if (!args) SWIG_fail;
10260 swig_obj[0] = args;
10261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10262 if (!SWIG_IsOK(res1)) {
10263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10264 }
10265 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10266 {
10267 PyThreadState* __tstate = wxPyBeginAllowThreads();
10268 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10269 wxPyEndAllowThreads(__tstate);
10270 if (PyErr_Occurred()) SWIG_fail;
10271 }
10272 resultobj = SWIG_From_int(static_cast< int >(result));
10273 return resultobj;
10274 fail:
10275 return NULL;
10276 }
10277
10278
10279 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10280 PyObject *resultobj = 0;
10281 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10282 int result;
10283 void *argp1 = 0 ;
10284 int res1 = 0 ;
10285 PyObject *swig_obj[1] ;
10286
10287 if (!args) SWIG_fail;
10288 swig_obj[0] = args;
10289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10290 if (!SWIG_IsOK(res1)) {
10291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10292 }
10293 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10294 {
10295 PyThreadState* __tstate = wxPyBeginAllowThreads();
10296 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10297 wxPyEndAllowThreads(__tstate);
10298 if (PyErr_Occurred()) SWIG_fail;
10299 }
10300 resultobj = SWIG_From_int(static_cast< int >(result));
10301 return resultobj;
10302 fail:
10303 return NULL;
10304 }
10305
10306
10307 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj = 0;
10309 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10310 int arg2 ;
10311 int arg3 ;
10312 bool result;
10313 void *argp1 = 0 ;
10314 int res1 = 0 ;
10315 int val2 ;
10316 int ecode2 = 0 ;
10317 int val3 ;
10318 int ecode3 = 0 ;
10319 PyObject * obj0 = 0 ;
10320 PyObject * obj1 = 0 ;
10321 PyObject * obj2 = 0 ;
10322 char * kwnames[] = {
10323 (char *) "self",(char *) "major",(char *) "minor", NULL
10324 };
10325
10326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10328 if (!SWIG_IsOK(res1)) {
10329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10330 }
10331 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10332 ecode2 = SWIG_AsVal_int(obj1, &val2);
10333 if (!SWIG_IsOK(ecode2)) {
10334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10335 }
10336 arg2 = static_cast< int >(val2);
10337 ecode3 = SWIG_AsVal_int(obj2, &val3);
10338 if (!SWIG_IsOK(ecode3)) {
10339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10340 }
10341 arg3 = static_cast< int >(val3);
10342 {
10343 PyThreadState* __tstate = wxPyBeginAllowThreads();
10344 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10345 wxPyEndAllowThreads(__tstate);
10346 if (PyErr_Occurred()) SWIG_fail;
10347 }
10348 {
10349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10350 }
10351 return resultobj;
10352 fail:
10353 return NULL;
10354 }
10355
10356
10357 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10358 PyObject *resultobj = 0;
10359 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10360 int result;
10361 void *argp1 = 0 ;
10362 int res1 = 0 ;
10363 PyObject *swig_obj[1] ;
10364
10365 if (!args) SWIG_fail;
10366 swig_obj[0] = args;
10367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10368 if (!SWIG_IsOK(res1)) {
10369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10370 }
10371 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10372 {
10373 PyThreadState* __tstate = wxPyBeginAllowThreads();
10374 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 resultobj = SWIG_From_int(static_cast< int >(result));
10379 return resultobj;
10380 fail:
10381 return NULL;
10382 }
10383
10384
10385 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10386 PyObject *resultobj = 0;
10387 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10388 int result;
10389 void *argp1 = 0 ;
10390 int res1 = 0 ;
10391 PyObject *swig_obj[1] ;
10392
10393 if (!args) SWIG_fail;
10394 swig_obj[0] = args;
10395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10396 if (!SWIG_IsOK(res1)) {
10397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10398 }
10399 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10400 {
10401 PyThreadState* __tstate = wxPyBeginAllowThreads();
10402 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10403 wxPyEndAllowThreads(__tstate);
10404 if (PyErr_Occurred()) SWIG_fail;
10405 }
10406 resultobj = SWIG_From_int(static_cast< int >(result));
10407 return resultobj;
10408 fail:
10409 return NULL;
10410 }
10411
10412
10413 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10414 PyObject *resultobj = 0;
10415 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10416 int arg2 ;
10417 int arg3 ;
10418 bool result;
10419 void *argp1 = 0 ;
10420 int res1 = 0 ;
10421 int val2 ;
10422 int ecode2 = 0 ;
10423 int val3 ;
10424 int ecode3 = 0 ;
10425 PyObject * obj0 = 0 ;
10426 PyObject * obj1 = 0 ;
10427 PyObject * obj2 = 0 ;
10428 char * kwnames[] = {
10429 (char *) "self",(char *) "major",(char *) "minor", NULL
10430 };
10431
10432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10434 if (!SWIG_IsOK(res1)) {
10435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10436 }
10437 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10438 ecode2 = SWIG_AsVal_int(obj1, &val2);
10439 if (!SWIG_IsOK(ecode2)) {
10440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10441 }
10442 arg2 = static_cast< int >(val2);
10443 ecode3 = SWIG_AsVal_int(obj2, &val3);
10444 if (!SWIG_IsOK(ecode3)) {
10445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10446 }
10447 arg3 = static_cast< int >(val3);
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10451 wxPyEndAllowThreads(__tstate);
10452 if (PyErr_Occurred()) SWIG_fail;
10453 }
10454 {
10455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10456 }
10457 return resultobj;
10458 fail:
10459 return NULL;
10460 }
10461
10462
10463 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10464 PyObject *resultobj = 0;
10465 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10466 bool result;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 PyObject *swig_obj[1] ;
10470
10471 if (!args) SWIG_fail;
10472 swig_obj[0] = args;
10473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10474 if (!SWIG_IsOK(res1)) {
10475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10476 }
10477 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10478 {
10479 PyThreadState* __tstate = wxPyBeginAllowThreads();
10480 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 {
10485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10486 }
10487 return resultobj;
10488 fail:
10489 return NULL;
10490 }
10491
10492
10493 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10494 PyObject *resultobj = 0;
10495 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10496 wxOperatingSystemId result;
10497 void *argp1 = 0 ;
10498 int res1 = 0 ;
10499 PyObject *swig_obj[1] ;
10500
10501 if (!args) SWIG_fail;
10502 swig_obj[0] = args;
10503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10504 if (!SWIG_IsOK(res1)) {
10505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10506 }
10507 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10511 wxPyEndAllowThreads(__tstate);
10512 if (PyErr_Occurred()) SWIG_fail;
10513 }
10514 resultobj = SWIG_From_int(static_cast< int >(result));
10515 return resultobj;
10516 fail:
10517 return NULL;
10518 }
10519
10520
10521 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10522 PyObject *resultobj = 0;
10523 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10524 wxPortId result;
10525 void *argp1 = 0 ;
10526 int res1 = 0 ;
10527 PyObject *swig_obj[1] ;
10528
10529 if (!args) SWIG_fail;
10530 swig_obj[0] = args;
10531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10534 }
10535 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10536 {
10537 PyThreadState* __tstate = wxPyBeginAllowThreads();
10538 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10539 wxPyEndAllowThreads(__tstate);
10540 if (PyErr_Occurred()) SWIG_fail;
10541 }
10542 resultobj = SWIG_From_int(static_cast< int >(result));
10543 return resultobj;
10544 fail:
10545 return NULL;
10546 }
10547
10548
10549 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10550 PyObject *resultobj = 0;
10551 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10552 wxArchitecture result;
10553 void *argp1 = 0 ;
10554 int res1 = 0 ;
10555 PyObject *swig_obj[1] ;
10556
10557 if (!args) SWIG_fail;
10558 swig_obj[0] = args;
10559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10560 if (!SWIG_IsOK(res1)) {
10561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10562 }
10563 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10564 {
10565 PyThreadState* __tstate = wxPyBeginAllowThreads();
10566 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10567 wxPyEndAllowThreads(__tstate);
10568 if (PyErr_Occurred()) SWIG_fail;
10569 }
10570 resultobj = SWIG_From_int(static_cast< int >(result));
10571 return resultobj;
10572 fail:
10573 return NULL;
10574 }
10575
10576
10577 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10578 PyObject *resultobj = 0;
10579 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10580 wxEndianness result;
10581 void *argp1 = 0 ;
10582 int res1 = 0 ;
10583 PyObject *swig_obj[1] ;
10584
10585 if (!args) SWIG_fail;
10586 swig_obj[0] = args;
10587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10588 if (!SWIG_IsOK(res1)) {
10589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10590 }
10591 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10592 {
10593 PyThreadState* __tstate = wxPyBeginAllowThreads();
10594 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10595 wxPyEndAllowThreads(__tstate);
10596 if (PyErr_Occurred()) SWIG_fail;
10597 }
10598 resultobj = SWIG_From_int(static_cast< int >(result));
10599 return resultobj;
10600 fail:
10601 return NULL;
10602 }
10603
10604
10605 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10606 PyObject *resultobj = 0;
10607 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10608 wxString result;
10609 void *argp1 = 0 ;
10610 int res1 = 0 ;
10611 PyObject *swig_obj[1] ;
10612
10613 if (!args) SWIG_fail;
10614 swig_obj[0] = args;
10615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10616 if (!SWIG_IsOK(res1)) {
10617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10618 }
10619 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10623 wxPyEndAllowThreads(__tstate);
10624 if (PyErr_Occurred()) SWIG_fail;
10625 }
10626 {
10627 #if wxUSE_UNICODE
10628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10629 #else
10630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10631 #endif
10632 }
10633 return resultobj;
10634 fail:
10635 return NULL;
10636 }
10637
10638
10639 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10640 PyObject *resultobj = 0;
10641 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10642 wxString result;
10643 void *argp1 = 0 ;
10644 int res1 = 0 ;
10645 PyObject *swig_obj[1] ;
10646
10647 if (!args) SWIG_fail;
10648 swig_obj[0] = args;
10649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10650 if (!SWIG_IsOK(res1)) {
10651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10652 }
10653 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10654 {
10655 PyThreadState* __tstate = wxPyBeginAllowThreads();
10656 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10657 wxPyEndAllowThreads(__tstate);
10658 if (PyErr_Occurred()) SWIG_fail;
10659 }
10660 {
10661 #if wxUSE_UNICODE
10662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10663 #else
10664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10665 #endif
10666 }
10667 return resultobj;
10668 fail:
10669 return NULL;
10670 }
10671
10672
10673 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10674 PyObject *resultobj = 0;
10675 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10676 wxString result;
10677 void *argp1 = 0 ;
10678 int res1 = 0 ;
10679 PyObject *swig_obj[1] ;
10680
10681 if (!args) SWIG_fail;
10682 swig_obj[0] = args;
10683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10684 if (!SWIG_IsOK(res1)) {
10685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10686 }
10687 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10688 {
10689 PyThreadState* __tstate = wxPyBeginAllowThreads();
10690 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10691 wxPyEndAllowThreads(__tstate);
10692 if (PyErr_Occurred()) SWIG_fail;
10693 }
10694 {
10695 #if wxUSE_UNICODE
10696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10697 #else
10698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10699 #endif
10700 }
10701 return resultobj;
10702 fail:
10703 return NULL;
10704 }
10705
10706
10707 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10708 PyObject *resultobj = 0;
10709 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10710 wxString result;
10711 void *argp1 = 0 ;
10712 int res1 = 0 ;
10713 PyObject *swig_obj[1] ;
10714
10715 if (!args) SWIG_fail;
10716 swig_obj[0] = args;
10717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10718 if (!SWIG_IsOK(res1)) {
10719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10720 }
10721 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10722 {
10723 PyThreadState* __tstate = wxPyBeginAllowThreads();
10724 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10725 wxPyEndAllowThreads(__tstate);
10726 if (PyErr_Occurred()) SWIG_fail;
10727 }
10728 {
10729 #if wxUSE_UNICODE
10730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10731 #else
10732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10733 #endif
10734 }
10735 return resultobj;
10736 fail:
10737 return NULL;
10738 }
10739
10740
10741 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10742 PyObject *resultobj = 0;
10743 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10744 wxString result;
10745 void *argp1 = 0 ;
10746 int res1 = 0 ;
10747 PyObject *swig_obj[1] ;
10748
10749 if (!args) SWIG_fail;
10750 swig_obj[0] = args;
10751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10752 if (!SWIG_IsOK(res1)) {
10753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10754 }
10755 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10756 {
10757 PyThreadState* __tstate = wxPyBeginAllowThreads();
10758 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10759 wxPyEndAllowThreads(__tstate);
10760 if (PyErr_Occurred()) SWIG_fail;
10761 }
10762 {
10763 #if wxUSE_UNICODE
10764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10765 #else
10766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10767 #endif
10768 }
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10776 PyObject *resultobj = 0;
10777 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10778 wxString result;
10779 void *argp1 = 0 ;
10780 int res1 = 0 ;
10781 PyObject *swig_obj[1] ;
10782
10783 if (!args) SWIG_fail;
10784 swig_obj[0] = args;
10785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10786 if (!SWIG_IsOK(res1)) {
10787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10788 }
10789 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10790 {
10791 PyThreadState* __tstate = wxPyBeginAllowThreads();
10792 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 {
10797 #if wxUSE_UNICODE
10798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10799 #else
10800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10801 #endif
10802 }
10803 return resultobj;
10804 fail:
10805 return NULL;
10806 }
10807
10808
10809 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10810 PyObject *resultobj = 0;
10811 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10812 int arg2 ;
10813 int arg3 ;
10814 void *argp1 = 0 ;
10815 int res1 = 0 ;
10816 int val2 ;
10817 int ecode2 = 0 ;
10818 int val3 ;
10819 int ecode3 = 0 ;
10820 PyObject * obj0 = 0 ;
10821 PyObject * obj1 = 0 ;
10822 PyObject * obj2 = 0 ;
10823 char * kwnames[] = {
10824 (char *) "self",(char *) "major",(char *) "minor", NULL
10825 };
10826
10827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10829 if (!SWIG_IsOK(res1)) {
10830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10831 }
10832 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10833 ecode2 = SWIG_AsVal_int(obj1, &val2);
10834 if (!SWIG_IsOK(ecode2)) {
10835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10836 }
10837 arg2 = static_cast< int >(val2);
10838 ecode3 = SWIG_AsVal_int(obj2, &val3);
10839 if (!SWIG_IsOK(ecode3)) {
10840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10841 }
10842 arg3 = static_cast< int >(val3);
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 (arg1)->SetOSVersion(arg2,arg3);
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 resultobj = SWIG_Py_Void();
10850 return resultobj;
10851 fail:
10852 return NULL;
10853 }
10854
10855
10856 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj = 0;
10858 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10859 int arg2 ;
10860 int arg3 ;
10861 void *argp1 = 0 ;
10862 int res1 = 0 ;
10863 int val2 ;
10864 int ecode2 = 0 ;
10865 int val3 ;
10866 int ecode3 = 0 ;
10867 PyObject * obj0 = 0 ;
10868 PyObject * obj1 = 0 ;
10869 PyObject * obj2 = 0 ;
10870 char * kwnames[] = {
10871 (char *) "self",(char *) "major",(char *) "minor", NULL
10872 };
10873
10874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10876 if (!SWIG_IsOK(res1)) {
10877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10878 }
10879 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10880 ecode2 = SWIG_AsVal_int(obj1, &val2);
10881 if (!SWIG_IsOK(ecode2)) {
10882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10883 }
10884 arg2 = static_cast< int >(val2);
10885 ecode3 = SWIG_AsVal_int(obj2, &val3);
10886 if (!SWIG_IsOK(ecode3)) {
10887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10888 }
10889 arg3 = static_cast< int >(val3);
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 (arg1)->SetToolkitVersion(arg2,arg3);
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = SWIG_Py_Void();
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj = 0;
10905 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10906 wxOperatingSystemId arg2 ;
10907 void *argp1 = 0 ;
10908 int res1 = 0 ;
10909 int val2 ;
10910 int ecode2 = 0 ;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 char * kwnames[] = {
10914 (char *) "self",(char *) "n", NULL
10915 };
10916
10917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10919 if (!SWIG_IsOK(res1)) {
10920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10921 }
10922 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10923 ecode2 = SWIG_AsVal_int(obj1, &val2);
10924 if (!SWIG_IsOK(ecode2)) {
10925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10926 }
10927 arg2 = static_cast< wxOperatingSystemId >(val2);
10928 {
10929 PyThreadState* __tstate = wxPyBeginAllowThreads();
10930 (arg1)->SetOperatingSystemId(arg2);
10931 wxPyEndAllowThreads(__tstate);
10932 if (PyErr_Occurred()) SWIG_fail;
10933 }
10934 resultobj = SWIG_Py_Void();
10935 return resultobj;
10936 fail:
10937 return NULL;
10938 }
10939
10940
10941 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10942 PyObject *resultobj = 0;
10943 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10944 wxPortId arg2 ;
10945 void *argp1 = 0 ;
10946 int res1 = 0 ;
10947 int val2 ;
10948 int ecode2 = 0 ;
10949 PyObject * obj0 = 0 ;
10950 PyObject * obj1 = 0 ;
10951 char * kwnames[] = {
10952 (char *) "self",(char *) "n", NULL
10953 };
10954
10955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10957 if (!SWIG_IsOK(res1)) {
10958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10959 }
10960 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10961 ecode2 = SWIG_AsVal_int(obj1, &val2);
10962 if (!SWIG_IsOK(ecode2)) {
10963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10964 }
10965 arg2 = static_cast< wxPortId >(val2);
10966 {
10967 PyThreadState* __tstate = wxPyBeginAllowThreads();
10968 (arg1)->SetPortId(arg2);
10969 wxPyEndAllowThreads(__tstate);
10970 if (PyErr_Occurred()) SWIG_fail;
10971 }
10972 resultobj = SWIG_Py_Void();
10973 return resultobj;
10974 fail:
10975 return NULL;
10976 }
10977
10978
10979 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10980 PyObject *resultobj = 0;
10981 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10982 wxArchitecture arg2 ;
10983 void *argp1 = 0 ;
10984 int res1 = 0 ;
10985 int val2 ;
10986 int ecode2 = 0 ;
10987 PyObject * obj0 = 0 ;
10988 PyObject * obj1 = 0 ;
10989 char * kwnames[] = {
10990 (char *) "self",(char *) "n", NULL
10991 };
10992
10993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10995 if (!SWIG_IsOK(res1)) {
10996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10997 }
10998 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10999 ecode2 = SWIG_AsVal_int(obj1, &val2);
11000 if (!SWIG_IsOK(ecode2)) {
11001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11002 }
11003 arg2 = static_cast< wxArchitecture >(val2);
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 (arg1)->SetArchitecture(arg2);
11007 wxPyEndAllowThreads(__tstate);
11008 if (PyErr_Occurred()) SWIG_fail;
11009 }
11010 resultobj = SWIG_Py_Void();
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11018 PyObject *resultobj = 0;
11019 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11020 wxEndianness arg2 ;
11021 void *argp1 = 0 ;
11022 int res1 = 0 ;
11023 int val2 ;
11024 int ecode2 = 0 ;
11025 PyObject * obj0 = 0 ;
11026 PyObject * obj1 = 0 ;
11027 char * kwnames[] = {
11028 (char *) "self",(char *) "n", NULL
11029 };
11030
11031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11033 if (!SWIG_IsOK(res1)) {
11034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11035 }
11036 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11037 ecode2 = SWIG_AsVal_int(obj1, &val2);
11038 if (!SWIG_IsOK(ecode2)) {
11039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11040 }
11041 arg2 = static_cast< wxEndianness >(val2);
11042 {
11043 PyThreadState* __tstate = wxPyBeginAllowThreads();
11044 (arg1)->SetEndianness(arg2);
11045 wxPyEndAllowThreads(__tstate);
11046 if (PyErr_Occurred()) SWIG_fail;
11047 }
11048 resultobj = SWIG_Py_Void();
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 PyObject *resultobj = 0;
11057 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11058 bool result;
11059 void *argp1 = 0 ;
11060 int res1 = 0 ;
11061 PyObject *swig_obj[1] ;
11062
11063 if (!args) SWIG_fail;
11064 swig_obj[0] = args;
11065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11066 if (!SWIG_IsOK(res1)) {
11067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11068 }
11069 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11070 {
11071 PyThreadState* __tstate = wxPyBeginAllowThreads();
11072 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11073 wxPyEndAllowThreads(__tstate);
11074 if (PyErr_Occurred()) SWIG_fail;
11075 }
11076 {
11077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11078 }
11079 return resultobj;
11080 fail:
11081 return NULL;
11082 }
11083
11084
11085 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11086 PyObject *obj;
11087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11088 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11089 return SWIG_Py_Void();
11090 }
11091
11092 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11093 return SWIG_Python_InitShadowInstance(args);
11094 }
11095
11096 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11097 PyObject *resultobj = 0;
11098 wxWindow *arg1 = (wxWindow *) 0 ;
11099 wxDC *arg2 = 0 ;
11100 bool result;
11101 void *argp1 = 0 ;
11102 int res1 = 0 ;
11103 void *argp2 = 0 ;
11104 int res2 = 0 ;
11105 PyObject * obj0 = 0 ;
11106 PyObject * obj1 = 0 ;
11107 char * kwnames[] = {
11108 (char *) "window",(char *) "dc", NULL
11109 };
11110
11111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11113 if (!SWIG_IsOK(res1)) {
11114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11115 }
11116 arg1 = reinterpret_cast< wxWindow * >(argp1);
11117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11118 if (!SWIG_IsOK(res2)) {
11119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11120 }
11121 if (!argp2) {
11122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11123 }
11124 arg2 = reinterpret_cast< wxDC * >(argp2);
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 {
11132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11133 }
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11143 void *argp1 = 0 ;
11144 int res1 = 0 ;
11145 PyObject *swig_obj[1] ;
11146
11147 if (!args) SWIG_fail;
11148 swig_obj[0] = args;
11149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11150 if (!SWIG_IsOK(res1)) {
11151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11152 }
11153 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11154 {
11155 PyThreadState* __tstate = wxPyBeginAllowThreads();
11156 delete arg1;
11157
11158 wxPyEndAllowThreads(__tstate);
11159 if (PyErr_Occurred()) SWIG_fail;
11160 }
11161 resultobj = SWIG_Py_Void();
11162 return resultobj;
11163 fail:
11164 return NULL;
11165 }
11166
11167
11168 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11169 PyObject *resultobj = 0;
11170 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11171 wxString result;
11172 void *argp1 = 0 ;
11173 int res1 = 0 ;
11174 PyObject *swig_obj[1] ;
11175
11176 if (!args) SWIG_fail;
11177 swig_obj[0] = args;
11178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11179 if (!SWIG_IsOK(res1)) {
11180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11181 }
11182 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (arg1)->GetTip();
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 {
11190 #if wxUSE_UNICODE
11191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11192 #else
11193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11194 #endif
11195 }
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11203 PyObject *resultobj = 0;
11204 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11205 size_t result;
11206 void *argp1 = 0 ;
11207 int res1 = 0 ;
11208 PyObject *swig_obj[1] ;
11209
11210 if (!args) SWIG_fail;
11211 swig_obj[0] = args;
11212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11213 if (!SWIG_IsOK(res1)) {
11214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11215 }
11216 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11217 {
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 result = (size_t)(arg1)->GetCurrentTip();
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11231 PyObject *resultobj = 0;
11232 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11233 wxString *arg2 = 0 ;
11234 wxString result;
11235 void *argp1 = 0 ;
11236 int res1 = 0 ;
11237 bool temp2 = false ;
11238 PyObject * obj0 = 0 ;
11239 PyObject * obj1 = 0 ;
11240 char * kwnames[] = {
11241 (char *) "self",(char *) "tip", NULL
11242 };
11243
11244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11246 if (!SWIG_IsOK(res1)) {
11247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11248 }
11249 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11250 {
11251 arg2 = wxString_in_helper(obj1);
11252 if (arg2 == NULL) SWIG_fail;
11253 temp2 = true;
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11258 wxPyEndAllowThreads(__tstate);
11259 if (PyErr_Occurred()) SWIG_fail;
11260 }
11261 {
11262 #if wxUSE_UNICODE
11263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11264 #else
11265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11266 #endif
11267 }
11268 {
11269 if (temp2)
11270 delete arg2;
11271 }
11272 return resultobj;
11273 fail:
11274 {
11275 if (temp2)
11276 delete arg2;
11277 }
11278 return NULL;
11279 }
11280
11281
11282 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11283 PyObject *obj;
11284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11285 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11286 return SWIG_Py_Void();
11287 }
11288
11289 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11290 PyObject *resultobj = 0;
11291 size_t arg1 ;
11292 wxPyTipProvider *result = 0 ;
11293 size_t val1 ;
11294 int ecode1 = 0 ;
11295 PyObject * obj0 = 0 ;
11296 char * kwnames[] = {
11297 (char *) "currentTip", NULL
11298 };
11299
11300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11301 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11302 if (!SWIG_IsOK(ecode1)) {
11303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11304 }
11305 arg1 = static_cast< size_t >(val1);
11306 {
11307 PyThreadState* __tstate = wxPyBeginAllowThreads();
11308 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11313 return resultobj;
11314 fail:
11315 return NULL;
11316 }
11317
11318
11319 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj = 0;
11321 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11322 PyObject *arg2 = (PyObject *) 0 ;
11323 PyObject *arg3 = (PyObject *) 0 ;
11324 void *argp1 = 0 ;
11325 int res1 = 0 ;
11326 PyObject * obj0 = 0 ;
11327 PyObject * obj1 = 0 ;
11328 PyObject * obj2 = 0 ;
11329 char * kwnames[] = {
11330 (char *) "self",(char *) "self",(char *) "_class", NULL
11331 };
11332
11333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11335 if (!SWIG_IsOK(res1)) {
11336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11337 }
11338 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11339 arg2 = obj1;
11340 arg3 = obj2;
11341 {
11342 PyThreadState* __tstate = wxPyBeginAllowThreads();
11343 (arg1)->_setCallbackInfo(arg2,arg3);
11344 wxPyEndAllowThreads(__tstate);
11345 if (PyErr_Occurred()) SWIG_fail;
11346 }
11347 resultobj = SWIG_Py_Void();
11348 return resultobj;
11349 fail:
11350 return NULL;
11351 }
11352
11353
11354 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11355 PyObject *obj;
11356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11357 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11358 return SWIG_Py_Void();
11359 }
11360
11361 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11362 return SWIG_Python_InitShadowInstance(args);
11363 }
11364
11365 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11366 PyObject *resultobj = 0;
11367 wxWindow *arg1 = (wxWindow *) 0 ;
11368 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11369 bool arg3 = (bool) true ;
11370 bool result;
11371 void *argp1 = 0 ;
11372 int res1 = 0 ;
11373 void *argp2 = 0 ;
11374 int res2 = 0 ;
11375 bool val3 ;
11376 int ecode3 = 0 ;
11377 PyObject * obj0 = 0 ;
11378 PyObject * obj1 = 0 ;
11379 PyObject * obj2 = 0 ;
11380 char * kwnames[] = {
11381 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11382 };
11383
11384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11386 if (!SWIG_IsOK(res1)) {
11387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11388 }
11389 arg1 = reinterpret_cast< wxWindow * >(argp1);
11390 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11391 if (!SWIG_IsOK(res2)) {
11392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11393 }
11394 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11395 if (obj2) {
11396 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11397 if (!SWIG_IsOK(ecode3)) {
11398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11399 }
11400 arg3 = static_cast< bool >(val3);
11401 }
11402 {
11403 if (!wxPyCheckForApp()) SWIG_fail;
11404 PyThreadState* __tstate = wxPyBeginAllowThreads();
11405 result = (bool)wxShowTip(arg1,arg2,arg3);
11406 wxPyEndAllowThreads(__tstate);
11407 if (PyErr_Occurred()) SWIG_fail;
11408 }
11409 {
11410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11411 }
11412 return resultobj;
11413 fail:
11414 return NULL;
11415 }
11416
11417
11418 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11419 PyObject *resultobj = 0;
11420 wxString *arg1 = 0 ;
11421 size_t arg2 ;
11422 wxTipProvider *result = 0 ;
11423 bool temp1 = false ;
11424 size_t val2 ;
11425 int ecode2 = 0 ;
11426 PyObject * obj0 = 0 ;
11427 PyObject * obj1 = 0 ;
11428 char * kwnames[] = {
11429 (char *) "filename",(char *) "currentTip", NULL
11430 };
11431
11432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11433 {
11434 arg1 = wxString_in_helper(obj0);
11435 if (arg1 == NULL) SWIG_fail;
11436 temp1 = true;
11437 }
11438 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11439 if (!SWIG_IsOK(ecode2)) {
11440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11441 }
11442 arg2 = static_cast< size_t >(val2);
11443 {
11444 if (!wxPyCheckForApp()) SWIG_fail;
11445 PyThreadState* __tstate = wxPyBeginAllowThreads();
11446 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11447 wxPyEndAllowThreads(__tstate);
11448 if (PyErr_Occurred()) SWIG_fail;
11449 }
11450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11451 {
11452 if (temp1)
11453 delete arg1;
11454 }
11455 return resultobj;
11456 fail:
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return NULL;
11462 }
11463
11464
11465 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj = 0;
11467 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11468 int arg2 = (int) wxID_ANY ;
11469 wxPyTimer *result = 0 ;
11470 void *argp1 = 0 ;
11471 int res1 = 0 ;
11472 int val2 ;
11473 int ecode2 = 0 ;
11474 PyObject * obj0 = 0 ;
11475 PyObject * obj1 = 0 ;
11476 char * kwnames[] = {
11477 (char *) "owner",(char *) "id", NULL
11478 };
11479
11480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11481 if (obj0) {
11482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11483 if (!SWIG_IsOK(res1)) {
11484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11485 }
11486 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11487 }
11488 if (obj1) {
11489 ecode2 = SWIG_AsVal_int(obj1, &val2);
11490 if (!SWIG_IsOK(ecode2)) {
11491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11492 }
11493 arg2 = static_cast< int >(val2);
11494 }
11495 {
11496 if (!wxPyCheckForApp()) SWIG_fail;
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11510 PyObject *resultobj = 0;
11511 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11512 void *argp1 = 0 ;
11513 int res1 = 0 ;
11514 PyObject *swig_obj[1] ;
11515
11516 if (!args) SWIG_fail;
11517 swig_obj[0] = args;
11518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11521 }
11522 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 delete arg1;
11526
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_Py_Void();
11531 return resultobj;
11532 fail:
11533 return NULL;
11534 }
11535
11536
11537 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11538 PyObject *resultobj = 0;
11539 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11540 PyObject *arg2 = (PyObject *) 0 ;
11541 PyObject *arg3 = (PyObject *) 0 ;
11542 int arg4 = (int) 1 ;
11543 void *argp1 = 0 ;
11544 int res1 = 0 ;
11545 int val4 ;
11546 int ecode4 = 0 ;
11547 PyObject * obj0 = 0 ;
11548 PyObject * obj1 = 0 ;
11549 PyObject * obj2 = 0 ;
11550 PyObject * obj3 = 0 ;
11551 char * kwnames[] = {
11552 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11553 };
11554
11555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11557 if (!SWIG_IsOK(res1)) {
11558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11559 }
11560 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11561 arg2 = obj1;
11562 arg3 = obj2;
11563 if (obj3) {
11564 ecode4 = SWIG_AsVal_int(obj3, &val4);
11565 if (!SWIG_IsOK(ecode4)) {
11566 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11567 }
11568 arg4 = static_cast< int >(val4);
11569 }
11570 {
11571 PyThreadState* __tstate = wxPyBeginAllowThreads();
11572 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11573 wxPyEndAllowThreads(__tstate);
11574 if (PyErr_Occurred()) SWIG_fail;
11575 }
11576 resultobj = SWIG_Py_Void();
11577 return resultobj;
11578 fail:
11579 return NULL;
11580 }
11581
11582
11583 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj = 0;
11585 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11586 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11587 int arg3 = (int) wxID_ANY ;
11588 void *argp1 = 0 ;
11589 int res1 = 0 ;
11590 void *argp2 = 0 ;
11591 int res2 = 0 ;
11592 int val3 ;
11593 int ecode3 = 0 ;
11594 PyObject * obj0 = 0 ;
11595 PyObject * obj1 = 0 ;
11596 PyObject * obj2 = 0 ;
11597 char * kwnames[] = {
11598 (char *) "self",(char *) "owner",(char *) "id", NULL
11599 };
11600
11601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11603 if (!SWIG_IsOK(res1)) {
11604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11605 }
11606 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11608 if (!SWIG_IsOK(res2)) {
11609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11610 }
11611 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11612 if (obj2) {
11613 ecode3 = SWIG_AsVal_int(obj2, &val3);
11614 if (!SWIG_IsOK(ecode3)) {
11615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11616 }
11617 arg3 = static_cast< int >(val3);
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 (arg1)->SetOwner(arg2,arg3);
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 resultobj = SWIG_Py_Void();
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11633 PyObject *resultobj = 0;
11634 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11635 wxEvtHandler *result = 0 ;
11636 void *argp1 = 0 ;
11637 int res1 = 0 ;
11638 PyObject *swig_obj[1] ;
11639
11640 if (!args) SWIG_fail;
11641 swig_obj[0] = args;
11642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11643 if (!SWIG_IsOK(res1)) {
11644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11645 }
11646 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 result = (wxEvtHandler *)(arg1)->GetOwner();
11650 wxPyEndAllowThreads(__tstate);
11651 if (PyErr_Occurred()) SWIG_fail;
11652 }
11653 {
11654 resultobj = wxPyMake_wxObject(result, 0);
11655 }
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11663 PyObject *resultobj = 0;
11664 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11665 int arg2 = (int) -1 ;
11666 bool arg3 = (bool) false ;
11667 bool result;
11668 void *argp1 = 0 ;
11669 int res1 = 0 ;
11670 int val2 ;
11671 int ecode2 = 0 ;
11672 bool val3 ;
11673 int ecode3 = 0 ;
11674 PyObject * obj0 = 0 ;
11675 PyObject * obj1 = 0 ;
11676 PyObject * obj2 = 0 ;
11677 char * kwnames[] = {
11678 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11679 };
11680
11681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11683 if (!SWIG_IsOK(res1)) {
11684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11685 }
11686 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11687 if (obj1) {
11688 ecode2 = SWIG_AsVal_int(obj1, &val2);
11689 if (!SWIG_IsOK(ecode2)) {
11690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11691 }
11692 arg2 = static_cast< int >(val2);
11693 }
11694 if (obj2) {
11695 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11696 if (!SWIG_IsOK(ecode3)) {
11697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11698 }
11699 arg3 = static_cast< bool >(val3);
11700 }
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (bool)(arg1)->Start(arg2,arg3);
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 {
11708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11709 }
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11717 PyObject *resultobj = 0;
11718 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11719 void *argp1 = 0 ;
11720 int res1 = 0 ;
11721 PyObject *swig_obj[1] ;
11722
11723 if (!args) SWIG_fail;
11724 swig_obj[0] = args;
11725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11726 if (!SWIG_IsOK(res1)) {
11727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11728 }
11729 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11730 {
11731 PyThreadState* __tstate = wxPyBeginAllowThreads();
11732 (arg1)->Stop();
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 resultobj = SWIG_Py_Void();
11737 return resultobj;
11738 fail:
11739 return NULL;
11740 }
11741
11742
11743 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11744 PyObject *resultobj = 0;
11745 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11746 void *argp1 = 0 ;
11747 int res1 = 0 ;
11748 PyObject *swig_obj[1] ;
11749
11750 if (!args) SWIG_fail;
11751 swig_obj[0] = args;
11752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11753 if (!SWIG_IsOK(res1)) {
11754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11755 }
11756 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11757 {
11758 PyThreadState* __tstate = wxPyBeginAllowThreads();
11759 (arg1)->Notify();
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 resultobj = SWIG_Py_Void();
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11771 PyObject *resultobj = 0;
11772 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11773 bool result;
11774 void *argp1 = 0 ;
11775 int res1 = 0 ;
11776 PyObject *swig_obj[1] ;
11777
11778 if (!args) SWIG_fail;
11779 swig_obj[0] = args;
11780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11781 if (!SWIG_IsOK(res1)) {
11782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11783 }
11784 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11788 wxPyEndAllowThreads(__tstate);
11789 if (PyErr_Occurred()) SWIG_fail;
11790 }
11791 {
11792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11793 }
11794 return resultobj;
11795 fail:
11796 return NULL;
11797 }
11798
11799
11800 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11801 PyObject *resultobj = 0;
11802 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11803 int result;
11804 void *argp1 = 0 ;
11805 int res1 = 0 ;
11806 PyObject *swig_obj[1] ;
11807
11808 if (!args) SWIG_fail;
11809 swig_obj[0] = args;
11810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11811 if (!SWIG_IsOK(res1)) {
11812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11813 }
11814 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 resultobj = SWIG_From_int(static_cast< int >(result));
11822 return resultobj;
11823 fail:
11824 return NULL;
11825 }
11826
11827
11828 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11829 PyObject *resultobj = 0;
11830 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11831 int result;
11832 void *argp1 = 0 ;
11833 int res1 = 0 ;
11834 PyObject *swig_obj[1] ;
11835
11836 if (!args) SWIG_fail;
11837 swig_obj[0] = args;
11838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11839 if (!SWIG_IsOK(res1)) {
11840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11841 }
11842 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11843 {
11844 PyThreadState* __tstate = wxPyBeginAllowThreads();
11845 result = (int)((wxPyTimer const *)arg1)->GetId();
11846 wxPyEndAllowThreads(__tstate);
11847 if (PyErr_Occurred()) SWIG_fail;
11848 }
11849 resultobj = SWIG_From_int(static_cast< int >(result));
11850 return resultobj;
11851 fail:
11852 return NULL;
11853 }
11854
11855
11856 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11857 PyObject *resultobj = 0;
11858 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11859 bool result;
11860 void *argp1 = 0 ;
11861 int res1 = 0 ;
11862 PyObject *swig_obj[1] ;
11863
11864 if (!args) SWIG_fail;
11865 swig_obj[0] = args;
11866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11867 if (!SWIG_IsOK(res1)) {
11868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11869 }
11870 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11874 wxPyEndAllowThreads(__tstate);
11875 if (PyErr_Occurred()) SWIG_fail;
11876 }
11877 {
11878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11879 }
11880 return resultobj;
11881 fail:
11882 return NULL;
11883 }
11884
11885
11886 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11887 PyObject *obj;
11888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11889 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11890 return SWIG_Py_Void();
11891 }
11892
11893 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 return SWIG_Python_InitShadowInstance(args);
11895 }
11896
11897 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11898 PyObject *resultobj = 0;
11899 int arg1 = (int) 0 ;
11900 int arg2 = (int) 0 ;
11901 wxTimerEvent *result = 0 ;
11902 int val1 ;
11903 int ecode1 = 0 ;
11904 int val2 ;
11905 int ecode2 = 0 ;
11906 PyObject * obj0 = 0 ;
11907 PyObject * obj1 = 0 ;
11908 char * kwnames[] = {
11909 (char *) "timerid",(char *) "interval", NULL
11910 };
11911
11912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11913 if (obj0) {
11914 ecode1 = SWIG_AsVal_int(obj0, &val1);
11915 if (!SWIG_IsOK(ecode1)) {
11916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11917 }
11918 arg1 = static_cast< int >(val1);
11919 }
11920 if (obj1) {
11921 ecode2 = SWIG_AsVal_int(obj1, &val2);
11922 if (!SWIG_IsOK(ecode2)) {
11923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11924 }
11925 arg2 = static_cast< int >(val2);
11926 }
11927 {
11928 PyThreadState* __tstate = wxPyBeginAllowThreads();
11929 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11930 wxPyEndAllowThreads(__tstate);
11931 if (PyErr_Occurred()) SWIG_fail;
11932 }
11933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11934 return resultobj;
11935 fail:
11936 return NULL;
11937 }
11938
11939
11940 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11941 PyObject *resultobj = 0;
11942 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11943 int result;
11944 void *argp1 = 0 ;
11945 int res1 = 0 ;
11946 PyObject *swig_obj[1] ;
11947
11948 if (!args) SWIG_fail;
11949 swig_obj[0] = args;
11950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11951 if (!SWIG_IsOK(res1)) {
11952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11953 }
11954 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11955 {
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11958 wxPyEndAllowThreads(__tstate);
11959 if (PyErr_Occurred()) SWIG_fail;
11960 }
11961 resultobj = SWIG_From_int(static_cast< int >(result));
11962 return resultobj;
11963 fail:
11964 return NULL;
11965 }
11966
11967
11968 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11969 PyObject *obj;
11970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11971 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11972 return SWIG_Py_Void();
11973 }
11974
11975 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11976 return SWIG_Python_InitShadowInstance(args);
11977 }
11978
11979 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11980 PyObject *resultobj = 0;
11981 wxTimer *arg1 = 0 ;
11982 wxTimerRunner *result = 0 ;
11983 void *argp1 = 0 ;
11984 int res1 = 0 ;
11985
11986 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11988 if (!SWIG_IsOK(res1)) {
11989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11990 }
11991 if (!argp1) {
11992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11993 }
11994 arg1 = reinterpret_cast< wxTimer * >(argp1);
11995 {
11996 if (!wxPyCheckForApp()) SWIG_fail;
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12010 PyObject *resultobj = 0;
12011 wxTimer *arg1 = 0 ;
12012 int arg2 ;
12013 bool arg3 = (bool) false ;
12014 wxTimerRunner *result = 0 ;
12015 void *argp1 = 0 ;
12016 int res1 = 0 ;
12017 int val2 ;
12018 int ecode2 = 0 ;
12019 bool val3 ;
12020 int ecode3 = 0 ;
12021
12022 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12024 if (!SWIG_IsOK(res1)) {
12025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12026 }
12027 if (!argp1) {
12028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12029 }
12030 arg1 = reinterpret_cast< wxTimer * >(argp1);
12031 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12032 if (!SWIG_IsOK(ecode2)) {
12033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12034 }
12035 arg2 = static_cast< int >(val2);
12036 if (swig_obj[2]) {
12037 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12038 if (!SWIG_IsOK(ecode3)) {
12039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12040 }
12041 arg3 = static_cast< bool >(val3);
12042 }
12043 {
12044 if (!wxPyCheckForApp()) SWIG_fail;
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12058 int argc;
12059 PyObject *argv[4];
12060
12061 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12062 --argc;
12063 if (argc == 1) {
12064 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12065 }
12066 if ((argc >= 2) && (argc <= 3)) {
12067 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12068 }
12069
12070 fail:
12071 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12072 return NULL;
12073 }
12074
12075
12076 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12077 PyObject *resultobj = 0;
12078 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12079 void *argp1 = 0 ;
12080 int res1 = 0 ;
12081 PyObject *swig_obj[1] ;
12082
12083 if (!args) SWIG_fail;
12084 swig_obj[0] = args;
12085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12086 if (!SWIG_IsOK(res1)) {
12087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12088 }
12089 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12090 {
12091 PyThreadState* __tstate = wxPyBeginAllowThreads();
12092 delete arg1;
12093
12094 wxPyEndAllowThreads(__tstate);
12095 if (PyErr_Occurred()) SWIG_fail;
12096 }
12097 resultobj = SWIG_Py_Void();
12098 return resultobj;
12099 fail:
12100 return NULL;
12101 }
12102
12103
12104 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12105 PyObject *resultobj = 0;
12106 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12107 int arg2 ;
12108 bool arg3 = (bool) false ;
12109 void *argp1 = 0 ;
12110 int res1 = 0 ;
12111 int val2 ;
12112 int ecode2 = 0 ;
12113 bool val3 ;
12114 int ecode3 = 0 ;
12115 PyObject * obj0 = 0 ;
12116 PyObject * obj1 = 0 ;
12117 PyObject * obj2 = 0 ;
12118 char * kwnames[] = {
12119 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12120 };
12121
12122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12124 if (!SWIG_IsOK(res1)) {
12125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12126 }
12127 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12128 ecode2 = SWIG_AsVal_int(obj1, &val2);
12129 if (!SWIG_IsOK(ecode2)) {
12130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12131 }
12132 arg2 = static_cast< int >(val2);
12133 if (obj2) {
12134 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12135 if (!SWIG_IsOK(ecode3)) {
12136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12137 }
12138 arg3 = static_cast< bool >(val3);
12139 }
12140 {
12141 PyThreadState* __tstate = wxPyBeginAllowThreads();
12142 (arg1)->Start(arg2,arg3);
12143 wxPyEndAllowThreads(__tstate);
12144 if (PyErr_Occurred()) SWIG_fail;
12145 }
12146 resultobj = SWIG_Py_Void();
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154 PyObject *obj;
12155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12156 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12157 return SWIG_Py_Void();
12158 }
12159
12160 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12161 return SWIG_Python_InitShadowInstance(args);
12162 }
12163
12164 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12165 PyObject *resultobj = 0;
12166 wxLog *result = 0 ;
12167
12168 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12169 {
12170 PyThreadState* __tstate = wxPyBeginAllowThreads();
12171 result = (wxLog *)new wxLog();
12172 wxPyEndAllowThreads(__tstate);
12173 if (PyErr_Occurred()) SWIG_fail;
12174 }
12175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12176 return resultobj;
12177 fail:
12178 return NULL;
12179 }
12180
12181
12182 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12183 PyObject *resultobj = 0;
12184 wxLog *arg1 = (wxLog *) 0 ;
12185 void *argp1 = 0 ;
12186 int res1 = 0 ;
12187 PyObject *swig_obj[1] ;
12188
12189 if (!args) SWIG_fail;
12190 swig_obj[0] = args;
12191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12192 if (!SWIG_IsOK(res1)) {
12193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12194 }
12195 arg1 = reinterpret_cast< wxLog * >(argp1);
12196 {
12197 PyThreadState* __tstate = wxPyBeginAllowThreads();
12198 delete arg1;
12199
12200 wxPyEndAllowThreads(__tstate);
12201 if (PyErr_Occurred()) SWIG_fail;
12202 }
12203 resultobj = SWIG_Py_Void();
12204 return resultobj;
12205 fail:
12206 return NULL;
12207 }
12208
12209
12210 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211 PyObject *resultobj = 0;
12212 bool result;
12213
12214 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (bool)wxLog::IsEnabled();
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 {
12222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12223 }
12224 return resultobj;
12225 fail:
12226 return NULL;
12227 }
12228
12229
12230 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12231 PyObject *resultobj = 0;
12232 bool arg1 = (bool) true ;
12233 bool result;
12234 bool val1 ;
12235 int ecode1 = 0 ;
12236 PyObject * obj0 = 0 ;
12237 char * kwnames[] = {
12238 (char *) "doIt", NULL
12239 };
12240
12241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12242 if (obj0) {
12243 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12244 if (!SWIG_IsOK(ecode1)) {
12245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12246 }
12247 arg1 = static_cast< bool >(val1);
12248 }
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (bool)wxLog::EnableLogging(arg1);
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 {
12256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12257 }
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj = 0;
12266 wxLogLevel arg1 ;
12267 wxChar *arg2 = (wxChar *) 0 ;
12268 time_t arg3 ;
12269 unsigned long val1 ;
12270 int ecode1 = 0 ;
12271 void *argp2 = 0 ;
12272 int res2 = 0 ;
12273 unsigned int val3 ;
12274 int ecode3 = 0 ;
12275 PyObject * obj0 = 0 ;
12276 PyObject * obj1 = 0 ;
12277 PyObject * obj2 = 0 ;
12278 char * kwnames[] = {
12279 (char *) "level",(char *) "szString",(char *) "t", NULL
12280 };
12281
12282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12283 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12284 if (!SWIG_IsOK(ecode1)) {
12285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12286 }
12287 arg1 = static_cast< wxLogLevel >(val1);
12288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12289 if (!SWIG_IsOK(res2)) {
12290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12291 }
12292 arg2 = reinterpret_cast< wxChar * >(argp2);
12293 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12294 if (!SWIG_IsOK(ecode3)) {
12295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12296 }
12297 arg3 = static_cast< time_t >(val3);
12298 {
12299 PyThreadState* __tstate = wxPyBeginAllowThreads();
12300 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12301 wxPyEndAllowThreads(__tstate);
12302 if (PyErr_Occurred()) SWIG_fail;
12303 }
12304 resultobj = SWIG_Py_Void();
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12312 PyObject *resultobj = 0;
12313 wxLog *arg1 = (wxLog *) 0 ;
12314 void *argp1 = 0 ;
12315 int res1 = 0 ;
12316 PyObject *swig_obj[1] ;
12317
12318 if (!args) SWIG_fail;
12319 swig_obj[0] = args;
12320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12321 if (!SWIG_IsOK(res1)) {
12322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12323 }
12324 arg1 = reinterpret_cast< wxLog * >(argp1);
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 (arg1)->Flush();
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 resultobj = SWIG_Py_Void();
12332 return resultobj;
12333 fail:
12334 return NULL;
12335 }
12336
12337
12338 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12339 PyObject *resultobj = 0;
12340
12341 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 wxLog::FlushActive();
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 resultobj = SWIG_Py_Void();
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12356 PyObject *resultobj = 0;
12357 wxLog *result = 0 ;
12358
12359 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (wxLog *)wxLog::GetActiveTarget();
12363 wxPyEndAllowThreads(__tstate);
12364 if (PyErr_Occurred()) SWIG_fail;
12365 }
12366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12374 PyObject *resultobj = 0;
12375 wxLog *arg1 = (wxLog *) 0 ;
12376 wxLog *result = 0 ;
12377 int res1 = 0 ;
12378 PyObject * obj0 = 0 ;
12379 char * kwnames[] = {
12380 (char *) "pLogger", NULL
12381 };
12382
12383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12384 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12385 if (!SWIG_IsOK(res1)) {
12386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12387 }
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12391 wxPyEndAllowThreads(__tstate);
12392 if (PyErr_Occurred()) SWIG_fail;
12393 }
12394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12395 return resultobj;
12396 fail:
12397 return NULL;
12398 }
12399
12400
12401 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12402 PyObject *resultobj = 0;
12403
12404 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12405 {
12406 PyThreadState* __tstate = wxPyBeginAllowThreads();
12407 wxLog::Suspend();
12408 wxPyEndAllowThreads(__tstate);
12409 if (PyErr_Occurred()) SWIG_fail;
12410 }
12411 resultobj = SWIG_Py_Void();
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12419 PyObject *resultobj = 0;
12420
12421 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12422 {
12423 PyThreadState* __tstate = wxPyBeginAllowThreads();
12424 wxLog::Resume();
12425 wxPyEndAllowThreads(__tstate);
12426 if (PyErr_Occurred()) SWIG_fail;
12427 }
12428 resultobj = SWIG_Py_Void();
12429 return resultobj;
12430 fail:
12431 return NULL;
12432 }
12433
12434
12435 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12436 PyObject *resultobj = 0;
12437 bool arg1 = (bool) true ;
12438 bool val1 ;
12439 int ecode1 = 0 ;
12440 PyObject * obj0 = 0 ;
12441 char * kwnames[] = {
12442 (char *) "bVerbose", NULL
12443 };
12444
12445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12446 if (obj0) {
12447 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12448 if (!SWIG_IsOK(ecode1)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12450 }
12451 arg1 = static_cast< bool >(val1);
12452 }
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 wxLog::SetVerbose(arg1);
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 resultobj = SWIG_Py_Void();
12460 return resultobj;
12461 fail:
12462 return NULL;
12463 }
12464
12465
12466 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12467 PyObject *resultobj = 0;
12468 wxLogLevel arg1 ;
12469 unsigned long val1 ;
12470 int ecode1 = 0 ;
12471 PyObject * obj0 = 0 ;
12472 char * kwnames[] = {
12473 (char *) "logLevel", NULL
12474 };
12475
12476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12477 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12478 if (!SWIG_IsOK(ecode1)) {
12479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12480 }
12481 arg1 = static_cast< wxLogLevel >(val1);
12482 {
12483 PyThreadState* __tstate = wxPyBeginAllowThreads();
12484 wxLog::SetLogLevel(arg1);
12485 wxPyEndAllowThreads(__tstate);
12486 if (PyErr_Occurred()) SWIG_fail;
12487 }
12488 resultobj = SWIG_Py_Void();
12489 return resultobj;
12490 fail:
12491 return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496 PyObject *resultobj = 0;
12497
12498 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12499 {
12500 PyThreadState* __tstate = wxPyBeginAllowThreads();
12501 wxLog::DontCreateOnDemand();
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 resultobj = SWIG_Py_Void();
12506 return resultobj;
12507 fail:
12508 return NULL;
12509 }
12510
12511
12512 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12513 PyObject *resultobj = 0;
12514 bool arg1 = (bool) true ;
12515 bool val1 ;
12516 int ecode1 = 0 ;
12517 PyObject * obj0 = 0 ;
12518 char * kwnames[] = {
12519 (char *) "bRepetCounting", NULL
12520 };
12521
12522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12523 if (obj0) {
12524 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12525 if (!SWIG_IsOK(ecode1)) {
12526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12527 }
12528 arg1 = static_cast< bool >(val1);
12529 }
12530 {
12531 PyThreadState* __tstate = wxPyBeginAllowThreads();
12532 wxLog::SetRepetitionCounting(arg1);
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 resultobj = SWIG_Py_Void();
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12544 PyObject *resultobj = 0;
12545 bool result;
12546
12547 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12548 {
12549 PyThreadState* __tstate = wxPyBeginAllowThreads();
12550 result = (bool)wxLog::GetRepetitionCounting();
12551 wxPyEndAllowThreads(__tstate);
12552 if (PyErr_Occurred()) SWIG_fail;
12553 }
12554 {
12555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12556 }
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj = 0;
12565 wxTraceMask arg1 ;
12566 unsigned long val1 ;
12567 int ecode1 = 0 ;
12568 PyObject * obj0 = 0 ;
12569 char * kwnames[] = {
12570 (char *) "ulMask", NULL
12571 };
12572
12573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12574 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12575 if (!SWIG_IsOK(ecode1)) {
12576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12577 }
12578 arg1 = static_cast< wxTraceMask >(val1);
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 wxLog::SetTraceMask(arg1);
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 resultobj = SWIG_Py_Void();
12586 return resultobj;
12587 fail:
12588 return NULL;
12589 }
12590
12591
12592 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12593 PyObject *resultobj = 0;
12594 wxString *arg1 = 0 ;
12595 bool temp1 = false ;
12596 PyObject * obj0 = 0 ;
12597 char * kwnames[] = {
12598 (char *) "str", NULL
12599 };
12600
12601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12602 {
12603 arg1 = wxString_in_helper(obj0);
12604 if (arg1 == NULL) SWIG_fail;
12605 temp1 = true;
12606 }
12607 {
12608 PyThreadState* __tstate = wxPyBeginAllowThreads();
12609 wxLog::AddTraceMask((wxString const &)*arg1);
12610 wxPyEndAllowThreads(__tstate);
12611 if (PyErr_Occurred()) SWIG_fail;
12612 }
12613 resultobj = SWIG_Py_Void();
12614 {
12615 if (temp1)
12616 delete arg1;
12617 }
12618 return resultobj;
12619 fail:
12620 {
12621 if (temp1)
12622 delete arg1;
12623 }
12624 return NULL;
12625 }
12626
12627
12628 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj = 0;
12630 wxString *arg1 = 0 ;
12631 bool temp1 = false ;
12632 PyObject * obj0 = 0 ;
12633 char * kwnames[] = {
12634 (char *) "str", NULL
12635 };
12636
12637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12638 {
12639 arg1 = wxString_in_helper(obj0);
12640 if (arg1 == NULL) SWIG_fail;
12641 temp1 = true;
12642 }
12643 {
12644 PyThreadState* __tstate = wxPyBeginAllowThreads();
12645 wxLog::RemoveTraceMask((wxString const &)*arg1);
12646 wxPyEndAllowThreads(__tstate);
12647 if (PyErr_Occurred()) SWIG_fail;
12648 }
12649 resultobj = SWIG_Py_Void();
12650 {
12651 if (temp1)
12652 delete arg1;
12653 }
12654 return resultobj;
12655 fail:
12656 {
12657 if (temp1)
12658 delete arg1;
12659 }
12660 return NULL;
12661 }
12662
12663
12664 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12665 PyObject *resultobj = 0;
12666
12667 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 wxLog::ClearTraceMasks();
12671 wxPyEndAllowThreads(__tstate);
12672 if (PyErr_Occurred()) SWIG_fail;
12673 }
12674 resultobj = SWIG_Py_Void();
12675 return resultobj;
12676 fail:
12677 return NULL;
12678 }
12679
12680
12681 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12682 PyObject *resultobj = 0;
12683 wxArrayString *result = 0 ;
12684
12685 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12686 {
12687 PyThreadState* __tstate = wxPyBeginAllowThreads();
12688 {
12689 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12690 result = (wxArrayString *) &_result_ref;
12691 }
12692 wxPyEndAllowThreads(__tstate);
12693 if (PyErr_Occurred()) SWIG_fail;
12694 }
12695 {
12696 resultobj = wxArrayString2PyList_helper(*result);
12697 }
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12705 PyObject *resultobj = 0;
12706 wxChar *arg1 = (wxChar *) 0 ;
12707 void *argp1 = 0 ;
12708 int res1 = 0 ;
12709 PyObject * obj0 = 0 ;
12710 char * kwnames[] = {
12711 (char *) "ts", NULL
12712 };
12713
12714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12716 if (!SWIG_IsOK(res1)) {
12717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12718 }
12719 arg1 = reinterpret_cast< wxChar * >(argp1);
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 wxLog::SetTimestamp((wxChar const *)arg1);
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 resultobj = SWIG_Py_Void();
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734 PyObject *resultobj = 0;
12735 bool result;
12736
12737 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 result = (bool)wxLog::GetVerbose();
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 {
12745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12746 }
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12754 PyObject *resultobj = 0;
12755 wxTraceMask result;
12756
12757 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12758 {
12759 PyThreadState* __tstate = wxPyBeginAllowThreads();
12760 result = (wxTraceMask)wxLog::GetTraceMask();
12761 wxPyEndAllowThreads(__tstate);
12762 if (PyErr_Occurred()) SWIG_fail;
12763 }
12764 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12772 PyObject *resultobj = 0;
12773 wxChar *arg1 = (wxChar *) 0 ;
12774 bool result;
12775 void *argp1 = 0 ;
12776 int res1 = 0 ;
12777 PyObject * obj0 = 0 ;
12778 char * kwnames[] = {
12779 (char *) "mask", NULL
12780 };
12781
12782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12784 if (!SWIG_IsOK(res1)) {
12785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12786 }
12787 arg1 = reinterpret_cast< wxChar * >(argp1);
12788 {
12789 PyThreadState* __tstate = wxPyBeginAllowThreads();
12790 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12791 wxPyEndAllowThreads(__tstate);
12792 if (PyErr_Occurred()) SWIG_fail;
12793 }
12794 {
12795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12796 }
12797 return resultobj;
12798 fail:
12799 return NULL;
12800 }
12801
12802
12803 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12804 PyObject *resultobj = 0;
12805 wxLogLevel result;
12806
12807 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12808 {
12809 PyThreadState* __tstate = wxPyBeginAllowThreads();
12810 result = (wxLogLevel)wxLog::GetLogLevel();
12811 wxPyEndAllowThreads(__tstate);
12812 if (PyErr_Occurred()) SWIG_fail;
12813 }
12814 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12822 PyObject *resultobj = 0;
12823 wxChar *result = 0 ;
12824
12825 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12826 {
12827 PyThreadState* __tstate = wxPyBeginAllowThreads();
12828 result = (wxChar *)wxLog::GetTimestamp();
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840 PyObject *resultobj = 0;
12841 wxString result;
12842
12843 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = wxLog_TimeStamp();
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 {
12851 #if wxUSE_UNICODE
12852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12853 #else
12854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12855 #endif
12856 }
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12864 PyObject *resultobj = 0;
12865 wxLog *arg1 = (wxLog *) 0 ;
12866 void *argp1 = 0 ;
12867 int res1 = 0 ;
12868 PyObject *swig_obj[1] ;
12869
12870 if (!args) SWIG_fail;
12871 swig_obj[0] = args;
12872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12873 if (!SWIG_IsOK(res1)) {
12874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12875 }
12876 arg1 = reinterpret_cast< wxLog * >(argp1);
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 wxLog_Destroy(arg1);
12880 wxPyEndAllowThreads(__tstate);
12881 if (PyErr_Occurred()) SWIG_fail;
12882 }
12883 resultobj = SWIG_Py_Void();
12884 return resultobj;
12885 fail:
12886 return NULL;
12887 }
12888
12889
12890 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12891 PyObject *obj;
12892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12893 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12894 return SWIG_Py_Void();
12895 }
12896
12897 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12898 return SWIG_Python_InitShadowInstance(args);
12899 }
12900
12901 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12902 PyObject *resultobj = 0;
12903 wxLogStderr *result = 0 ;
12904
12905 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 result = (wxLogStderr *)new wxLogStderr();
12909 wxPyEndAllowThreads(__tstate);
12910 if (PyErr_Occurred()) SWIG_fail;
12911 }
12912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12913 return resultobj;
12914 fail:
12915 return NULL;
12916 }
12917
12918
12919 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12920 PyObject *obj;
12921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12922 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12923 return SWIG_Py_Void();
12924 }
12925
12926 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12927 return SWIG_Python_InitShadowInstance(args);
12928 }
12929
12930 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12931 PyObject *resultobj = 0;
12932 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12933 wxLogTextCtrl *result = 0 ;
12934 void *argp1 = 0 ;
12935 int res1 = 0 ;
12936 PyObject * obj0 = 0 ;
12937 char * kwnames[] = {
12938 (char *) "pTextCtrl", NULL
12939 };
12940
12941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12943 if (!SWIG_IsOK(res1)) {
12944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12945 }
12946 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12947 {
12948 PyThreadState* __tstate = wxPyBeginAllowThreads();
12949 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12950 wxPyEndAllowThreads(__tstate);
12951 if (PyErr_Occurred()) SWIG_fail;
12952 }
12953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 PyObject *obj;
12962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12963 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12964 return SWIG_Py_Void();
12965 }
12966
12967 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 return SWIG_Python_InitShadowInstance(args);
12969 }
12970
12971 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12972 PyObject *resultobj = 0;
12973 wxLogGui *result = 0 ;
12974
12975 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12976 {
12977 PyThreadState* __tstate = wxPyBeginAllowThreads();
12978 result = (wxLogGui *)new wxLogGui();
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12983 return resultobj;
12984 fail:
12985 return NULL;
12986 }
12987
12988
12989 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12990 PyObject *obj;
12991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12992 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12993 return SWIG_Py_Void();
12994 }
12995
12996 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 return SWIG_Python_InitShadowInstance(args);
12998 }
12999
13000 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13001 PyObject *resultobj = 0;
13002 wxFrame *arg1 = (wxFrame *) 0 ;
13003 wxString *arg2 = 0 ;
13004 bool arg3 = (bool) true ;
13005 bool arg4 = (bool) true ;
13006 wxLogWindow *result = 0 ;
13007 void *argp1 = 0 ;
13008 int res1 = 0 ;
13009 bool temp2 = false ;
13010 bool val3 ;
13011 int ecode3 = 0 ;
13012 bool val4 ;
13013 int ecode4 = 0 ;
13014 PyObject * obj0 = 0 ;
13015 PyObject * obj1 = 0 ;
13016 PyObject * obj2 = 0 ;
13017 PyObject * obj3 = 0 ;
13018 char * kwnames[] = {
13019 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13020 };
13021
13022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13024 if (!SWIG_IsOK(res1)) {
13025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13026 }
13027 arg1 = reinterpret_cast< wxFrame * >(argp1);
13028 {
13029 arg2 = wxString_in_helper(obj1);
13030 if (arg2 == NULL) SWIG_fail;
13031 temp2 = true;
13032 }
13033 if (obj2) {
13034 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13035 if (!SWIG_IsOK(ecode3)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13037 }
13038 arg3 = static_cast< bool >(val3);
13039 }
13040 if (obj3) {
13041 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13042 if (!SWIG_IsOK(ecode4)) {
13043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13044 }
13045 arg4 = static_cast< bool >(val4);
13046 }
13047 {
13048 PyThreadState* __tstate = wxPyBeginAllowThreads();
13049 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13054 {
13055 if (temp2)
13056 delete arg2;
13057 }
13058 return resultobj;
13059 fail:
13060 {
13061 if (temp2)
13062 delete arg2;
13063 }
13064 return NULL;
13065 }
13066
13067
13068 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13069 PyObject *resultobj = 0;
13070 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13071 bool arg2 = (bool) true ;
13072 void *argp1 = 0 ;
13073 int res1 = 0 ;
13074 bool val2 ;
13075 int ecode2 = 0 ;
13076 PyObject * obj0 = 0 ;
13077 PyObject * obj1 = 0 ;
13078 char * kwnames[] = {
13079 (char *) "self",(char *) "bShow", NULL
13080 };
13081
13082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13084 if (!SWIG_IsOK(res1)) {
13085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13086 }
13087 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13088 if (obj1) {
13089 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13090 if (!SWIG_IsOK(ecode2)) {
13091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13092 }
13093 arg2 = static_cast< bool >(val2);
13094 }
13095 {
13096 PyThreadState* __tstate = wxPyBeginAllowThreads();
13097 (arg1)->Show(arg2);
13098 wxPyEndAllowThreads(__tstate);
13099 if (PyErr_Occurred()) SWIG_fail;
13100 }
13101 resultobj = SWIG_Py_Void();
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13109 PyObject *resultobj = 0;
13110 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13111 wxFrame *result = 0 ;
13112 void *argp1 = 0 ;
13113 int res1 = 0 ;
13114 PyObject *swig_obj[1] ;
13115
13116 if (!args) SWIG_fail;
13117 swig_obj[0] = args;
13118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13119 if (!SWIG_IsOK(res1)) {
13120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13121 }
13122 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13126 wxPyEndAllowThreads(__tstate);
13127 if (PyErr_Occurred()) SWIG_fail;
13128 }
13129 {
13130 resultobj = wxPyMake_wxObject(result, (bool)0);
13131 }
13132 return resultobj;
13133 fail:
13134 return NULL;
13135 }
13136
13137
13138 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13139 PyObject *resultobj = 0;
13140 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13141 wxLog *result = 0 ;
13142 void *argp1 = 0 ;
13143 int res1 = 0 ;
13144 PyObject *swig_obj[1] ;
13145
13146 if (!args) SWIG_fail;
13147 swig_obj[0] = args;
13148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13149 if (!SWIG_IsOK(res1)) {
13150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13151 }
13152 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13167 PyObject *resultobj = 0;
13168 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13169 bool result;
13170 void *argp1 = 0 ;
13171 int res1 = 0 ;
13172 PyObject *swig_obj[1] ;
13173
13174 if (!args) SWIG_fail;
13175 swig_obj[0] = args;
13176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13177 if (!SWIG_IsOK(res1)) {
13178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13179 }
13180 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13181 {
13182 PyThreadState* __tstate = wxPyBeginAllowThreads();
13183 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13184 wxPyEndAllowThreads(__tstate);
13185 if (PyErr_Occurred()) SWIG_fail;
13186 }
13187 {
13188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13189 }
13190 return resultobj;
13191 fail:
13192 return NULL;
13193 }
13194
13195
13196 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13197 PyObject *resultobj = 0;
13198 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13199 bool arg2 ;
13200 void *argp1 = 0 ;
13201 int res1 = 0 ;
13202 bool val2 ;
13203 int ecode2 = 0 ;
13204 PyObject * obj0 = 0 ;
13205 PyObject * obj1 = 0 ;
13206 char * kwnames[] = {
13207 (char *) "self",(char *) "bDoPass", NULL
13208 };
13209
13210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13212 if (!SWIG_IsOK(res1)) {
13213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13214 }
13215 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13217 if (!SWIG_IsOK(ecode2)) {
13218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13219 }
13220 arg2 = static_cast< bool >(val2);
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 (arg1)->PassMessages(arg2);
13224 wxPyEndAllowThreads(__tstate);
13225 if (PyErr_Occurred()) SWIG_fail;
13226 }
13227 resultobj = SWIG_Py_Void();
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13235 PyObject *obj;
13236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13237 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13238 return SWIG_Py_Void();
13239 }
13240
13241 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13242 return SWIG_Python_InitShadowInstance(args);
13243 }
13244
13245 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13246 PyObject *resultobj = 0;
13247 wxLog *arg1 = (wxLog *) 0 ;
13248 wxLogChain *result = 0 ;
13249 void *argp1 = 0 ;
13250 int res1 = 0 ;
13251 PyObject * obj0 = 0 ;
13252 char * kwnames[] = {
13253 (char *) "logger", NULL
13254 };
13255
13256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13258 if (!SWIG_IsOK(res1)) {
13259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13260 }
13261 arg1 = reinterpret_cast< wxLog * >(argp1);
13262 {
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 result = (wxLogChain *)new wxLogChain(arg1);
13265 wxPyEndAllowThreads(__tstate);
13266 if (PyErr_Occurred()) SWIG_fail;
13267 }
13268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13276 PyObject *resultobj = 0;
13277 wxLogChain *arg1 = (wxLogChain *) 0 ;
13278 wxLog *arg2 = (wxLog *) 0 ;
13279 void *argp1 = 0 ;
13280 int res1 = 0 ;
13281 void *argp2 = 0 ;
13282 int res2 = 0 ;
13283 PyObject * obj0 = 0 ;
13284 PyObject * obj1 = 0 ;
13285 char * kwnames[] = {
13286 (char *) "self",(char *) "logger", NULL
13287 };
13288
13289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13291 if (!SWIG_IsOK(res1)) {
13292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13293 }
13294 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13296 if (!SWIG_IsOK(res2)) {
13297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13298 }
13299 arg2 = reinterpret_cast< wxLog * >(argp2);
13300 {
13301 PyThreadState* __tstate = wxPyBeginAllowThreads();
13302 (arg1)->SetLog(arg2);
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 resultobj = SWIG_Py_Void();
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13314 PyObject *resultobj = 0;
13315 wxLogChain *arg1 = (wxLogChain *) 0 ;
13316 bool arg2 ;
13317 void *argp1 = 0 ;
13318 int res1 = 0 ;
13319 bool val2 ;
13320 int ecode2 = 0 ;
13321 PyObject * obj0 = 0 ;
13322 PyObject * obj1 = 0 ;
13323 char * kwnames[] = {
13324 (char *) "self",(char *) "bDoPass", NULL
13325 };
13326
13327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13329 if (!SWIG_IsOK(res1)) {
13330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13331 }
13332 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13333 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13334 if (!SWIG_IsOK(ecode2)) {
13335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13336 }
13337 arg2 = static_cast< bool >(val2);
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 (arg1)->PassMessages(arg2);
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 resultobj = SWIG_Py_Void();
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13352 PyObject *resultobj = 0;
13353 wxLogChain *arg1 = (wxLogChain *) 0 ;
13354 bool result;
13355 void *argp1 = 0 ;
13356 int res1 = 0 ;
13357 PyObject *swig_obj[1] ;
13358
13359 if (!args) SWIG_fail;
13360 swig_obj[0] = args;
13361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13362 if (!SWIG_IsOK(res1)) {
13363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13364 }
13365 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13366 {
13367 PyThreadState* __tstate = wxPyBeginAllowThreads();
13368 result = (bool)(arg1)->IsPassingMessages();
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 {
13373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13374 }
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13382 PyObject *resultobj = 0;
13383 wxLogChain *arg1 = (wxLogChain *) 0 ;
13384 wxLog *result = 0 ;
13385 void *argp1 = 0 ;
13386 int res1 = 0 ;
13387 PyObject *swig_obj[1] ;
13388
13389 if (!args) SWIG_fail;
13390 swig_obj[0] = args;
13391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13392 if (!SWIG_IsOK(res1)) {
13393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13394 }
13395 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13396 {
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 result = (wxLog *)(arg1)->GetOldLog();
13399 wxPyEndAllowThreads(__tstate);
13400 if (PyErr_Occurred()) SWIG_fail;
13401 }
13402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13410 PyObject *obj;
13411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13412 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13413 return SWIG_Py_Void();
13414 }
13415
13416 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13417 return SWIG_Python_InitShadowInstance(args);
13418 }
13419
13420 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13421 PyObject *resultobj = 0;
13422 wxLogBuffer *result = 0 ;
13423
13424 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = (wxLogBuffer *)new wxLogBuffer();
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *resultobj = 0;
13440 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13441 wxString *result = 0 ;
13442 void *argp1 = 0 ;
13443 int res1 = 0 ;
13444 PyObject *swig_obj[1] ;
13445
13446 if (!args) SWIG_fail;
13447 swig_obj[0] = args;
13448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13449 if (!SWIG_IsOK(res1)) {
13450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13451 }
13452 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 {
13456 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13457 result = (wxString *) &_result_ref;
13458 }
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 {
13463 #if wxUSE_UNICODE
13464 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13465 #else
13466 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13467 #endif
13468 }
13469 return resultobj;
13470 fail:
13471 return NULL;
13472 }
13473
13474
13475 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13476 PyObject *obj;
13477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13478 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13479 return SWIG_Py_Void();
13480 }
13481
13482 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13483 return SWIG_Python_InitShadowInstance(args);
13484 }
13485
13486 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13487 PyObject *resultobj = 0;
13488 unsigned long result;
13489
13490 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (unsigned long)wxSysErrorCode();
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13498 return resultobj;
13499 fail:
13500 return NULL;
13501 }
13502
13503
13504 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13505 PyObject *resultobj = 0;
13506 unsigned long arg1 = (unsigned long) 0 ;
13507 wxString result;
13508 unsigned long val1 ;
13509 int ecode1 = 0 ;
13510 PyObject * obj0 = 0 ;
13511 char * kwnames[] = {
13512 (char *) "nErrCode", NULL
13513 };
13514
13515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13516 if (obj0) {
13517 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13518 if (!SWIG_IsOK(ecode1)) {
13519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13520 }
13521 arg1 = static_cast< unsigned long >(val1);
13522 }
13523 {
13524 PyThreadState* __tstate = wxPyBeginAllowThreads();
13525 result = wxSysErrorMsg(arg1);
13526 wxPyEndAllowThreads(__tstate);
13527 if (PyErr_Occurred()) SWIG_fail;
13528 }
13529 {
13530 #if wxUSE_UNICODE
13531 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13532 #else
13533 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13534 #endif
13535 }
13536 return resultobj;
13537 fail:
13538 return NULL;
13539 }
13540
13541
13542 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13543 PyObject *resultobj = 0;
13544 wxString *arg1 = 0 ;
13545 bool temp1 = false ;
13546 PyObject * obj0 = 0 ;
13547 char * kwnames[] = {
13548 (char *) "msg", NULL
13549 };
13550
13551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13552 {
13553 arg1 = wxString_in_helper(obj0);
13554 if (arg1 == NULL) SWIG_fail;
13555 temp1 = true;
13556 }
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 wxPyLogFatalError((wxString const &)*arg1);
13560 wxPyEndAllowThreads(__tstate);
13561 if (PyErr_Occurred()) SWIG_fail;
13562 }
13563 resultobj = SWIG_Py_Void();
13564 {
13565 if (temp1)
13566 delete arg1;
13567 }
13568 return resultobj;
13569 fail:
13570 {
13571 if (temp1)
13572 delete arg1;
13573 }
13574 return NULL;
13575 }
13576
13577
13578 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13579 PyObject *resultobj = 0;
13580 wxString *arg1 = 0 ;
13581 bool temp1 = false ;
13582 PyObject * obj0 = 0 ;
13583 char * kwnames[] = {
13584 (char *) "msg", NULL
13585 };
13586
13587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13588 {
13589 arg1 = wxString_in_helper(obj0);
13590 if (arg1 == NULL) SWIG_fail;
13591 temp1 = true;
13592 }
13593 {
13594 PyThreadState* __tstate = wxPyBeginAllowThreads();
13595 wxPyLogError((wxString const &)*arg1);
13596 wxPyEndAllowThreads(__tstate);
13597 if (PyErr_Occurred()) SWIG_fail;
13598 }
13599 resultobj = SWIG_Py_Void();
13600 {
13601 if (temp1)
13602 delete arg1;
13603 }
13604 return resultobj;
13605 fail:
13606 {
13607 if (temp1)
13608 delete arg1;
13609 }
13610 return NULL;
13611 }
13612
13613
13614 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13615 PyObject *resultobj = 0;
13616 wxString *arg1 = 0 ;
13617 bool temp1 = false ;
13618 PyObject * obj0 = 0 ;
13619 char * kwnames[] = {
13620 (char *) "msg", NULL
13621 };
13622
13623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13624 {
13625 arg1 = wxString_in_helper(obj0);
13626 if (arg1 == NULL) SWIG_fail;
13627 temp1 = true;
13628 }
13629 {
13630 PyThreadState* __tstate = wxPyBeginAllowThreads();
13631 wxPyLogWarning((wxString const &)*arg1);
13632 wxPyEndAllowThreads(__tstate);
13633 if (PyErr_Occurred()) SWIG_fail;
13634 }
13635 resultobj = SWIG_Py_Void();
13636 {
13637 if (temp1)
13638 delete arg1;
13639 }
13640 return resultobj;
13641 fail:
13642 {
13643 if (temp1)
13644 delete arg1;
13645 }
13646 return NULL;
13647 }
13648
13649
13650 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj = 0;
13652 wxString *arg1 = 0 ;
13653 bool temp1 = false ;
13654 PyObject * obj0 = 0 ;
13655 char * kwnames[] = {
13656 (char *) "msg", NULL
13657 };
13658
13659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13660 {
13661 arg1 = wxString_in_helper(obj0);
13662 if (arg1 == NULL) SWIG_fail;
13663 temp1 = true;
13664 }
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 wxPyLogMessage((wxString const &)*arg1);
13668 wxPyEndAllowThreads(__tstate);
13669 if (PyErr_Occurred()) SWIG_fail;
13670 }
13671 resultobj = SWIG_Py_Void();
13672 {
13673 if (temp1)
13674 delete arg1;
13675 }
13676 return resultobj;
13677 fail:
13678 {
13679 if (temp1)
13680 delete arg1;
13681 }
13682 return NULL;
13683 }
13684
13685
13686 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj = 0;
13688 wxString *arg1 = 0 ;
13689 bool temp1 = false ;
13690 PyObject * obj0 = 0 ;
13691 char * kwnames[] = {
13692 (char *) "msg", NULL
13693 };
13694
13695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13696 {
13697 arg1 = wxString_in_helper(obj0);
13698 if (arg1 == NULL) SWIG_fail;
13699 temp1 = true;
13700 }
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 wxPyLogInfo((wxString const &)*arg1);
13704 wxPyEndAllowThreads(__tstate);
13705 if (PyErr_Occurred()) SWIG_fail;
13706 }
13707 resultobj = SWIG_Py_Void();
13708 {
13709 if (temp1)
13710 delete arg1;
13711 }
13712 return resultobj;
13713 fail:
13714 {
13715 if (temp1)
13716 delete arg1;
13717 }
13718 return NULL;
13719 }
13720
13721
13722 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13723 PyObject *resultobj = 0;
13724 wxString *arg1 = 0 ;
13725 bool temp1 = false ;
13726 PyObject * obj0 = 0 ;
13727 char * kwnames[] = {
13728 (char *) "msg", NULL
13729 };
13730
13731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13732 {
13733 arg1 = wxString_in_helper(obj0);
13734 if (arg1 == NULL) SWIG_fail;
13735 temp1 = true;
13736 }
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 wxPyLogDebug((wxString const &)*arg1);
13740 wxPyEndAllowThreads(__tstate);
13741 if (PyErr_Occurred()) SWIG_fail;
13742 }
13743 resultobj = SWIG_Py_Void();
13744 {
13745 if (temp1)
13746 delete arg1;
13747 }
13748 return resultobj;
13749 fail:
13750 {
13751 if (temp1)
13752 delete arg1;
13753 }
13754 return NULL;
13755 }
13756
13757
13758 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13759 PyObject *resultobj = 0;
13760 wxString *arg1 = 0 ;
13761 bool temp1 = false ;
13762 PyObject * obj0 = 0 ;
13763 char * kwnames[] = {
13764 (char *) "msg", NULL
13765 };
13766
13767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13768 {
13769 arg1 = wxString_in_helper(obj0);
13770 if (arg1 == NULL) SWIG_fail;
13771 temp1 = true;
13772 }
13773 {
13774 PyThreadState* __tstate = wxPyBeginAllowThreads();
13775 wxPyLogVerbose((wxString const &)*arg1);
13776 wxPyEndAllowThreads(__tstate);
13777 if (PyErr_Occurred()) SWIG_fail;
13778 }
13779 resultobj = SWIG_Py_Void();
13780 {
13781 if (temp1)
13782 delete arg1;
13783 }
13784 return resultobj;
13785 fail:
13786 {
13787 if (temp1)
13788 delete arg1;
13789 }
13790 return NULL;
13791 }
13792
13793
13794 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13795 PyObject *resultobj = 0;
13796 wxString *arg1 = 0 ;
13797 bool temp1 = false ;
13798 PyObject * obj0 = 0 ;
13799 char * kwnames[] = {
13800 (char *) "msg", NULL
13801 };
13802
13803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13804 {
13805 arg1 = wxString_in_helper(obj0);
13806 if (arg1 == NULL) SWIG_fail;
13807 temp1 = true;
13808 }
13809 {
13810 PyThreadState* __tstate = wxPyBeginAllowThreads();
13811 wxPyLogStatus((wxString const &)*arg1);
13812 wxPyEndAllowThreads(__tstate);
13813 if (PyErr_Occurred()) SWIG_fail;
13814 }
13815 resultobj = SWIG_Py_Void();
13816 {
13817 if (temp1)
13818 delete arg1;
13819 }
13820 return resultobj;
13821 fail:
13822 {
13823 if (temp1)
13824 delete arg1;
13825 }
13826 return NULL;
13827 }
13828
13829
13830 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13831 PyObject *resultobj = 0;
13832 wxFrame *arg1 = (wxFrame *) 0 ;
13833 wxString *arg2 = 0 ;
13834 void *argp1 = 0 ;
13835 int res1 = 0 ;
13836 bool temp2 = false ;
13837 PyObject * obj0 = 0 ;
13838 PyObject * obj1 = 0 ;
13839 char * kwnames[] = {
13840 (char *) "pFrame",(char *) "msg", NULL
13841 };
13842
13843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13845 if (!SWIG_IsOK(res1)) {
13846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13847 }
13848 arg1 = reinterpret_cast< wxFrame * >(argp1);
13849 {
13850 arg2 = wxString_in_helper(obj1);
13851 if (arg2 == NULL) SWIG_fail;
13852 temp2 = true;
13853 }
13854 {
13855 PyThreadState* __tstate = wxPyBeginAllowThreads();
13856 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13857 wxPyEndAllowThreads(__tstate);
13858 if (PyErr_Occurred()) SWIG_fail;
13859 }
13860 resultobj = SWIG_Py_Void();
13861 {
13862 if (temp2)
13863 delete arg2;
13864 }
13865 return resultobj;
13866 fail:
13867 {
13868 if (temp2)
13869 delete arg2;
13870 }
13871 return NULL;
13872 }
13873
13874
13875 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13876 PyObject *resultobj = 0;
13877 wxString *arg1 = 0 ;
13878 bool temp1 = false ;
13879 PyObject * obj0 = 0 ;
13880 char * kwnames[] = {
13881 (char *) "msg", NULL
13882 };
13883
13884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13885 {
13886 arg1 = wxString_in_helper(obj0);
13887 if (arg1 == NULL) SWIG_fail;
13888 temp1 = true;
13889 }
13890 {
13891 PyThreadState* __tstate = wxPyBeginAllowThreads();
13892 wxPyLogSysError((wxString const &)*arg1);
13893 wxPyEndAllowThreads(__tstate);
13894 if (PyErr_Occurred()) SWIG_fail;
13895 }
13896 resultobj = SWIG_Py_Void();
13897 {
13898 if (temp1)
13899 delete arg1;
13900 }
13901 return resultobj;
13902 fail:
13903 {
13904 if (temp1)
13905 delete arg1;
13906 }
13907 return NULL;
13908 }
13909
13910
13911 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13912 PyObject *resultobj = 0;
13913 unsigned long arg1 ;
13914 wxString *arg2 = 0 ;
13915 unsigned long val1 ;
13916 int ecode1 = 0 ;
13917 bool temp2 = false ;
13918 PyObject * obj0 = 0 ;
13919 PyObject * obj1 = 0 ;
13920 char * kwnames[] = {
13921 (char *) "level",(char *) "msg", NULL
13922 };
13923
13924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13925 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13926 if (!SWIG_IsOK(ecode1)) {
13927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13928 }
13929 arg1 = static_cast< unsigned long >(val1);
13930 {
13931 arg2 = wxString_in_helper(obj1);
13932 if (arg2 == NULL) SWIG_fail;
13933 temp2 = true;
13934 }
13935 {
13936 PyThreadState* __tstate = wxPyBeginAllowThreads();
13937 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13938 wxPyEndAllowThreads(__tstate);
13939 if (PyErr_Occurred()) SWIG_fail;
13940 }
13941 resultobj = SWIG_Py_Void();
13942 {
13943 if (temp2)
13944 delete arg2;
13945 }
13946 return resultobj;
13947 fail:
13948 {
13949 if (temp2)
13950 delete arg2;
13951 }
13952 return NULL;
13953 }
13954
13955
13956 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13957 PyObject *resultobj = 0;
13958 unsigned long arg1 ;
13959 wxString *arg2 = 0 ;
13960 unsigned long val1 ;
13961 int ecode1 = 0 ;
13962 bool temp2 = false ;
13963
13964 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13965 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13966 if (!SWIG_IsOK(ecode1)) {
13967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13968 }
13969 arg1 = static_cast< unsigned long >(val1);
13970 {
13971 arg2 = wxString_in_helper(swig_obj[1]);
13972 if (arg2 == NULL) SWIG_fail;
13973 temp2 = true;
13974 }
13975 {
13976 PyThreadState* __tstate = wxPyBeginAllowThreads();
13977 wxPyLogTrace(arg1,(wxString const &)*arg2);
13978 wxPyEndAllowThreads(__tstate);
13979 if (PyErr_Occurred()) SWIG_fail;
13980 }
13981 resultobj = SWIG_Py_Void();
13982 {
13983 if (temp2)
13984 delete arg2;
13985 }
13986 return resultobj;
13987 fail:
13988 {
13989 if (temp2)
13990 delete arg2;
13991 }
13992 return NULL;
13993 }
13994
13995
13996 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13997 PyObject *resultobj = 0;
13998 wxString *arg1 = 0 ;
13999 wxString *arg2 = 0 ;
14000 bool temp1 = false ;
14001 bool temp2 = false ;
14002
14003 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14004 {
14005 arg1 = wxString_in_helper(swig_obj[0]);
14006 if (arg1 == NULL) SWIG_fail;
14007 temp1 = true;
14008 }
14009 {
14010 arg2 = wxString_in_helper(swig_obj[1]);
14011 if (arg2 == NULL) SWIG_fail;
14012 temp2 = true;
14013 }
14014 {
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14017 wxPyEndAllowThreads(__tstate);
14018 if (PyErr_Occurred()) SWIG_fail;
14019 }
14020 resultobj = SWIG_Py_Void();
14021 {
14022 if (temp1)
14023 delete arg1;
14024 }
14025 {
14026 if (temp2)
14027 delete arg2;
14028 }
14029 return resultobj;
14030 fail:
14031 {
14032 if (temp1)
14033 delete arg1;
14034 }
14035 {
14036 if (temp2)
14037 delete arg2;
14038 }
14039 return NULL;
14040 }
14041
14042
14043 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14044 int argc;
14045 PyObject *argv[3];
14046
14047 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14048 --argc;
14049 if (argc == 2) {
14050 int _v = 0;
14051 {
14052 {
14053 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14054 }
14055 }
14056 if (!_v) goto check_1;
14057 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14058 }
14059 check_1:
14060
14061 if (argc == 2) {
14062 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14063 }
14064
14065 fail:
14066 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14067 return NULL;
14068 }
14069
14070
14071 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj = 0;
14073 wxString *arg1 = 0 ;
14074 wxString *arg2 = 0 ;
14075 bool temp1 = false ;
14076 bool temp2 = false ;
14077 PyObject * obj0 = 0 ;
14078 PyObject * obj1 = 0 ;
14079 char * kwnames[] = {
14080 (char *) "title",(char *) "text", NULL
14081 };
14082
14083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14084 {
14085 arg1 = wxString_in_helper(obj0);
14086 if (arg1 == NULL) SWIG_fail;
14087 temp1 = true;
14088 }
14089 {
14090 arg2 = wxString_in_helper(obj1);
14091 if (arg2 == NULL) SWIG_fail;
14092 temp2 = true;
14093 }
14094 {
14095 PyThreadState* __tstate = wxPyBeginAllowThreads();
14096 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14097 wxPyEndAllowThreads(__tstate);
14098 if (PyErr_Occurred()) SWIG_fail;
14099 }
14100 resultobj = SWIG_Py_Void();
14101 {
14102 if (temp1)
14103 delete arg1;
14104 }
14105 {
14106 if (temp2)
14107 delete arg2;
14108 }
14109 return resultobj;
14110 fail:
14111 {
14112 if (temp1)
14113 delete arg1;
14114 }
14115 {
14116 if (temp2)
14117 delete arg2;
14118 }
14119 return NULL;
14120 }
14121
14122
14123 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14124 PyObject *resultobj = 0;
14125 wxLogNull *result = 0 ;
14126
14127 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14128 {
14129 PyThreadState* __tstate = wxPyBeginAllowThreads();
14130 result = (wxLogNull *)new wxLogNull();
14131 wxPyEndAllowThreads(__tstate);
14132 if (PyErr_Occurred()) SWIG_fail;
14133 }
14134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14142 PyObject *resultobj = 0;
14143 wxLogNull *arg1 = (wxLogNull *) 0 ;
14144 void *argp1 = 0 ;
14145 int res1 = 0 ;
14146 PyObject *swig_obj[1] ;
14147
14148 if (!args) SWIG_fail;
14149 swig_obj[0] = args;
14150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14151 if (!SWIG_IsOK(res1)) {
14152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14153 }
14154 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14155 {
14156 PyThreadState* __tstate = wxPyBeginAllowThreads();
14157 delete arg1;
14158
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 resultobj = SWIG_Py_Void();
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14170 PyObject *obj;
14171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14172 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14173 return SWIG_Py_Void();
14174 }
14175
14176 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14177 return SWIG_Python_InitShadowInstance(args);
14178 }
14179
14180 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14181 PyObject *resultobj = 0;
14182 wxPyLog *result = 0 ;
14183
14184 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 result = (wxPyLog *)new wxPyLog();
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj = 0;
14200 wxPyLog *arg1 = (wxPyLog *) 0 ;
14201 PyObject *arg2 = (PyObject *) 0 ;
14202 PyObject *arg3 = (PyObject *) 0 ;
14203 void *argp1 = 0 ;
14204 int res1 = 0 ;
14205 PyObject * obj0 = 0 ;
14206 PyObject * obj1 = 0 ;
14207 PyObject * obj2 = 0 ;
14208 char * kwnames[] = {
14209 (char *) "self",(char *) "self",(char *) "_class", NULL
14210 };
14211
14212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14214 if (!SWIG_IsOK(res1)) {
14215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14216 }
14217 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14218 arg2 = obj1;
14219 arg3 = obj2;
14220 {
14221 PyThreadState* __tstate = wxPyBeginAllowThreads();
14222 (arg1)->_setCallbackInfo(arg2,arg3);
14223 wxPyEndAllowThreads(__tstate);
14224 if (PyErr_Occurred()) SWIG_fail;
14225 }
14226 resultobj = SWIG_Py_Void();
14227 return resultobj;
14228 fail:
14229 return NULL;
14230 }
14231
14232
14233 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14234 PyObject *obj;
14235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14236 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14237 return SWIG_Py_Void();
14238 }
14239
14240 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14241 return SWIG_Python_InitShadowInstance(args);
14242 }
14243
14244 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj = 0;
14246 int arg1 ;
14247 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14248 int arg3 = (int) wxKILL_NOCHILDREN ;
14249 wxKillError result;
14250 int val1 ;
14251 int ecode1 = 0 ;
14252 int val2 ;
14253 int ecode2 = 0 ;
14254 int val3 ;
14255 int ecode3 = 0 ;
14256 PyObject * obj0 = 0 ;
14257 PyObject * obj1 = 0 ;
14258 PyObject * obj2 = 0 ;
14259 char * kwnames[] = {
14260 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14261 };
14262
14263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14264 ecode1 = SWIG_AsVal_int(obj0, &val1);
14265 if (!SWIG_IsOK(ecode1)) {
14266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14267 }
14268 arg1 = static_cast< int >(val1);
14269 if (obj1) {
14270 ecode2 = SWIG_AsVal_int(obj1, &val2);
14271 if (!SWIG_IsOK(ecode2)) {
14272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14273 }
14274 arg2 = static_cast< wxSignal >(val2);
14275 }
14276 if (obj2) {
14277 ecode3 = SWIG_AsVal_int(obj2, &val3);
14278 if (!SWIG_IsOK(ecode3)) {
14279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14280 }
14281 arg3 = static_cast< int >(val3);
14282 }
14283 {
14284 PyThreadState* __tstate = wxPyBeginAllowThreads();
14285 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 resultobj = SWIG_From_int(static_cast< int >(result));
14290 return resultobj;
14291 fail:
14292 return NULL;
14293 }
14294
14295
14296 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14297 PyObject *resultobj = 0;
14298 int arg1 ;
14299 bool result;
14300 int val1 ;
14301 int ecode1 = 0 ;
14302 PyObject * obj0 = 0 ;
14303 char * kwnames[] = {
14304 (char *) "pid", NULL
14305 };
14306
14307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14308 ecode1 = SWIG_AsVal_int(obj0, &val1);
14309 if (!SWIG_IsOK(ecode1)) {
14310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14311 }
14312 arg1 = static_cast< int >(val1);
14313 {
14314 PyThreadState* __tstate = wxPyBeginAllowThreads();
14315 result = (bool)wxPyProcess::Exists(arg1);
14316 wxPyEndAllowThreads(__tstate);
14317 if (PyErr_Occurred()) SWIG_fail;
14318 }
14319 {
14320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14321 }
14322 return resultobj;
14323 fail:
14324 return NULL;
14325 }
14326
14327
14328 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14329 PyObject *resultobj = 0;
14330 wxString *arg1 = 0 ;
14331 int arg2 = (int) wxEXEC_ASYNC ;
14332 wxPyProcess *result = 0 ;
14333 bool temp1 = false ;
14334 int val2 ;
14335 int ecode2 = 0 ;
14336 PyObject * obj0 = 0 ;
14337 PyObject * obj1 = 0 ;
14338 char * kwnames[] = {
14339 (char *) "cmd",(char *) "flags", NULL
14340 };
14341
14342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14343 {
14344 arg1 = wxString_in_helper(obj0);
14345 if (arg1 == NULL) SWIG_fail;
14346 temp1 = true;
14347 }
14348 if (obj1) {
14349 ecode2 = SWIG_AsVal_int(obj1, &val2);
14350 if (!SWIG_IsOK(ecode2)) {
14351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14352 }
14353 arg2 = static_cast< int >(val2);
14354 }
14355 {
14356 PyThreadState* __tstate = wxPyBeginAllowThreads();
14357 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14358 wxPyEndAllowThreads(__tstate);
14359 if (PyErr_Occurred()) SWIG_fail;
14360 }
14361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14362 {
14363 if (temp1)
14364 delete arg1;
14365 }
14366 return resultobj;
14367 fail:
14368 {
14369 if (temp1)
14370 delete arg1;
14371 }
14372 return NULL;
14373 }
14374
14375
14376 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14377 PyObject *resultobj = 0;
14378 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14379 int arg2 = (int) -1 ;
14380 wxPyProcess *result = 0 ;
14381 void *argp1 = 0 ;
14382 int res1 = 0 ;
14383 int val2 ;
14384 int ecode2 = 0 ;
14385 PyObject * obj0 = 0 ;
14386 PyObject * obj1 = 0 ;
14387 char * kwnames[] = {
14388 (char *) "parent",(char *) "id", NULL
14389 };
14390
14391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14392 if (obj0) {
14393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14394 if (!SWIG_IsOK(res1)) {
14395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14396 }
14397 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14398 }
14399 if (obj1) {
14400 ecode2 = SWIG_AsVal_int(obj1, &val2);
14401 if (!SWIG_IsOK(ecode2)) {
14402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14403 }
14404 arg2 = static_cast< int >(val2);
14405 }
14406 {
14407 PyThreadState* __tstate = wxPyBeginAllowThreads();
14408 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14409 wxPyEndAllowThreads(__tstate);
14410 if (PyErr_Occurred()) SWIG_fail;
14411 }
14412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14413 return resultobj;
14414 fail:
14415 return NULL;
14416 }
14417
14418
14419 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14420 PyObject *resultobj = 0;
14421 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14422 void *argp1 = 0 ;
14423 int res1 = 0 ;
14424 PyObject *swig_obj[1] ;
14425
14426 if (!args) SWIG_fail;
14427 swig_obj[0] = args;
14428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14431 }
14432 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14433 {
14434 PyThreadState* __tstate = wxPyBeginAllowThreads();
14435 delete arg1;
14436
14437 wxPyEndAllowThreads(__tstate);
14438 if (PyErr_Occurred()) SWIG_fail;
14439 }
14440 resultobj = SWIG_Py_Void();
14441 return resultobj;
14442 fail:
14443 return NULL;
14444 }
14445
14446
14447 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14448 PyObject *resultobj = 0;
14449 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14450 long result;
14451 void *argp1 = 0 ;
14452 int res1 = 0 ;
14453 PyObject *swig_obj[1] ;
14454
14455 if (!args) SWIG_fail;
14456 swig_obj[0] = args;
14457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14458 if (!SWIG_IsOK(res1)) {
14459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14460 }
14461 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14462 {
14463 PyThreadState* __tstate = wxPyBeginAllowThreads();
14464 result = (long)((wxPyProcess const *)arg1)->GetPid();
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 resultobj = SWIG_From_long(static_cast< long >(result));
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj = 0;
14477 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14478 PyObject *arg2 = (PyObject *) 0 ;
14479 PyObject *arg3 = (PyObject *) 0 ;
14480 void *argp1 = 0 ;
14481 int res1 = 0 ;
14482 PyObject * obj0 = 0 ;
14483 PyObject * obj1 = 0 ;
14484 PyObject * obj2 = 0 ;
14485 char * kwnames[] = {
14486 (char *) "self",(char *) "self",(char *) "_class", NULL
14487 };
14488
14489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14493 }
14494 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14495 arg2 = obj1;
14496 arg3 = obj2;
14497 {
14498 PyThreadState* __tstate = wxPyBeginAllowThreads();
14499 (arg1)->_setCallbackInfo(arg2,arg3);
14500 wxPyEndAllowThreads(__tstate);
14501 if (PyErr_Occurred()) SWIG_fail;
14502 }
14503 resultobj = SWIG_Py_Void();
14504 return resultobj;
14505 fail:
14506 return NULL;
14507 }
14508
14509
14510 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14511 PyObject *resultobj = 0;
14512 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14513 int arg2 ;
14514 int arg3 ;
14515 void *argp1 = 0 ;
14516 int res1 = 0 ;
14517 int val2 ;
14518 int ecode2 = 0 ;
14519 int val3 ;
14520 int ecode3 = 0 ;
14521 PyObject * obj0 = 0 ;
14522 PyObject * obj1 = 0 ;
14523 PyObject * obj2 = 0 ;
14524 char * kwnames[] = {
14525 (char *) "self",(char *) "pid",(char *) "status", NULL
14526 };
14527
14528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14530 if (!SWIG_IsOK(res1)) {
14531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14532 }
14533 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14534 ecode2 = SWIG_AsVal_int(obj1, &val2);
14535 if (!SWIG_IsOK(ecode2)) {
14536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14537 }
14538 arg2 = static_cast< int >(val2);
14539 ecode3 = SWIG_AsVal_int(obj2, &val3);
14540 if (!SWIG_IsOK(ecode3)) {
14541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14542 }
14543 arg3 = static_cast< int >(val3);
14544 {
14545 PyThreadState* __tstate = wxPyBeginAllowThreads();
14546 (arg1)->OnTerminate(arg2,arg3);
14547 wxPyEndAllowThreads(__tstate);
14548 if (PyErr_Occurred()) SWIG_fail;
14549 }
14550 resultobj = SWIG_Py_Void();
14551 return resultobj;
14552 fail:
14553 return NULL;
14554 }
14555
14556
14557 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14558 PyObject *resultobj = 0;
14559 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14560 void *argp1 = 0 ;
14561 int res1 = 0 ;
14562 PyObject *swig_obj[1] ;
14563
14564 if (!args) SWIG_fail;
14565 swig_obj[0] = args;
14566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14567 if (!SWIG_IsOK(res1)) {
14568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14569 }
14570 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14571 {
14572 PyThreadState* __tstate = wxPyBeginAllowThreads();
14573 (arg1)->Redirect();
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 resultobj = SWIG_Py_Void();
14578 return resultobj;
14579 fail:
14580 return NULL;
14581 }
14582
14583
14584 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14585 PyObject *resultobj = 0;
14586 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14587 bool result;
14588 void *argp1 = 0 ;
14589 int res1 = 0 ;
14590 PyObject *swig_obj[1] ;
14591
14592 if (!args) SWIG_fail;
14593 swig_obj[0] = args;
14594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14595 if (!SWIG_IsOK(res1)) {
14596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14597 }
14598 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14599 {
14600 PyThreadState* __tstate = wxPyBeginAllowThreads();
14601 result = (bool)(arg1)->IsRedirected();
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 {
14606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14607 }
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14615 PyObject *resultobj = 0;
14616 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14617 void *argp1 = 0 ;
14618 int res1 = 0 ;
14619 PyObject *swig_obj[1] ;
14620
14621 if (!args) SWIG_fail;
14622 swig_obj[0] = args;
14623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14624 if (!SWIG_IsOK(res1)) {
14625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14626 }
14627 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 (arg1)->Detach();
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 resultobj = SWIG_Py_Void();
14635 return resultobj;
14636 fail:
14637 return NULL;
14638 }
14639
14640
14641 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14642 PyObject *resultobj = 0;
14643 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14644 wxInputStream *result = 0 ;
14645 void *argp1 = 0 ;
14646 int res1 = 0 ;
14647 PyObject *swig_obj[1] ;
14648
14649 if (!args) SWIG_fail;
14650 swig_obj[0] = args;
14651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14652 if (!SWIG_IsOK(res1)) {
14653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14654 }
14655 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 result = (wxInputStream *)(arg1)->GetInputStream();
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 {
14663 wxPyInputStream * _ptr = NULL;
14664
14665 if (result) {
14666 _ptr = new wxPyInputStream(result);
14667 }
14668 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14669 }
14670 return resultobj;
14671 fail:
14672 return NULL;
14673 }
14674
14675
14676 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14677 PyObject *resultobj = 0;
14678 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14679 wxInputStream *result = 0 ;
14680 void *argp1 = 0 ;
14681 int res1 = 0 ;
14682 PyObject *swig_obj[1] ;
14683
14684 if (!args) SWIG_fail;
14685 swig_obj[0] = args;
14686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14687 if (!SWIG_IsOK(res1)) {
14688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14689 }
14690 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 result = (wxInputStream *)(arg1)->GetErrorStream();
14694 wxPyEndAllowThreads(__tstate);
14695 if (PyErr_Occurred()) SWIG_fail;
14696 }
14697 {
14698 wxPyInputStream * _ptr = NULL;
14699
14700 if (result) {
14701 _ptr = new wxPyInputStream(result);
14702 }
14703 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14704 }
14705 return resultobj;
14706 fail:
14707 return NULL;
14708 }
14709
14710
14711 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14712 PyObject *resultobj = 0;
14713 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14714 wxOutputStream *result = 0 ;
14715 void *argp1 = 0 ;
14716 int res1 = 0 ;
14717 PyObject *swig_obj[1] ;
14718
14719 if (!args) SWIG_fail;
14720 swig_obj[0] = args;
14721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14722 if (!SWIG_IsOK(res1)) {
14723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14724 }
14725 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14726 {
14727 PyThreadState* __tstate = wxPyBeginAllowThreads();
14728 result = (wxOutputStream *)(arg1)->GetOutputStream();
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14733 return resultobj;
14734 fail:
14735 return NULL;
14736 }
14737
14738
14739 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14740 PyObject *resultobj = 0;
14741 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14742 void *argp1 = 0 ;
14743 int res1 = 0 ;
14744 PyObject *swig_obj[1] ;
14745
14746 if (!args) SWIG_fail;
14747 swig_obj[0] = args;
14748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14749 if (!SWIG_IsOK(res1)) {
14750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14751 }
14752 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14753 {
14754 PyThreadState* __tstate = wxPyBeginAllowThreads();
14755 (arg1)->CloseOutput();
14756 wxPyEndAllowThreads(__tstate);
14757 if (PyErr_Occurred()) SWIG_fail;
14758 }
14759 resultobj = SWIG_Py_Void();
14760 return resultobj;
14761 fail:
14762 return NULL;
14763 }
14764
14765
14766 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14767 PyObject *resultobj = 0;
14768 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14769 bool result;
14770 void *argp1 = 0 ;
14771 int res1 = 0 ;
14772 PyObject *swig_obj[1] ;
14773
14774 if (!args) SWIG_fail;
14775 swig_obj[0] = args;
14776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14777 if (!SWIG_IsOK(res1)) {
14778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14779 }
14780 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 {
14788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14789 }
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14797 PyObject *resultobj = 0;
14798 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14799 bool result;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 PyObject *swig_obj[1] ;
14803
14804 if (!args) SWIG_fail;
14805 swig_obj[0] = args;
14806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14807 if (!SWIG_IsOK(res1)) {
14808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14809 }
14810 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14811 {
14812 PyThreadState* __tstate = wxPyBeginAllowThreads();
14813 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 {
14818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14819 }
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14827 PyObject *resultobj = 0;
14828 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14829 bool result;
14830 void *argp1 = 0 ;
14831 int res1 = 0 ;
14832 PyObject *swig_obj[1] ;
14833
14834 if (!args) SWIG_fail;
14835 swig_obj[0] = args;
14836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14837 if (!SWIG_IsOK(res1)) {
14838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14839 }
14840 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 {
14848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14849 }
14850 return resultobj;
14851 fail:
14852 return NULL;
14853 }
14854
14855
14856 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14857 PyObject *obj;
14858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14859 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14860 return SWIG_Py_Void();
14861 }
14862
14863 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14864 return SWIG_Python_InitShadowInstance(args);
14865 }
14866
14867 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14868 PyObject *resultobj = 0;
14869 int arg1 = (int) 0 ;
14870 int arg2 = (int) 0 ;
14871 int arg3 = (int) 0 ;
14872 wxProcessEvent *result = 0 ;
14873 int val1 ;
14874 int ecode1 = 0 ;
14875 int val2 ;
14876 int ecode2 = 0 ;
14877 int val3 ;
14878 int ecode3 = 0 ;
14879 PyObject * obj0 = 0 ;
14880 PyObject * obj1 = 0 ;
14881 PyObject * obj2 = 0 ;
14882 char * kwnames[] = {
14883 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14884 };
14885
14886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14887 if (obj0) {
14888 ecode1 = SWIG_AsVal_int(obj0, &val1);
14889 if (!SWIG_IsOK(ecode1)) {
14890 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14891 }
14892 arg1 = static_cast< int >(val1);
14893 }
14894 if (obj1) {
14895 ecode2 = SWIG_AsVal_int(obj1, &val2);
14896 if (!SWIG_IsOK(ecode2)) {
14897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14898 }
14899 arg2 = static_cast< int >(val2);
14900 }
14901 if (obj2) {
14902 ecode3 = SWIG_AsVal_int(obj2, &val3);
14903 if (!SWIG_IsOK(ecode3)) {
14904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14905 }
14906 arg3 = static_cast< int >(val3);
14907 }
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14911 wxPyEndAllowThreads(__tstate);
14912 if (PyErr_Occurred()) SWIG_fail;
14913 }
14914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14915 return resultobj;
14916 fail:
14917 return NULL;
14918 }
14919
14920
14921 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14922 PyObject *resultobj = 0;
14923 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14924 int result;
14925 void *argp1 = 0 ;
14926 int res1 = 0 ;
14927 PyObject *swig_obj[1] ;
14928
14929 if (!args) SWIG_fail;
14930 swig_obj[0] = args;
14931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14932 if (!SWIG_IsOK(res1)) {
14933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14934 }
14935 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14936 {
14937 PyThreadState* __tstate = wxPyBeginAllowThreads();
14938 result = (int)(arg1)->GetPid();
14939 wxPyEndAllowThreads(__tstate);
14940 if (PyErr_Occurred()) SWIG_fail;
14941 }
14942 resultobj = SWIG_From_int(static_cast< int >(result));
14943 return resultobj;
14944 fail:
14945 return NULL;
14946 }
14947
14948
14949 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14950 PyObject *resultobj = 0;
14951 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14952 int result;
14953 void *argp1 = 0 ;
14954 int res1 = 0 ;
14955 PyObject *swig_obj[1] ;
14956
14957 if (!args) SWIG_fail;
14958 swig_obj[0] = args;
14959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14960 if (!SWIG_IsOK(res1)) {
14961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14962 }
14963 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14964 {
14965 PyThreadState* __tstate = wxPyBeginAllowThreads();
14966 result = (int)(arg1)->GetExitCode();
14967 wxPyEndAllowThreads(__tstate);
14968 if (PyErr_Occurred()) SWIG_fail;
14969 }
14970 resultobj = SWIG_From_int(static_cast< int >(result));
14971 return resultobj;
14972 fail:
14973 return NULL;
14974 }
14975
14976
14977 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14978 PyObject *resultobj = 0;
14979 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14980 int arg2 ;
14981 void *argp1 = 0 ;
14982 int res1 = 0 ;
14983 int val2 ;
14984 int ecode2 = 0 ;
14985 PyObject *swig_obj[2] ;
14986
14987 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14989 if (!SWIG_IsOK(res1)) {
14990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14991 }
14992 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14993 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14994 if (!SWIG_IsOK(ecode2)) {
14995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14996 }
14997 arg2 = static_cast< int >(val2);
14998 if (arg1) (arg1)->m_pid = arg2;
14999
15000 resultobj = SWIG_Py_Void();
15001 return resultobj;
15002 fail:
15003 return NULL;
15004 }
15005
15006
15007 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15008 PyObject *resultobj = 0;
15009 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15010 int result;
15011 void *argp1 = 0 ;
15012 int res1 = 0 ;
15013 PyObject *swig_obj[1] ;
15014
15015 if (!args) SWIG_fail;
15016 swig_obj[0] = args;
15017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15018 if (!SWIG_IsOK(res1)) {
15019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15020 }
15021 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15022 result = (int) ((arg1)->m_pid);
15023 resultobj = SWIG_From_int(static_cast< int >(result));
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15031 PyObject *resultobj = 0;
15032 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15033 int arg2 ;
15034 void *argp1 = 0 ;
15035 int res1 = 0 ;
15036 int val2 ;
15037 int ecode2 = 0 ;
15038 PyObject *swig_obj[2] ;
15039
15040 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15042 if (!SWIG_IsOK(res1)) {
15043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15044 }
15045 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15046 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15047 if (!SWIG_IsOK(ecode2)) {
15048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15049 }
15050 arg2 = static_cast< int >(val2);
15051 if (arg1) (arg1)->m_exitcode = arg2;
15052
15053 resultobj = SWIG_Py_Void();
15054 return resultobj;
15055 fail:
15056 return NULL;
15057 }
15058
15059
15060 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15061 PyObject *resultobj = 0;
15062 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15063 int result;
15064 void *argp1 = 0 ;
15065 int res1 = 0 ;
15066 PyObject *swig_obj[1] ;
15067
15068 if (!args) SWIG_fail;
15069 swig_obj[0] = args;
15070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15071 if (!SWIG_IsOK(res1)) {
15072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15073 }
15074 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15075 result = (int) ((arg1)->m_exitcode);
15076 resultobj = SWIG_From_int(static_cast< int >(result));
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15084 PyObject *obj;
15085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15086 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15087 return SWIG_Py_Void();
15088 }
15089
15090 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15091 return SWIG_Python_InitShadowInstance(args);
15092 }
15093
15094 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15095 PyObject *resultobj = 0;
15096 wxString *arg1 = 0 ;
15097 int arg2 = (int) wxEXEC_ASYNC ;
15098 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15099 long result;
15100 bool temp1 = false ;
15101 int val2 ;
15102 int ecode2 = 0 ;
15103 void *argp3 = 0 ;
15104 int res3 = 0 ;
15105 PyObject * obj0 = 0 ;
15106 PyObject * obj1 = 0 ;
15107 PyObject * obj2 = 0 ;
15108 char * kwnames[] = {
15109 (char *) "command",(char *) "flags",(char *) "process", NULL
15110 };
15111
15112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15113 {
15114 arg1 = wxString_in_helper(obj0);
15115 if (arg1 == NULL) SWIG_fail;
15116 temp1 = true;
15117 }
15118 if (obj1) {
15119 ecode2 = SWIG_AsVal_int(obj1, &val2);
15120 if (!SWIG_IsOK(ecode2)) {
15121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15122 }
15123 arg2 = static_cast< int >(val2);
15124 }
15125 if (obj2) {
15126 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15127 if (!SWIG_IsOK(res3)) {
15128 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15129 }
15130 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15131 }
15132 {
15133 if (!wxPyCheckForApp()) SWIG_fail;
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 resultobj = SWIG_From_long(static_cast< long >(result));
15140 {
15141 if (temp1)
15142 delete arg1;
15143 }
15144 return resultobj;
15145 fail:
15146 {
15147 if (temp1)
15148 delete arg1;
15149 }
15150 return NULL;
15151 }
15152
15153
15154 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15155 PyObject *resultobj = 0;
15156 long arg1 ;
15157 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15158 wxKillError *arg3 = (wxKillError *) 0 ;
15159 int arg4 = (int) wxKILL_NOCHILDREN ;
15160 int result;
15161 long val1 ;
15162 int ecode1 = 0 ;
15163 int val2 ;
15164 int ecode2 = 0 ;
15165 wxKillError temp3 ;
15166 int val4 ;
15167 int ecode4 = 0 ;
15168 PyObject * obj0 = 0 ;
15169 PyObject * obj1 = 0 ;
15170 PyObject * obj2 = 0 ;
15171 char * kwnames[] = {
15172 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15173 };
15174
15175 {
15176 arg3 = &temp3;
15177 }
15178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15179 ecode1 = SWIG_AsVal_long(obj0, &val1);
15180 if (!SWIG_IsOK(ecode1)) {
15181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15182 }
15183 arg1 = static_cast< long >(val1);
15184 if (obj1) {
15185 ecode2 = SWIG_AsVal_int(obj1, &val2);
15186 if (!SWIG_IsOK(ecode2)) {
15187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15188 }
15189 arg2 = static_cast< wxSignal >(val2);
15190 }
15191 if (obj2) {
15192 ecode4 = SWIG_AsVal_int(obj2, &val4);
15193 if (!SWIG_IsOK(ecode4)) {
15194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15195 }
15196 arg4 = static_cast< int >(val4);
15197 }
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = (int)wxKill(arg1,arg2,arg3,arg4);
15201 wxPyEndAllowThreads(__tstate);
15202 if (PyErr_Occurred()) SWIG_fail;
15203 }
15204 resultobj = SWIG_From_int(static_cast< int >(result));
15205 {
15206 PyObject* o;
15207 o = PyInt_FromLong((long) (*arg3));
15208
15209
15210
15211 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15212
15213 }
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj = 0;
15222 int arg1 = (int) wxJOYSTICK1 ;
15223 wxJoystick *result = 0 ;
15224 int val1 ;
15225 int ecode1 = 0 ;
15226 PyObject * obj0 = 0 ;
15227 char * kwnames[] = {
15228 (char *) "joystick", NULL
15229 };
15230
15231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15232 if (obj0) {
15233 ecode1 = SWIG_AsVal_int(obj0, &val1);
15234 if (!SWIG_IsOK(ecode1)) {
15235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15236 }
15237 arg1 = static_cast< int >(val1);
15238 }
15239 {
15240 if (!wxPyCheckForApp()) SWIG_fail;
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 result = (wxJoystick *)new wxJoystick(arg1);
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15247 return resultobj;
15248 fail:
15249 return NULL;
15250 }
15251
15252
15253 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15254 PyObject *resultobj = 0;
15255 wxJoystick *arg1 = (wxJoystick *) 0 ;
15256 void *argp1 = 0 ;
15257 int res1 = 0 ;
15258 PyObject *swig_obj[1] ;
15259
15260 if (!args) SWIG_fail;
15261 swig_obj[0] = args;
15262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15263 if (!SWIG_IsOK(res1)) {
15264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15265 }
15266 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15267 {
15268 PyThreadState* __tstate = wxPyBeginAllowThreads();
15269 delete arg1;
15270
15271 wxPyEndAllowThreads(__tstate);
15272 if (PyErr_Occurred()) SWIG_fail;
15273 }
15274 resultobj = SWIG_Py_Void();
15275 return resultobj;
15276 fail:
15277 return NULL;
15278 }
15279
15280
15281 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15282 PyObject *resultobj = 0;
15283 wxJoystick *arg1 = (wxJoystick *) 0 ;
15284 wxPoint result;
15285 void *argp1 = 0 ;
15286 int res1 = 0 ;
15287 PyObject *swig_obj[1] ;
15288
15289 if (!args) SWIG_fail;
15290 swig_obj[0] = args;
15291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15292 if (!SWIG_IsOK(res1)) {
15293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15294 }
15295 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15296 {
15297 PyThreadState* __tstate = wxPyBeginAllowThreads();
15298 result = (arg1)->GetPosition();
15299 wxPyEndAllowThreads(__tstate);
15300 if (PyErr_Occurred()) SWIG_fail;
15301 }
15302 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15303 return resultobj;
15304 fail:
15305 return NULL;
15306 }
15307
15308
15309 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15310 PyObject *resultobj = 0;
15311 wxJoystick *arg1 = (wxJoystick *) 0 ;
15312 int result;
15313 void *argp1 = 0 ;
15314 int res1 = 0 ;
15315 PyObject *swig_obj[1] ;
15316
15317 if (!args) SWIG_fail;
15318 swig_obj[0] = args;
15319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15320 if (!SWIG_IsOK(res1)) {
15321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15322 }
15323 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15324 {
15325 PyThreadState* __tstate = wxPyBeginAllowThreads();
15326 result = (int)(arg1)->GetZPosition();
15327 wxPyEndAllowThreads(__tstate);
15328 if (PyErr_Occurred()) SWIG_fail;
15329 }
15330 resultobj = SWIG_From_int(static_cast< int >(result));
15331 return resultobj;
15332 fail:
15333 return NULL;
15334 }
15335
15336
15337 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15338 PyObject *resultobj = 0;
15339 wxJoystick *arg1 = (wxJoystick *) 0 ;
15340 int result;
15341 void *argp1 = 0 ;
15342 int res1 = 0 ;
15343 PyObject *swig_obj[1] ;
15344
15345 if (!args) SWIG_fail;
15346 swig_obj[0] = args;
15347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15348 if (!SWIG_IsOK(res1)) {
15349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15350 }
15351 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 result = (int)(arg1)->GetButtonState();
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 resultobj = SWIG_From_int(static_cast< int >(result));
15359 return resultobj;
15360 fail:
15361 return NULL;
15362 }
15363
15364
15365 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15366 PyObject *resultobj = 0;
15367 wxJoystick *arg1 = (wxJoystick *) 0 ;
15368 int result;
15369 void *argp1 = 0 ;
15370 int res1 = 0 ;
15371 PyObject *swig_obj[1] ;
15372
15373 if (!args) SWIG_fail;
15374 swig_obj[0] = args;
15375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15376 if (!SWIG_IsOK(res1)) {
15377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15378 }
15379 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15380 {
15381 PyThreadState* __tstate = wxPyBeginAllowThreads();
15382 result = (int)(arg1)->GetPOVPosition();
15383 wxPyEndAllowThreads(__tstate);
15384 if (PyErr_Occurred()) SWIG_fail;
15385 }
15386 resultobj = SWIG_From_int(static_cast< int >(result));
15387 return resultobj;
15388 fail:
15389 return NULL;
15390 }
15391
15392
15393 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15394 PyObject *resultobj = 0;
15395 wxJoystick *arg1 = (wxJoystick *) 0 ;
15396 int result;
15397 void *argp1 = 0 ;
15398 int res1 = 0 ;
15399 PyObject *swig_obj[1] ;
15400
15401 if (!args) SWIG_fail;
15402 swig_obj[0] = args;
15403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15404 if (!SWIG_IsOK(res1)) {
15405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15406 }
15407 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15408 {
15409 PyThreadState* __tstate = wxPyBeginAllowThreads();
15410 result = (int)(arg1)->GetPOVCTSPosition();
15411 wxPyEndAllowThreads(__tstate);
15412 if (PyErr_Occurred()) SWIG_fail;
15413 }
15414 resultobj = SWIG_From_int(static_cast< int >(result));
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15422 PyObject *resultobj = 0;
15423 wxJoystick *arg1 = (wxJoystick *) 0 ;
15424 int result;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 PyObject *swig_obj[1] ;
15428
15429 if (!args) SWIG_fail;
15430 swig_obj[0] = args;
15431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15432 if (!SWIG_IsOK(res1)) {
15433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15434 }
15435 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 result = (int)(arg1)->GetRudderPosition();
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 resultobj = SWIG_From_int(static_cast< int >(result));
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15450 PyObject *resultobj = 0;
15451 wxJoystick *arg1 = (wxJoystick *) 0 ;
15452 int result;
15453 void *argp1 = 0 ;
15454 int res1 = 0 ;
15455 PyObject *swig_obj[1] ;
15456
15457 if (!args) SWIG_fail;
15458 swig_obj[0] = args;
15459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15460 if (!SWIG_IsOK(res1)) {
15461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15462 }
15463 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15464 {
15465 PyThreadState* __tstate = wxPyBeginAllowThreads();
15466 result = (int)(arg1)->GetUPosition();
15467 wxPyEndAllowThreads(__tstate);
15468 if (PyErr_Occurred()) SWIG_fail;
15469 }
15470 resultobj = SWIG_From_int(static_cast< int >(result));
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15478 PyObject *resultobj = 0;
15479 wxJoystick *arg1 = (wxJoystick *) 0 ;
15480 int result;
15481 void *argp1 = 0 ;
15482 int res1 = 0 ;
15483 PyObject *swig_obj[1] ;
15484
15485 if (!args) SWIG_fail;
15486 swig_obj[0] = args;
15487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15490 }
15491 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (int)(arg1)->GetVPosition();
15495 wxPyEndAllowThreads(__tstate);
15496 if (PyErr_Occurred()) SWIG_fail;
15497 }
15498 resultobj = SWIG_From_int(static_cast< int >(result));
15499 return resultobj;
15500 fail:
15501 return NULL;
15502 }
15503
15504
15505 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15506 PyObject *resultobj = 0;
15507 wxJoystick *arg1 = (wxJoystick *) 0 ;
15508 int result;
15509 void *argp1 = 0 ;
15510 int res1 = 0 ;
15511 PyObject *swig_obj[1] ;
15512
15513 if (!args) SWIG_fail;
15514 swig_obj[0] = args;
15515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15516 if (!SWIG_IsOK(res1)) {
15517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15518 }
15519 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15520 {
15521 PyThreadState* __tstate = wxPyBeginAllowThreads();
15522 result = (int)(arg1)->GetMovementThreshold();
15523 wxPyEndAllowThreads(__tstate);
15524 if (PyErr_Occurred()) SWIG_fail;
15525 }
15526 resultobj = SWIG_From_int(static_cast< int >(result));
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15534 PyObject *resultobj = 0;
15535 wxJoystick *arg1 = (wxJoystick *) 0 ;
15536 int arg2 ;
15537 void *argp1 = 0 ;
15538 int res1 = 0 ;
15539 int val2 ;
15540 int ecode2 = 0 ;
15541 PyObject * obj0 = 0 ;
15542 PyObject * obj1 = 0 ;
15543 char * kwnames[] = {
15544 (char *) "self",(char *) "threshold", NULL
15545 };
15546
15547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15549 if (!SWIG_IsOK(res1)) {
15550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15551 }
15552 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15553 ecode2 = SWIG_AsVal_int(obj1, &val2);
15554 if (!SWIG_IsOK(ecode2)) {
15555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15556 }
15557 arg2 = static_cast< int >(val2);
15558 {
15559 PyThreadState* __tstate = wxPyBeginAllowThreads();
15560 (arg1)->SetMovementThreshold(arg2);
15561 wxPyEndAllowThreads(__tstate);
15562 if (PyErr_Occurred()) SWIG_fail;
15563 }
15564 resultobj = SWIG_Py_Void();
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15572 PyObject *resultobj = 0;
15573 wxJoystick *arg1 = (wxJoystick *) 0 ;
15574 bool result;
15575 void *argp1 = 0 ;
15576 int res1 = 0 ;
15577 PyObject *swig_obj[1] ;
15578
15579 if (!args) SWIG_fail;
15580 swig_obj[0] = args;
15581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15582 if (!SWIG_IsOK(res1)) {
15583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15584 }
15585 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15586 {
15587 PyThreadState* __tstate = wxPyBeginAllowThreads();
15588 result = (bool)(arg1)->IsOk();
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 {
15593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15594 }
15595 return resultobj;
15596 fail:
15597 return NULL;
15598 }
15599
15600
15601 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15602 PyObject *resultobj = 0;
15603 wxJoystick *arg1 = (wxJoystick *) 0 ;
15604 int result;
15605 void *argp1 = 0 ;
15606 int res1 = 0 ;
15607 PyObject *swig_obj[1] ;
15608
15609 if (!args) SWIG_fail;
15610 swig_obj[0] = args;
15611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15612 if (!SWIG_IsOK(res1)) {
15613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15614 }
15615 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15616 {
15617 PyThreadState* __tstate = wxPyBeginAllowThreads();
15618 result = (int)(arg1)->GetNumberJoysticks();
15619 wxPyEndAllowThreads(__tstate);
15620 if (PyErr_Occurred()) SWIG_fail;
15621 }
15622 resultobj = SWIG_From_int(static_cast< int >(result));
15623 return resultobj;
15624 fail:
15625 return NULL;
15626 }
15627
15628
15629 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15630 PyObject *resultobj = 0;
15631 wxJoystick *arg1 = (wxJoystick *) 0 ;
15632 int result;
15633 void *argp1 = 0 ;
15634 int res1 = 0 ;
15635 PyObject *swig_obj[1] ;
15636
15637 if (!args) SWIG_fail;
15638 swig_obj[0] = args;
15639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15640 if (!SWIG_IsOK(res1)) {
15641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15642 }
15643 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15644 {
15645 PyThreadState* __tstate = wxPyBeginAllowThreads();
15646 result = (int)(arg1)->GetManufacturerId();
15647 wxPyEndAllowThreads(__tstate);
15648 if (PyErr_Occurred()) SWIG_fail;
15649 }
15650 resultobj = SWIG_From_int(static_cast< int >(result));
15651 return resultobj;
15652 fail:
15653 return NULL;
15654 }
15655
15656
15657 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15658 PyObject *resultobj = 0;
15659 wxJoystick *arg1 = (wxJoystick *) 0 ;
15660 int result;
15661 void *argp1 = 0 ;
15662 int res1 = 0 ;
15663 PyObject *swig_obj[1] ;
15664
15665 if (!args) SWIG_fail;
15666 swig_obj[0] = args;
15667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15668 if (!SWIG_IsOK(res1)) {
15669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15670 }
15671 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15672 {
15673 PyThreadState* __tstate = wxPyBeginAllowThreads();
15674 result = (int)(arg1)->GetProductId();
15675 wxPyEndAllowThreads(__tstate);
15676 if (PyErr_Occurred()) SWIG_fail;
15677 }
15678 resultobj = SWIG_From_int(static_cast< int >(result));
15679 return resultobj;
15680 fail:
15681 return NULL;
15682 }
15683
15684
15685 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15686 PyObject *resultobj = 0;
15687 wxJoystick *arg1 = (wxJoystick *) 0 ;
15688 wxString result;
15689 void *argp1 = 0 ;
15690 int res1 = 0 ;
15691 PyObject *swig_obj[1] ;
15692
15693 if (!args) SWIG_fail;
15694 swig_obj[0] = args;
15695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15696 if (!SWIG_IsOK(res1)) {
15697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15698 }
15699 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15700 {
15701 PyThreadState* __tstate = wxPyBeginAllowThreads();
15702 result = (arg1)->GetProductName();
15703 wxPyEndAllowThreads(__tstate);
15704 if (PyErr_Occurred()) SWIG_fail;
15705 }
15706 {
15707 #if wxUSE_UNICODE
15708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15709 #else
15710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15711 #endif
15712 }
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15720 PyObject *resultobj = 0;
15721 wxJoystick *arg1 = (wxJoystick *) 0 ;
15722 int result;
15723 void *argp1 = 0 ;
15724 int res1 = 0 ;
15725 PyObject *swig_obj[1] ;
15726
15727 if (!args) SWIG_fail;
15728 swig_obj[0] = args;
15729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15730 if (!SWIG_IsOK(res1)) {
15731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15732 }
15733 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15734 {
15735 PyThreadState* __tstate = wxPyBeginAllowThreads();
15736 result = (int)(arg1)->GetXMin();
15737 wxPyEndAllowThreads(__tstate);
15738 if (PyErr_Occurred()) SWIG_fail;
15739 }
15740 resultobj = SWIG_From_int(static_cast< int >(result));
15741 return resultobj;
15742 fail:
15743 return NULL;
15744 }
15745
15746
15747 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15748 PyObject *resultobj = 0;
15749 wxJoystick *arg1 = (wxJoystick *) 0 ;
15750 int result;
15751 void *argp1 = 0 ;
15752 int res1 = 0 ;
15753 PyObject *swig_obj[1] ;
15754
15755 if (!args) SWIG_fail;
15756 swig_obj[0] = args;
15757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15758 if (!SWIG_IsOK(res1)) {
15759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15760 }
15761 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15762 {
15763 PyThreadState* __tstate = wxPyBeginAllowThreads();
15764 result = (int)(arg1)->GetYMin();
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 resultobj = SWIG_From_int(static_cast< int >(result));
15769 return resultobj;
15770 fail:
15771 return NULL;
15772 }
15773
15774
15775 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15776 PyObject *resultobj = 0;
15777 wxJoystick *arg1 = (wxJoystick *) 0 ;
15778 int result;
15779 void *argp1 = 0 ;
15780 int res1 = 0 ;
15781 PyObject *swig_obj[1] ;
15782
15783 if (!args) SWIG_fail;
15784 swig_obj[0] = args;
15785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15786 if (!SWIG_IsOK(res1)) {
15787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15788 }
15789 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15790 {
15791 PyThreadState* __tstate = wxPyBeginAllowThreads();
15792 result = (int)(arg1)->GetZMin();
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 resultobj = SWIG_From_int(static_cast< int >(result));
15797 return resultobj;
15798 fail:
15799 return NULL;
15800 }
15801
15802
15803 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15804 PyObject *resultobj = 0;
15805 wxJoystick *arg1 = (wxJoystick *) 0 ;
15806 int result;
15807 void *argp1 = 0 ;
15808 int res1 = 0 ;
15809 PyObject *swig_obj[1] ;
15810
15811 if (!args) SWIG_fail;
15812 swig_obj[0] = args;
15813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15814 if (!SWIG_IsOK(res1)) {
15815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15816 }
15817 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15818 {
15819 PyThreadState* __tstate = wxPyBeginAllowThreads();
15820 result = (int)(arg1)->GetXMax();
15821 wxPyEndAllowThreads(__tstate);
15822 if (PyErr_Occurred()) SWIG_fail;
15823 }
15824 resultobj = SWIG_From_int(static_cast< int >(result));
15825 return resultobj;
15826 fail:
15827 return NULL;
15828 }
15829
15830
15831 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15832 PyObject *resultobj = 0;
15833 wxJoystick *arg1 = (wxJoystick *) 0 ;
15834 int result;
15835 void *argp1 = 0 ;
15836 int res1 = 0 ;
15837 PyObject *swig_obj[1] ;
15838
15839 if (!args) SWIG_fail;
15840 swig_obj[0] = args;
15841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15842 if (!SWIG_IsOK(res1)) {
15843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15844 }
15845 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15846 {
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 result = (int)(arg1)->GetYMax();
15849 wxPyEndAllowThreads(__tstate);
15850 if (PyErr_Occurred()) SWIG_fail;
15851 }
15852 resultobj = SWIG_From_int(static_cast< int >(result));
15853 return resultobj;
15854 fail:
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15860 PyObject *resultobj = 0;
15861 wxJoystick *arg1 = (wxJoystick *) 0 ;
15862 int result;
15863 void *argp1 = 0 ;
15864 int res1 = 0 ;
15865 PyObject *swig_obj[1] ;
15866
15867 if (!args) SWIG_fail;
15868 swig_obj[0] = args;
15869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15870 if (!SWIG_IsOK(res1)) {
15871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15872 }
15873 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15874 {
15875 PyThreadState* __tstate = wxPyBeginAllowThreads();
15876 result = (int)(arg1)->GetZMax();
15877 wxPyEndAllowThreads(__tstate);
15878 if (PyErr_Occurred()) SWIG_fail;
15879 }
15880 resultobj = SWIG_From_int(static_cast< int >(result));
15881 return resultobj;
15882 fail:
15883 return NULL;
15884 }
15885
15886
15887 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15888 PyObject *resultobj = 0;
15889 wxJoystick *arg1 = (wxJoystick *) 0 ;
15890 int result;
15891 void *argp1 = 0 ;
15892 int res1 = 0 ;
15893 PyObject *swig_obj[1] ;
15894
15895 if (!args) SWIG_fail;
15896 swig_obj[0] = args;
15897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15898 if (!SWIG_IsOK(res1)) {
15899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15900 }
15901 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15902 {
15903 PyThreadState* __tstate = wxPyBeginAllowThreads();
15904 result = (int)(arg1)->GetNumberButtons();
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 resultobj = SWIG_From_int(static_cast< int >(result));
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15916 PyObject *resultobj = 0;
15917 wxJoystick *arg1 = (wxJoystick *) 0 ;
15918 int result;
15919 void *argp1 = 0 ;
15920 int res1 = 0 ;
15921 PyObject *swig_obj[1] ;
15922
15923 if (!args) SWIG_fail;
15924 swig_obj[0] = args;
15925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15926 if (!SWIG_IsOK(res1)) {
15927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15928 }
15929 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15930 {
15931 PyThreadState* __tstate = wxPyBeginAllowThreads();
15932 result = (int)(arg1)->GetNumberAxes();
15933 wxPyEndAllowThreads(__tstate);
15934 if (PyErr_Occurred()) SWIG_fail;
15935 }
15936 resultobj = SWIG_From_int(static_cast< int >(result));
15937 return resultobj;
15938 fail:
15939 return NULL;
15940 }
15941
15942
15943 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15944 PyObject *resultobj = 0;
15945 wxJoystick *arg1 = (wxJoystick *) 0 ;
15946 int result;
15947 void *argp1 = 0 ;
15948 int res1 = 0 ;
15949 PyObject *swig_obj[1] ;
15950
15951 if (!args) SWIG_fail;
15952 swig_obj[0] = args;
15953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15954 if (!SWIG_IsOK(res1)) {
15955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15956 }
15957 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15958 {
15959 PyThreadState* __tstate = wxPyBeginAllowThreads();
15960 result = (int)(arg1)->GetMaxButtons();
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 resultobj = SWIG_From_int(static_cast< int >(result));
15965 return resultobj;
15966 fail:
15967 return NULL;
15968 }
15969
15970
15971 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15972 PyObject *resultobj = 0;
15973 wxJoystick *arg1 = (wxJoystick *) 0 ;
15974 int result;
15975 void *argp1 = 0 ;
15976 int res1 = 0 ;
15977 PyObject *swig_obj[1] ;
15978
15979 if (!args) SWIG_fail;
15980 swig_obj[0] = args;
15981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15982 if (!SWIG_IsOK(res1)) {
15983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15984 }
15985 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15986 {
15987 PyThreadState* __tstate = wxPyBeginAllowThreads();
15988 result = (int)(arg1)->GetMaxAxes();
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 resultobj = SWIG_From_int(static_cast< int >(result));
15993 return resultobj;
15994 fail:
15995 return NULL;
15996 }
15997
15998
15999 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16000 PyObject *resultobj = 0;
16001 wxJoystick *arg1 = (wxJoystick *) 0 ;
16002 int result;
16003 void *argp1 = 0 ;
16004 int res1 = 0 ;
16005 PyObject *swig_obj[1] ;
16006
16007 if (!args) SWIG_fail;
16008 swig_obj[0] = args;
16009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16010 if (!SWIG_IsOK(res1)) {
16011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16012 }
16013 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16014 {
16015 PyThreadState* __tstate = wxPyBeginAllowThreads();
16016 result = (int)(arg1)->GetPollingMin();
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 resultobj = SWIG_From_int(static_cast< int >(result));
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16028 PyObject *resultobj = 0;
16029 wxJoystick *arg1 = (wxJoystick *) 0 ;
16030 int result;
16031 void *argp1 = 0 ;
16032 int res1 = 0 ;
16033 PyObject *swig_obj[1] ;
16034
16035 if (!args) SWIG_fail;
16036 swig_obj[0] = args;
16037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16038 if (!SWIG_IsOK(res1)) {
16039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16040 }
16041 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16042 {
16043 PyThreadState* __tstate = wxPyBeginAllowThreads();
16044 result = (int)(arg1)->GetPollingMax();
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 resultobj = SWIG_From_int(static_cast< int >(result));
16049 return resultobj;
16050 fail:
16051 return NULL;
16052 }
16053
16054
16055 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16056 PyObject *resultobj = 0;
16057 wxJoystick *arg1 = (wxJoystick *) 0 ;
16058 int result;
16059 void *argp1 = 0 ;
16060 int res1 = 0 ;
16061 PyObject *swig_obj[1] ;
16062
16063 if (!args) SWIG_fail;
16064 swig_obj[0] = args;
16065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16066 if (!SWIG_IsOK(res1)) {
16067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16068 }
16069 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = (int)(arg1)->GetRudderMin();
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 resultobj = SWIG_From_int(static_cast< int >(result));
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16084 PyObject *resultobj = 0;
16085 wxJoystick *arg1 = (wxJoystick *) 0 ;
16086 int result;
16087 void *argp1 = 0 ;
16088 int res1 = 0 ;
16089 PyObject *swig_obj[1] ;
16090
16091 if (!args) SWIG_fail;
16092 swig_obj[0] = args;
16093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16094 if (!SWIG_IsOK(res1)) {
16095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16096 }
16097 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 result = (int)(arg1)->GetRudderMax();
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 resultobj = SWIG_From_int(static_cast< int >(result));
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16112 PyObject *resultobj = 0;
16113 wxJoystick *arg1 = (wxJoystick *) 0 ;
16114 int result;
16115 void *argp1 = 0 ;
16116 int res1 = 0 ;
16117 PyObject *swig_obj[1] ;
16118
16119 if (!args) SWIG_fail;
16120 swig_obj[0] = args;
16121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16122 if (!SWIG_IsOK(res1)) {
16123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16124 }
16125 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16126 {
16127 PyThreadState* __tstate = wxPyBeginAllowThreads();
16128 result = (int)(arg1)->GetUMin();
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 resultobj = SWIG_From_int(static_cast< int >(result));
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16140 PyObject *resultobj = 0;
16141 wxJoystick *arg1 = (wxJoystick *) 0 ;
16142 int result;
16143 void *argp1 = 0 ;
16144 int res1 = 0 ;
16145 PyObject *swig_obj[1] ;
16146
16147 if (!args) SWIG_fail;
16148 swig_obj[0] = args;
16149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16150 if (!SWIG_IsOK(res1)) {
16151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16152 }
16153 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 result = (int)(arg1)->GetUMax();
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 resultobj = SWIG_From_int(static_cast< int >(result));
16161 return resultobj;
16162 fail:
16163 return NULL;
16164 }
16165
16166
16167 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16168 PyObject *resultobj = 0;
16169 wxJoystick *arg1 = (wxJoystick *) 0 ;
16170 int result;
16171 void *argp1 = 0 ;
16172 int res1 = 0 ;
16173 PyObject *swig_obj[1] ;
16174
16175 if (!args) SWIG_fail;
16176 swig_obj[0] = args;
16177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16178 if (!SWIG_IsOK(res1)) {
16179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16180 }
16181 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16182 {
16183 PyThreadState* __tstate = wxPyBeginAllowThreads();
16184 result = (int)(arg1)->GetVMin();
16185 wxPyEndAllowThreads(__tstate);
16186 if (PyErr_Occurred()) SWIG_fail;
16187 }
16188 resultobj = SWIG_From_int(static_cast< int >(result));
16189 return resultobj;
16190 fail:
16191 return NULL;
16192 }
16193
16194
16195 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16196 PyObject *resultobj = 0;
16197 wxJoystick *arg1 = (wxJoystick *) 0 ;
16198 int result;
16199 void *argp1 = 0 ;
16200 int res1 = 0 ;
16201 PyObject *swig_obj[1] ;
16202
16203 if (!args) SWIG_fail;
16204 swig_obj[0] = args;
16205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16206 if (!SWIG_IsOK(res1)) {
16207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16208 }
16209 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16210 {
16211 PyThreadState* __tstate = wxPyBeginAllowThreads();
16212 result = (int)(arg1)->GetVMax();
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 resultobj = SWIG_From_int(static_cast< int >(result));
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16224 PyObject *resultobj = 0;
16225 wxJoystick *arg1 = (wxJoystick *) 0 ;
16226 bool result;
16227 void *argp1 = 0 ;
16228 int res1 = 0 ;
16229 PyObject *swig_obj[1] ;
16230
16231 if (!args) SWIG_fail;
16232 swig_obj[0] = args;
16233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16234 if (!SWIG_IsOK(res1)) {
16235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16236 }
16237 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16238 {
16239 PyThreadState* __tstate = wxPyBeginAllowThreads();
16240 result = (bool)(arg1)->HasRudder();
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 {
16245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16246 }
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16254 PyObject *resultobj = 0;
16255 wxJoystick *arg1 = (wxJoystick *) 0 ;
16256 bool result;
16257 void *argp1 = 0 ;
16258 int res1 = 0 ;
16259 PyObject *swig_obj[1] ;
16260
16261 if (!args) SWIG_fail;
16262 swig_obj[0] = args;
16263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16264 if (!SWIG_IsOK(res1)) {
16265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16266 }
16267 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16268 {
16269 PyThreadState* __tstate = wxPyBeginAllowThreads();
16270 result = (bool)(arg1)->HasZ();
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 {
16275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16276 }
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16284 PyObject *resultobj = 0;
16285 wxJoystick *arg1 = (wxJoystick *) 0 ;
16286 bool result;
16287 void *argp1 = 0 ;
16288 int res1 = 0 ;
16289 PyObject *swig_obj[1] ;
16290
16291 if (!args) SWIG_fail;
16292 swig_obj[0] = args;
16293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16294 if (!SWIG_IsOK(res1)) {
16295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16296 }
16297 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16298 {
16299 PyThreadState* __tstate = wxPyBeginAllowThreads();
16300 result = (bool)(arg1)->HasU();
16301 wxPyEndAllowThreads(__tstate);
16302 if (PyErr_Occurred()) SWIG_fail;
16303 }
16304 {
16305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16306 }
16307 return resultobj;
16308 fail:
16309 return NULL;
16310 }
16311
16312
16313 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16314 PyObject *resultobj = 0;
16315 wxJoystick *arg1 = (wxJoystick *) 0 ;
16316 bool result;
16317 void *argp1 = 0 ;
16318 int res1 = 0 ;
16319 PyObject *swig_obj[1] ;
16320
16321 if (!args) SWIG_fail;
16322 swig_obj[0] = args;
16323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16324 if (!SWIG_IsOK(res1)) {
16325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16326 }
16327 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 result = (bool)(arg1)->HasV();
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 {
16335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16336 }
16337 return resultobj;
16338 fail:
16339 return NULL;
16340 }
16341
16342
16343 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16344 PyObject *resultobj = 0;
16345 wxJoystick *arg1 = (wxJoystick *) 0 ;
16346 bool result;
16347 void *argp1 = 0 ;
16348 int res1 = 0 ;
16349 PyObject *swig_obj[1] ;
16350
16351 if (!args) SWIG_fail;
16352 swig_obj[0] = args;
16353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16354 if (!SWIG_IsOK(res1)) {
16355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16356 }
16357 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16358 {
16359 PyThreadState* __tstate = wxPyBeginAllowThreads();
16360 result = (bool)(arg1)->HasPOV();
16361 wxPyEndAllowThreads(__tstate);
16362 if (PyErr_Occurred()) SWIG_fail;
16363 }
16364 {
16365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16366 }
16367 return resultobj;
16368 fail:
16369 return NULL;
16370 }
16371
16372
16373 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16374 PyObject *resultobj = 0;
16375 wxJoystick *arg1 = (wxJoystick *) 0 ;
16376 bool result;
16377 void *argp1 = 0 ;
16378 int res1 = 0 ;
16379 PyObject *swig_obj[1] ;
16380
16381 if (!args) SWIG_fail;
16382 swig_obj[0] = args;
16383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16384 if (!SWIG_IsOK(res1)) {
16385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16386 }
16387 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16388 {
16389 PyThreadState* __tstate = wxPyBeginAllowThreads();
16390 result = (bool)(arg1)->HasPOV4Dir();
16391 wxPyEndAllowThreads(__tstate);
16392 if (PyErr_Occurred()) SWIG_fail;
16393 }
16394 {
16395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16396 }
16397 return resultobj;
16398 fail:
16399 return NULL;
16400 }
16401
16402
16403 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16404 PyObject *resultobj = 0;
16405 wxJoystick *arg1 = (wxJoystick *) 0 ;
16406 bool result;
16407 void *argp1 = 0 ;
16408 int res1 = 0 ;
16409 PyObject *swig_obj[1] ;
16410
16411 if (!args) SWIG_fail;
16412 swig_obj[0] = args;
16413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16414 if (!SWIG_IsOK(res1)) {
16415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16416 }
16417 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16418 {
16419 PyThreadState* __tstate = wxPyBeginAllowThreads();
16420 result = (bool)(arg1)->HasPOVCTS();
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 {
16425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16426 }
16427 return resultobj;
16428 fail:
16429 return NULL;
16430 }
16431
16432
16433 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16434 PyObject *resultobj = 0;
16435 wxJoystick *arg1 = (wxJoystick *) 0 ;
16436 wxWindow *arg2 = (wxWindow *) 0 ;
16437 int arg3 = (int) 0 ;
16438 bool result;
16439 void *argp1 = 0 ;
16440 int res1 = 0 ;
16441 void *argp2 = 0 ;
16442 int res2 = 0 ;
16443 int val3 ;
16444 int ecode3 = 0 ;
16445 PyObject * obj0 = 0 ;
16446 PyObject * obj1 = 0 ;
16447 PyObject * obj2 = 0 ;
16448 char * kwnames[] = {
16449 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16450 };
16451
16452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16454 if (!SWIG_IsOK(res1)) {
16455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16456 }
16457 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16458 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16459 if (!SWIG_IsOK(res2)) {
16460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16461 }
16462 arg2 = reinterpret_cast< wxWindow * >(argp2);
16463 if (obj2) {
16464 ecode3 = SWIG_AsVal_int(obj2, &val3);
16465 if (!SWIG_IsOK(ecode3)) {
16466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16467 }
16468 arg3 = static_cast< int >(val3);
16469 }
16470 {
16471 PyThreadState* __tstate = wxPyBeginAllowThreads();
16472 result = (bool)(arg1)->SetCapture(arg2,arg3);
16473 wxPyEndAllowThreads(__tstate);
16474 if (PyErr_Occurred()) SWIG_fail;
16475 }
16476 {
16477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16478 }
16479 return resultobj;
16480 fail:
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16486 PyObject *resultobj = 0;
16487 wxJoystick *arg1 = (wxJoystick *) 0 ;
16488 bool result;
16489 void *argp1 = 0 ;
16490 int res1 = 0 ;
16491 PyObject *swig_obj[1] ;
16492
16493 if (!args) SWIG_fail;
16494 swig_obj[0] = args;
16495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16496 if (!SWIG_IsOK(res1)) {
16497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16498 }
16499 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16500 {
16501 PyThreadState* __tstate = wxPyBeginAllowThreads();
16502 result = (bool)(arg1)->ReleaseCapture();
16503 wxPyEndAllowThreads(__tstate);
16504 if (PyErr_Occurred()) SWIG_fail;
16505 }
16506 {
16507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16508 }
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16516 PyObject *obj;
16517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16518 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16519 return SWIG_Py_Void();
16520 }
16521
16522 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16523 return SWIG_Python_InitShadowInstance(args);
16524 }
16525
16526 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16527 PyObject *resultobj = 0;
16528 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16529 int arg2 = (int) 0 ;
16530 int arg3 = (int) wxJOYSTICK1 ;
16531 int arg4 = (int) 0 ;
16532 wxJoystickEvent *result = 0 ;
16533 int val1 ;
16534 int ecode1 = 0 ;
16535 int val2 ;
16536 int ecode2 = 0 ;
16537 int val3 ;
16538 int ecode3 = 0 ;
16539 int val4 ;
16540 int ecode4 = 0 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 PyObject * obj2 = 0 ;
16544 PyObject * obj3 = 0 ;
16545 char * kwnames[] = {
16546 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16547 };
16548
16549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16550 if (obj0) {
16551 ecode1 = SWIG_AsVal_int(obj0, &val1);
16552 if (!SWIG_IsOK(ecode1)) {
16553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16554 }
16555 arg1 = static_cast< wxEventType >(val1);
16556 }
16557 if (obj1) {
16558 ecode2 = SWIG_AsVal_int(obj1, &val2);
16559 if (!SWIG_IsOK(ecode2)) {
16560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16561 }
16562 arg2 = static_cast< int >(val2);
16563 }
16564 if (obj2) {
16565 ecode3 = SWIG_AsVal_int(obj2, &val3);
16566 if (!SWIG_IsOK(ecode3)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16568 }
16569 arg3 = static_cast< int >(val3);
16570 }
16571 if (obj3) {
16572 ecode4 = SWIG_AsVal_int(obj3, &val4);
16573 if (!SWIG_IsOK(ecode4)) {
16574 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16575 }
16576 arg4 = static_cast< int >(val4);
16577 }
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16592 PyObject *resultobj = 0;
16593 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16594 wxPoint result;
16595 void *argp1 = 0 ;
16596 int res1 = 0 ;
16597 PyObject *swig_obj[1] ;
16598
16599 if (!args) SWIG_fail;
16600 swig_obj[0] = args;
16601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16602 if (!SWIG_IsOK(res1)) {
16603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16604 }
16605 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16620 PyObject *resultobj = 0;
16621 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16622 int result;
16623 void *argp1 = 0 ;
16624 int res1 = 0 ;
16625 PyObject *swig_obj[1] ;
16626
16627 if (!args) SWIG_fail;
16628 swig_obj[0] = args;
16629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16630 if (!SWIG_IsOK(res1)) {
16631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16632 }
16633 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 resultobj = SWIG_From_int(static_cast< int >(result));
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16648 PyObject *resultobj = 0;
16649 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16650 int result;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 PyObject *swig_obj[1] ;
16654
16655 if (!args) SWIG_fail;
16656 swig_obj[0] = args;
16657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16658 if (!SWIG_IsOK(res1)) {
16659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16660 }
16661 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16665 wxPyEndAllowThreads(__tstate);
16666 if (PyErr_Occurred()) SWIG_fail;
16667 }
16668 resultobj = SWIG_From_int(static_cast< int >(result));
16669 return resultobj;
16670 fail:
16671 return NULL;
16672 }
16673
16674
16675 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16676 PyObject *resultobj = 0;
16677 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16678 int result;
16679 void *argp1 = 0 ;
16680 int res1 = 0 ;
16681 PyObject *swig_obj[1] ;
16682
16683 if (!args) SWIG_fail;
16684 swig_obj[0] = args;
16685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16686 if (!SWIG_IsOK(res1)) {
16687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16688 }
16689 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16693 wxPyEndAllowThreads(__tstate);
16694 if (PyErr_Occurred()) SWIG_fail;
16695 }
16696 resultobj = SWIG_From_int(static_cast< int >(result));
16697 return resultobj;
16698 fail:
16699 return NULL;
16700 }
16701
16702
16703 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16704 PyObject *resultobj = 0;
16705 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16706 int result;
16707 void *argp1 = 0 ;
16708 int res1 = 0 ;
16709 PyObject *swig_obj[1] ;
16710
16711 if (!args) SWIG_fail;
16712 swig_obj[0] = args;
16713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16714 if (!SWIG_IsOK(res1)) {
16715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16716 }
16717 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16721 wxPyEndAllowThreads(__tstate);
16722 if (PyErr_Occurred()) SWIG_fail;
16723 }
16724 resultobj = SWIG_From_int(static_cast< int >(result));
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16732 PyObject *resultobj = 0;
16733 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16734 int arg2 ;
16735 void *argp1 = 0 ;
16736 int res1 = 0 ;
16737 int val2 ;
16738 int ecode2 = 0 ;
16739 PyObject * obj0 = 0 ;
16740 PyObject * obj1 = 0 ;
16741 char * kwnames[] = {
16742 (char *) "self",(char *) "stick", NULL
16743 };
16744
16745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16747 if (!SWIG_IsOK(res1)) {
16748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16749 }
16750 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16751 ecode2 = SWIG_AsVal_int(obj1, &val2);
16752 if (!SWIG_IsOK(ecode2)) {
16753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16754 }
16755 arg2 = static_cast< int >(val2);
16756 {
16757 PyThreadState* __tstate = wxPyBeginAllowThreads();
16758 (arg1)->SetJoystick(arg2);
16759 wxPyEndAllowThreads(__tstate);
16760 if (PyErr_Occurred()) SWIG_fail;
16761 }
16762 resultobj = SWIG_Py_Void();
16763 return resultobj;
16764 fail:
16765 return NULL;
16766 }
16767
16768
16769 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16770 PyObject *resultobj = 0;
16771 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16772 int arg2 ;
16773 void *argp1 = 0 ;
16774 int res1 = 0 ;
16775 int val2 ;
16776 int ecode2 = 0 ;
16777 PyObject * obj0 = 0 ;
16778 PyObject * obj1 = 0 ;
16779 char * kwnames[] = {
16780 (char *) "self",(char *) "state", NULL
16781 };
16782
16783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16785 if (!SWIG_IsOK(res1)) {
16786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16787 }
16788 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16789 ecode2 = SWIG_AsVal_int(obj1, &val2);
16790 if (!SWIG_IsOK(ecode2)) {
16791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16792 }
16793 arg2 = static_cast< int >(val2);
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 (arg1)->SetButtonState(arg2);
16797 wxPyEndAllowThreads(__tstate);
16798 if (PyErr_Occurred()) SWIG_fail;
16799 }
16800 resultobj = SWIG_Py_Void();
16801 return resultobj;
16802 fail:
16803 return NULL;
16804 }
16805
16806
16807 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16808 PyObject *resultobj = 0;
16809 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16810 int arg2 ;
16811 void *argp1 = 0 ;
16812 int res1 = 0 ;
16813 int val2 ;
16814 int ecode2 = 0 ;
16815 PyObject * obj0 = 0 ;
16816 PyObject * obj1 = 0 ;
16817 char * kwnames[] = {
16818 (char *) "self",(char *) "change", NULL
16819 };
16820
16821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16823 if (!SWIG_IsOK(res1)) {
16824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16825 }
16826 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16827 ecode2 = SWIG_AsVal_int(obj1, &val2);
16828 if (!SWIG_IsOK(ecode2)) {
16829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16830 }
16831 arg2 = static_cast< int >(val2);
16832 {
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 (arg1)->SetButtonChange(arg2);
16835 wxPyEndAllowThreads(__tstate);
16836 if (PyErr_Occurred()) SWIG_fail;
16837 }
16838 resultobj = SWIG_Py_Void();
16839 return resultobj;
16840 fail:
16841 return NULL;
16842 }
16843
16844
16845 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj = 0;
16847 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16848 wxPoint *arg2 = 0 ;
16849 void *argp1 = 0 ;
16850 int res1 = 0 ;
16851 wxPoint temp2 ;
16852 PyObject * obj0 = 0 ;
16853 PyObject * obj1 = 0 ;
16854 char * kwnames[] = {
16855 (char *) "self",(char *) "pos", NULL
16856 };
16857
16858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16860 if (!SWIG_IsOK(res1)) {
16861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16862 }
16863 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16864 {
16865 arg2 = &temp2;
16866 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16867 }
16868 {
16869 PyThreadState* __tstate = wxPyBeginAllowThreads();
16870 (arg1)->SetPosition((wxPoint const &)*arg2);
16871 wxPyEndAllowThreads(__tstate);
16872 if (PyErr_Occurred()) SWIG_fail;
16873 }
16874 resultobj = SWIG_Py_Void();
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16882 PyObject *resultobj = 0;
16883 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16884 int arg2 ;
16885 void *argp1 = 0 ;
16886 int res1 = 0 ;
16887 int val2 ;
16888 int ecode2 = 0 ;
16889 PyObject * obj0 = 0 ;
16890 PyObject * obj1 = 0 ;
16891 char * kwnames[] = {
16892 (char *) "self",(char *) "zPos", NULL
16893 };
16894
16895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16897 if (!SWIG_IsOK(res1)) {
16898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16899 }
16900 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16901 ecode2 = SWIG_AsVal_int(obj1, &val2);
16902 if (!SWIG_IsOK(ecode2)) {
16903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16904 }
16905 arg2 = static_cast< int >(val2);
16906 {
16907 PyThreadState* __tstate = wxPyBeginAllowThreads();
16908 (arg1)->SetZPosition(arg2);
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 resultobj = SWIG_Py_Void();
16913 return resultobj;
16914 fail:
16915 return NULL;
16916 }
16917
16918
16919 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16920 PyObject *resultobj = 0;
16921 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16922 bool result;
16923 void *argp1 = 0 ;
16924 int res1 = 0 ;
16925 PyObject *swig_obj[1] ;
16926
16927 if (!args) SWIG_fail;
16928 swig_obj[0] = args;
16929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16930 if (!SWIG_IsOK(res1)) {
16931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16932 }
16933 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16937 wxPyEndAllowThreads(__tstate);
16938 if (PyErr_Occurred()) SWIG_fail;
16939 }
16940 {
16941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16942 }
16943 return resultobj;
16944 fail:
16945 return NULL;
16946 }
16947
16948
16949 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16950 PyObject *resultobj = 0;
16951 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16952 bool result;
16953 void *argp1 = 0 ;
16954 int res1 = 0 ;
16955 PyObject *swig_obj[1] ;
16956
16957 if (!args) SWIG_fail;
16958 swig_obj[0] = args;
16959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16960 if (!SWIG_IsOK(res1)) {
16961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16962 }
16963 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16964 {
16965 PyThreadState* __tstate = wxPyBeginAllowThreads();
16966 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16967 wxPyEndAllowThreads(__tstate);
16968 if (PyErr_Occurred()) SWIG_fail;
16969 }
16970 {
16971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16972 }
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16980 PyObject *resultobj = 0;
16981 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16982 bool result;
16983 void *argp1 = 0 ;
16984 int res1 = 0 ;
16985 PyObject *swig_obj[1] ;
16986
16987 if (!args) SWIG_fail;
16988 swig_obj[0] = args;
16989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16990 if (!SWIG_IsOK(res1)) {
16991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16992 }
16993 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16994 {
16995 PyThreadState* __tstate = wxPyBeginAllowThreads();
16996 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16997 wxPyEndAllowThreads(__tstate);
16998 if (PyErr_Occurred()) SWIG_fail;
16999 }
17000 {
17001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17002 }
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj = 0;
17011 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17012 int arg2 = (int) wxJOY_BUTTON_ANY ;
17013 bool result;
17014 void *argp1 = 0 ;
17015 int res1 = 0 ;
17016 int val2 ;
17017 int ecode2 = 0 ;
17018 PyObject * obj0 = 0 ;
17019 PyObject * obj1 = 0 ;
17020 char * kwnames[] = {
17021 (char *) "self",(char *) "but", NULL
17022 };
17023
17024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17026 if (!SWIG_IsOK(res1)) {
17027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17028 }
17029 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17030 if (obj1) {
17031 ecode2 = SWIG_AsVal_int(obj1, &val2);
17032 if (!SWIG_IsOK(ecode2)) {
17033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17034 }
17035 arg2 = static_cast< int >(val2);
17036 }
17037 {
17038 PyThreadState* __tstate = wxPyBeginAllowThreads();
17039 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17040 wxPyEndAllowThreads(__tstate);
17041 if (PyErr_Occurred()) SWIG_fail;
17042 }
17043 {
17044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17045 }
17046 return resultobj;
17047 fail:
17048 return NULL;
17049 }
17050
17051
17052 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17053 PyObject *resultobj = 0;
17054 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17055 int arg2 = (int) wxJOY_BUTTON_ANY ;
17056 bool result;
17057 void *argp1 = 0 ;
17058 int res1 = 0 ;
17059 int val2 ;
17060 int ecode2 = 0 ;
17061 PyObject * obj0 = 0 ;
17062 PyObject * obj1 = 0 ;
17063 char * kwnames[] = {
17064 (char *) "self",(char *) "but", NULL
17065 };
17066
17067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17069 if (!SWIG_IsOK(res1)) {
17070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17071 }
17072 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17073 if (obj1) {
17074 ecode2 = SWIG_AsVal_int(obj1, &val2);
17075 if (!SWIG_IsOK(ecode2)) {
17076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17077 }
17078 arg2 = static_cast< int >(val2);
17079 }
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 {
17087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17088 }
17089 return resultobj;
17090 fail:
17091 return NULL;
17092 }
17093
17094
17095 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17096 PyObject *resultobj = 0;
17097 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17098 int arg2 = (int) wxJOY_BUTTON_ANY ;
17099 bool result;
17100 void *argp1 = 0 ;
17101 int res1 = 0 ;
17102 int val2 ;
17103 int ecode2 = 0 ;
17104 PyObject * obj0 = 0 ;
17105 PyObject * obj1 = 0 ;
17106 char * kwnames[] = {
17107 (char *) "self",(char *) "but", NULL
17108 };
17109
17110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17112 if (!SWIG_IsOK(res1)) {
17113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17114 }
17115 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17116 if (obj1) {
17117 ecode2 = SWIG_AsVal_int(obj1, &val2);
17118 if (!SWIG_IsOK(ecode2)) {
17119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17120 }
17121 arg2 = static_cast< int >(val2);
17122 }
17123 {
17124 PyThreadState* __tstate = wxPyBeginAllowThreads();
17125 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17126 wxPyEndAllowThreads(__tstate);
17127 if (PyErr_Occurred()) SWIG_fail;
17128 }
17129 {
17130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17131 }
17132 return resultobj;
17133 fail:
17134 return NULL;
17135 }
17136
17137
17138 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17139 PyObject *obj;
17140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17141 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17142 return SWIG_Py_Void();
17143 }
17144
17145 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17146 return SWIG_Python_InitShadowInstance(args);
17147 }
17148
17149 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17150 PyObject *resultobj = 0;
17151 wxString const &arg1_defvalue = wxPyEmptyString ;
17152 wxString *arg1 = (wxString *) &arg1_defvalue ;
17153 wxSound *result = 0 ;
17154 bool temp1 = false ;
17155 PyObject * obj0 = 0 ;
17156 char * kwnames[] = {
17157 (char *) "fileName", NULL
17158 };
17159
17160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17161 if (obj0) {
17162 {
17163 arg1 = wxString_in_helper(obj0);
17164 if (arg1 == NULL) SWIG_fail;
17165 temp1 = true;
17166 }
17167 }
17168 {
17169 if (!wxPyCheckForApp()) SWIG_fail;
17170 PyThreadState* __tstate = wxPyBeginAllowThreads();
17171 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17172 wxPyEndAllowThreads(__tstate);
17173 if (PyErr_Occurred()) SWIG_fail;
17174 }
17175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17176 {
17177 if (temp1)
17178 delete arg1;
17179 }
17180 return resultobj;
17181 fail:
17182 {
17183 if (temp1)
17184 delete arg1;
17185 }
17186 return NULL;
17187 }
17188
17189
17190 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17191 PyObject *resultobj = 0;
17192 PyObject *arg1 = (PyObject *) 0 ;
17193 wxSound *result = 0 ;
17194 PyObject * obj0 = 0 ;
17195 char * kwnames[] = {
17196 (char *) "data", NULL
17197 };
17198
17199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17200 arg1 = obj0;
17201 {
17202 if (!wxPyCheckForApp()) SWIG_fail;
17203 PyThreadState* __tstate = wxPyBeginAllowThreads();
17204 result = (wxSound *)new_wxSound(arg1);
17205 wxPyEndAllowThreads(__tstate);
17206 if (PyErr_Occurred()) SWIG_fail;
17207 }
17208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17209 return resultobj;
17210 fail:
17211 return NULL;
17212 }
17213
17214
17215 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17216 PyObject *resultobj = 0;
17217 wxSound *arg1 = (wxSound *) 0 ;
17218 void *argp1 = 0 ;
17219 int res1 = 0 ;
17220 PyObject *swig_obj[1] ;
17221
17222 if (!args) SWIG_fail;
17223 swig_obj[0] = args;
17224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17225 if (!SWIG_IsOK(res1)) {
17226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17227 }
17228 arg1 = reinterpret_cast< wxSound * >(argp1);
17229 {
17230 PyThreadState* __tstate = wxPyBeginAllowThreads();
17231 delete arg1;
17232
17233 wxPyEndAllowThreads(__tstate);
17234 if (PyErr_Occurred()) SWIG_fail;
17235 }
17236 resultobj = SWIG_Py_Void();
17237 return resultobj;
17238 fail:
17239 return NULL;
17240 }
17241
17242
17243 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17244 PyObject *resultobj = 0;
17245 wxSound *arg1 = (wxSound *) 0 ;
17246 wxString *arg2 = 0 ;
17247 bool result;
17248 void *argp1 = 0 ;
17249 int res1 = 0 ;
17250 bool temp2 = false ;
17251 PyObject * obj0 = 0 ;
17252 PyObject * obj1 = 0 ;
17253 char * kwnames[] = {
17254 (char *) "self",(char *) "fileName", NULL
17255 };
17256
17257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17259 if (!SWIG_IsOK(res1)) {
17260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17261 }
17262 arg1 = reinterpret_cast< wxSound * >(argp1);
17263 {
17264 arg2 = wxString_in_helper(obj1);
17265 if (arg2 == NULL) SWIG_fail;
17266 temp2 = true;
17267 }
17268 {
17269 PyThreadState* __tstate = wxPyBeginAllowThreads();
17270 result = (bool)(arg1)->Create((wxString const &)*arg2);
17271 wxPyEndAllowThreads(__tstate);
17272 if (PyErr_Occurred()) SWIG_fail;
17273 }
17274 {
17275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17276 }
17277 {
17278 if (temp2)
17279 delete arg2;
17280 }
17281 return resultobj;
17282 fail:
17283 {
17284 if (temp2)
17285 delete arg2;
17286 }
17287 return NULL;
17288 }
17289
17290
17291 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17292 PyObject *resultobj = 0;
17293 wxSound *arg1 = (wxSound *) 0 ;
17294 PyObject *arg2 = (PyObject *) 0 ;
17295 bool result;
17296 void *argp1 = 0 ;
17297 int res1 = 0 ;
17298 PyObject * obj0 = 0 ;
17299 PyObject * obj1 = 0 ;
17300 char * kwnames[] = {
17301 (char *) "self",(char *) "data", NULL
17302 };
17303
17304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17306 if (!SWIG_IsOK(res1)) {
17307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17308 }
17309 arg1 = reinterpret_cast< wxSound * >(argp1);
17310 arg2 = obj1;
17311 {
17312 PyThreadState* __tstate = wxPyBeginAllowThreads();
17313 result = (bool)wxSound_CreateFromData(arg1,arg2);
17314 wxPyEndAllowThreads(__tstate);
17315 if (PyErr_Occurred()) SWIG_fail;
17316 }
17317 {
17318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17319 }
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17327 PyObject *resultobj = 0;
17328 wxSound *arg1 = (wxSound *) 0 ;
17329 bool result;
17330 void *argp1 = 0 ;
17331 int res1 = 0 ;
17332 PyObject *swig_obj[1] ;
17333
17334 if (!args) SWIG_fail;
17335 swig_obj[0] = args;
17336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17337 if (!SWIG_IsOK(res1)) {
17338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17339 }
17340 arg1 = reinterpret_cast< wxSound * >(argp1);
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 result = (bool)(arg1)->IsOk();
17344 wxPyEndAllowThreads(__tstate);
17345 if (PyErr_Occurred()) SWIG_fail;
17346 }
17347 {
17348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17349 }
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj = 0;
17358 wxSound *arg1 = (wxSound *) 0 ;
17359 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17360 bool result;
17361 void *argp1 = 0 ;
17362 int res1 = 0 ;
17363 unsigned int val2 ;
17364 int ecode2 = 0 ;
17365 PyObject * obj0 = 0 ;
17366 PyObject * obj1 = 0 ;
17367 char * kwnames[] = {
17368 (char *) "self",(char *) "flags", NULL
17369 };
17370
17371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17373 if (!SWIG_IsOK(res1)) {
17374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17375 }
17376 arg1 = reinterpret_cast< wxSound * >(argp1);
17377 if (obj1) {
17378 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17379 if (!SWIG_IsOK(ecode2)) {
17380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17381 }
17382 arg2 = static_cast< unsigned int >(val2);
17383 }
17384 {
17385 if (!wxPyCheckForApp()) SWIG_fail;
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (bool)((wxSound const *)arg1)->Play(arg2);
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 {
17392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17393 }
17394 return resultobj;
17395 fail:
17396 return NULL;
17397 }
17398
17399
17400 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17401 PyObject *resultobj = 0;
17402 wxString *arg1 = 0 ;
17403 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17404 bool result;
17405 bool temp1 = false ;
17406 unsigned int val2 ;
17407 int ecode2 = 0 ;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 char * kwnames[] = {
17411 (char *) "filename",(char *) "flags", NULL
17412 };
17413
17414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17415 {
17416 arg1 = wxString_in_helper(obj0);
17417 if (arg1 == NULL) SWIG_fail;
17418 temp1 = true;
17419 }
17420 if (obj1) {
17421 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17422 if (!SWIG_IsOK(ecode2)) {
17423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17424 }
17425 arg2 = static_cast< unsigned int >(val2);
17426 }
17427 {
17428 if (!wxPyCheckForApp()) SWIG_fail;
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17431 wxPyEndAllowThreads(__tstate);
17432 if (PyErr_Occurred()) SWIG_fail;
17433 }
17434 {
17435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17436 }
17437 {
17438 if (temp1)
17439 delete arg1;
17440 }
17441 return resultobj;
17442 fail:
17443 {
17444 if (temp1)
17445 delete arg1;
17446 }
17447 return NULL;
17448 }
17449
17450
17451 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17452 PyObject *resultobj = 0;
17453
17454 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17455 {
17456 if (!wxPyCheckForApp()) SWIG_fail;
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 wxSound::Stop();
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 resultobj = SWIG_Py_Void();
17463 return resultobj;
17464 fail:
17465 return NULL;
17466 }
17467
17468
17469 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 PyObject *obj;
17471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17472 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17473 return SWIG_Py_Void();
17474 }
17475
17476 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17477 return SWIG_Python_InitShadowInstance(args);
17478 }
17479
17480 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17481 PyObject *resultobj = 0;
17482 wxString *arg1 = 0 ;
17483 wxString *arg2 = 0 ;
17484 wxString *arg3 = 0 ;
17485 wxString *arg4 = 0 ;
17486 wxFileTypeInfo *result = 0 ;
17487 bool temp1 = false ;
17488 bool temp2 = false ;
17489 bool temp3 = false ;
17490 bool temp4 = false ;
17491 PyObject * obj0 = 0 ;
17492 PyObject * obj1 = 0 ;
17493 PyObject * obj2 = 0 ;
17494 PyObject * obj3 = 0 ;
17495 char * kwnames[] = {
17496 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17497 };
17498
17499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17500 {
17501 arg1 = wxString_in_helper(obj0);
17502 if (arg1 == NULL) SWIG_fail;
17503 temp1 = true;
17504 }
17505 {
17506 arg2 = wxString_in_helper(obj1);
17507 if (arg2 == NULL) SWIG_fail;
17508 temp2 = true;
17509 }
17510 {
17511 arg3 = wxString_in_helper(obj2);
17512 if (arg3 == NULL) SWIG_fail;
17513 temp3 = true;
17514 }
17515 {
17516 arg4 = wxString_in_helper(obj3);
17517 if (arg4 == NULL) SWIG_fail;
17518 temp4 = true;
17519 }
17520 {
17521 PyThreadState* __tstate = wxPyBeginAllowThreads();
17522 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17523 wxPyEndAllowThreads(__tstate);
17524 if (PyErr_Occurred()) SWIG_fail;
17525 }
17526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17527 {
17528 if (temp1)
17529 delete arg1;
17530 }
17531 {
17532 if (temp2)
17533 delete arg2;
17534 }
17535 {
17536 if (temp3)
17537 delete arg3;
17538 }
17539 {
17540 if (temp4)
17541 delete arg4;
17542 }
17543 return resultobj;
17544 fail:
17545 {
17546 if (temp1)
17547 delete arg1;
17548 }
17549 {
17550 if (temp2)
17551 delete arg2;
17552 }
17553 {
17554 if (temp3)
17555 delete arg3;
17556 }
17557 {
17558 if (temp4)
17559 delete arg4;
17560 }
17561 return NULL;
17562 }
17563
17564
17565 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj = 0;
17567 wxArrayString *arg1 = 0 ;
17568 wxFileTypeInfo *result = 0 ;
17569 bool temp1 = false ;
17570 PyObject * obj0 = 0 ;
17571 char * kwnames[] = {
17572 (char *) "sArray", NULL
17573 };
17574
17575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17576 {
17577 if (! PySequence_Check(obj0)) {
17578 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17579 SWIG_fail;
17580 }
17581 arg1 = new wxArrayString;
17582 temp1 = true;
17583 int i, len=PySequence_Length(obj0);
17584 for (i=0; i<len; i++) {
17585 PyObject* item = PySequence_GetItem(obj0, i);
17586 wxString* s = wxString_in_helper(item);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 arg1->Add(*s);
17589 delete s;
17590 Py_DECREF(item);
17591 }
17592 }
17593 {
17594 PyThreadState* __tstate = wxPyBeginAllowThreads();
17595 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17596 wxPyEndAllowThreads(__tstate);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 }
17599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17600 {
17601 if (temp1) delete arg1;
17602 }
17603 return resultobj;
17604 fail:
17605 {
17606 if (temp1) delete arg1;
17607 }
17608 return NULL;
17609 }
17610
17611
17612 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17613 PyObject *resultobj = 0;
17614 wxFileTypeInfo *result = 0 ;
17615
17616 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17617 {
17618 PyThreadState* __tstate = wxPyBeginAllowThreads();
17619 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17620 wxPyEndAllowThreads(__tstate);
17621 if (PyErr_Occurred()) SWIG_fail;
17622 }
17623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17624 return resultobj;
17625 fail:
17626 return NULL;
17627 }
17628
17629
17630 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17631 PyObject *resultobj = 0;
17632 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17633 bool result;
17634 void *argp1 = 0 ;
17635 int res1 = 0 ;
17636 PyObject *swig_obj[1] ;
17637
17638 if (!args) SWIG_fail;
17639 swig_obj[0] = args;
17640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17641 if (!SWIG_IsOK(res1)) {
17642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17643 }
17644 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17645 {
17646 PyThreadState* __tstate = wxPyBeginAllowThreads();
17647 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17648 wxPyEndAllowThreads(__tstate);
17649 if (PyErr_Occurred()) SWIG_fail;
17650 }
17651 {
17652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17653 }
17654 return resultobj;
17655 fail:
17656 return NULL;
17657 }
17658
17659
17660 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17661 PyObject *resultobj = 0;
17662 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17663 wxString *arg2 = 0 ;
17664 int arg3 = (int) 0 ;
17665 void *argp1 = 0 ;
17666 int res1 = 0 ;
17667 bool temp2 = false ;
17668 int val3 ;
17669 int ecode3 = 0 ;
17670 PyObject * obj0 = 0 ;
17671 PyObject * obj1 = 0 ;
17672 PyObject * obj2 = 0 ;
17673 char * kwnames[] = {
17674 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17675 };
17676
17677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17679 if (!SWIG_IsOK(res1)) {
17680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17681 }
17682 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17683 {
17684 arg2 = wxString_in_helper(obj1);
17685 if (arg2 == NULL) SWIG_fail;
17686 temp2 = true;
17687 }
17688 if (obj2) {
17689 ecode3 = SWIG_AsVal_int(obj2, &val3);
17690 if (!SWIG_IsOK(ecode3)) {
17691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17692 }
17693 arg3 = static_cast< int >(val3);
17694 }
17695 {
17696 PyThreadState* __tstate = wxPyBeginAllowThreads();
17697 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17698 wxPyEndAllowThreads(__tstate);
17699 if (PyErr_Occurred()) SWIG_fail;
17700 }
17701 resultobj = SWIG_Py_Void();
17702 {
17703 if (temp2)
17704 delete arg2;
17705 }
17706 return resultobj;
17707 fail:
17708 {
17709 if (temp2)
17710 delete arg2;
17711 }
17712 return NULL;
17713 }
17714
17715
17716 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17717 PyObject *resultobj = 0;
17718 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17719 wxString *arg2 = 0 ;
17720 void *argp1 = 0 ;
17721 int res1 = 0 ;
17722 bool temp2 = false ;
17723 PyObject * obj0 = 0 ;
17724 PyObject * obj1 = 0 ;
17725 char * kwnames[] = {
17726 (char *) "self",(char *) "shortDesc", NULL
17727 };
17728
17729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17731 if (!SWIG_IsOK(res1)) {
17732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17733 }
17734 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17735 {
17736 arg2 = wxString_in_helper(obj1);
17737 if (arg2 == NULL) SWIG_fail;
17738 temp2 = true;
17739 }
17740 {
17741 PyThreadState* __tstate = wxPyBeginAllowThreads();
17742 (arg1)->SetShortDesc((wxString const &)*arg2);
17743 wxPyEndAllowThreads(__tstate);
17744 if (PyErr_Occurred()) SWIG_fail;
17745 }
17746 resultobj = SWIG_Py_Void();
17747 {
17748 if (temp2)
17749 delete arg2;
17750 }
17751 return resultobj;
17752 fail:
17753 {
17754 if (temp2)
17755 delete arg2;
17756 }
17757 return NULL;
17758 }
17759
17760
17761 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17762 PyObject *resultobj = 0;
17763 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17764 wxString *result = 0 ;
17765 void *argp1 = 0 ;
17766 int res1 = 0 ;
17767 PyObject *swig_obj[1] ;
17768
17769 if (!args) SWIG_fail;
17770 swig_obj[0] = args;
17771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17772 if (!SWIG_IsOK(res1)) {
17773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17774 }
17775 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17776 {
17777 PyThreadState* __tstate = wxPyBeginAllowThreads();
17778 {
17779 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17780 result = (wxString *) &_result_ref;
17781 }
17782 wxPyEndAllowThreads(__tstate);
17783 if (PyErr_Occurred()) SWIG_fail;
17784 }
17785 {
17786 #if wxUSE_UNICODE
17787 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17788 #else
17789 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17790 #endif
17791 }
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17799 PyObject *resultobj = 0;
17800 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17801 wxString *result = 0 ;
17802 void *argp1 = 0 ;
17803 int res1 = 0 ;
17804 PyObject *swig_obj[1] ;
17805
17806 if (!args) SWIG_fail;
17807 swig_obj[0] = args;
17808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17809 if (!SWIG_IsOK(res1)) {
17810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17811 }
17812 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 {
17816 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17817 result = (wxString *) &_result_ref;
17818 }
17819 wxPyEndAllowThreads(__tstate);
17820 if (PyErr_Occurred()) SWIG_fail;
17821 }
17822 {
17823 #if wxUSE_UNICODE
17824 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17825 #else
17826 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17827 #endif
17828 }
17829 return resultobj;
17830 fail:
17831 return NULL;
17832 }
17833
17834
17835 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17836 PyObject *resultobj = 0;
17837 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17838 wxString *result = 0 ;
17839 void *argp1 = 0 ;
17840 int res1 = 0 ;
17841 PyObject *swig_obj[1] ;
17842
17843 if (!args) SWIG_fail;
17844 swig_obj[0] = args;
17845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17846 if (!SWIG_IsOK(res1)) {
17847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17848 }
17849 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17850 {
17851 PyThreadState* __tstate = wxPyBeginAllowThreads();
17852 {
17853 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17854 result = (wxString *) &_result_ref;
17855 }
17856 wxPyEndAllowThreads(__tstate);
17857 if (PyErr_Occurred()) SWIG_fail;
17858 }
17859 {
17860 #if wxUSE_UNICODE
17861 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17862 #else
17863 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17864 #endif
17865 }
17866 return resultobj;
17867 fail:
17868 return NULL;
17869 }
17870
17871
17872 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17873 PyObject *resultobj = 0;
17874 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17875 wxString *result = 0 ;
17876 void *argp1 = 0 ;
17877 int res1 = 0 ;
17878 PyObject *swig_obj[1] ;
17879
17880 if (!args) SWIG_fail;
17881 swig_obj[0] = args;
17882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17883 if (!SWIG_IsOK(res1)) {
17884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17885 }
17886 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17887 {
17888 PyThreadState* __tstate = wxPyBeginAllowThreads();
17889 {
17890 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17891 result = (wxString *) &_result_ref;
17892 }
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 {
17897 #if wxUSE_UNICODE
17898 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17899 #else
17900 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17901 #endif
17902 }
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17910 PyObject *resultobj = 0;
17911 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17912 wxString *result = 0 ;
17913 void *argp1 = 0 ;
17914 int res1 = 0 ;
17915 PyObject *swig_obj[1] ;
17916
17917 if (!args) SWIG_fail;
17918 swig_obj[0] = args;
17919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17920 if (!SWIG_IsOK(res1)) {
17921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17922 }
17923 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17924 {
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 {
17927 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17928 result = (wxString *) &_result_ref;
17929 }
17930 wxPyEndAllowThreads(__tstate);
17931 if (PyErr_Occurred()) SWIG_fail;
17932 }
17933 {
17934 #if wxUSE_UNICODE
17935 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17936 #else
17937 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17938 #endif
17939 }
17940 return resultobj;
17941 fail:
17942 return NULL;
17943 }
17944
17945
17946 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17947 PyObject *resultobj = 0;
17948 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17949 wxArrayString *result = 0 ;
17950 void *argp1 = 0 ;
17951 int res1 = 0 ;
17952 PyObject *swig_obj[1] ;
17953
17954 if (!args) SWIG_fail;
17955 swig_obj[0] = args;
17956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17957 if (!SWIG_IsOK(res1)) {
17958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17959 }
17960 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17961 {
17962 PyThreadState* __tstate = wxPyBeginAllowThreads();
17963 {
17964 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17965 result = (wxArrayString *) &_result_ref;
17966 }
17967 wxPyEndAllowThreads(__tstate);
17968 if (PyErr_Occurred()) SWIG_fail;
17969 }
17970 {
17971 resultobj = wxArrayString2PyList_helper(*result);
17972 }
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17980 PyObject *resultobj = 0;
17981 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17982 size_t result;
17983 void *argp1 = 0 ;
17984 int res1 = 0 ;
17985 PyObject *swig_obj[1] ;
17986
17987 if (!args) SWIG_fail;
17988 swig_obj[0] = args;
17989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17990 if (!SWIG_IsOK(res1)) {
17991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17992 }
17993 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17994 {
17995 PyThreadState* __tstate = wxPyBeginAllowThreads();
17996 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18008 PyObject *resultobj = 0;
18009 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18010 wxString *result = 0 ;
18011 void *argp1 = 0 ;
18012 int res1 = 0 ;
18013 PyObject *swig_obj[1] ;
18014
18015 if (!args) SWIG_fail;
18016 swig_obj[0] = args;
18017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18018 if (!SWIG_IsOK(res1)) {
18019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18020 }
18021 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18022 {
18023 PyThreadState* __tstate = wxPyBeginAllowThreads();
18024 {
18025 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18026 result = (wxString *) &_result_ref;
18027 }
18028 wxPyEndAllowThreads(__tstate);
18029 if (PyErr_Occurred()) SWIG_fail;
18030 }
18031 {
18032 #if wxUSE_UNICODE
18033 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18034 #else
18035 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18036 #endif
18037 }
18038 return resultobj;
18039 fail:
18040 return NULL;
18041 }
18042
18043
18044 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18045 PyObject *resultobj = 0;
18046 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18047 int result;
18048 void *argp1 = 0 ;
18049 int res1 = 0 ;
18050 PyObject *swig_obj[1] ;
18051
18052 if (!args) SWIG_fail;
18053 swig_obj[0] = args;
18054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18055 if (!SWIG_IsOK(res1)) {
18056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18057 }
18058 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18059 {
18060 PyThreadState* __tstate = wxPyBeginAllowThreads();
18061 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18062 wxPyEndAllowThreads(__tstate);
18063 if (PyErr_Occurred()) SWIG_fail;
18064 }
18065 resultobj = SWIG_From_int(static_cast< int >(result));
18066 return resultobj;
18067 fail:
18068 return NULL;
18069 }
18070
18071
18072 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18073 PyObject *obj;
18074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18075 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18076 return SWIG_Py_Void();
18077 }
18078
18079 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18080 return SWIG_Python_InitShadowInstance(args);
18081 }
18082
18083 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18084 PyObject *resultobj = 0;
18085 wxFileTypeInfo *arg1 = 0 ;
18086 wxFileType *result = 0 ;
18087 void *argp1 = 0 ;
18088 int res1 = 0 ;
18089 PyObject * obj0 = 0 ;
18090 char * kwnames[] = {
18091 (char *) "ftInfo", NULL
18092 };
18093
18094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18095 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18096 if (!SWIG_IsOK(res1)) {
18097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18098 }
18099 if (!argp1) {
18100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18101 }
18102 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18103 {
18104 PyThreadState* __tstate = wxPyBeginAllowThreads();
18105 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18110 return resultobj;
18111 fail:
18112 return NULL;
18113 }
18114
18115
18116 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18117 PyObject *resultobj = 0;
18118 wxFileType *arg1 = (wxFileType *) 0 ;
18119 void *argp1 = 0 ;
18120 int res1 = 0 ;
18121 PyObject *swig_obj[1] ;
18122
18123 if (!args) SWIG_fail;
18124 swig_obj[0] = args;
18125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18126 if (!SWIG_IsOK(res1)) {
18127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18128 }
18129 arg1 = reinterpret_cast< wxFileType * >(argp1);
18130 {
18131 PyThreadState* __tstate = wxPyBeginAllowThreads();
18132 delete arg1;
18133
18134 wxPyEndAllowThreads(__tstate);
18135 if (PyErr_Occurred()) SWIG_fail;
18136 }
18137 resultobj = SWIG_Py_Void();
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18145 PyObject *resultobj = 0;
18146 wxFileType *arg1 = (wxFileType *) 0 ;
18147 PyObject *result = 0 ;
18148 void *argp1 = 0 ;
18149 int res1 = 0 ;
18150 PyObject *swig_obj[1] ;
18151
18152 if (!args) SWIG_fail;
18153 swig_obj[0] = args;
18154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18155 if (!SWIG_IsOK(res1)) {
18156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18157 }
18158 arg1 = reinterpret_cast< wxFileType * >(argp1);
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 result = (PyObject *)wxFileType_GetMimeType(arg1);
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 resultobj = result;
18166 return resultobj;
18167 fail:
18168 return NULL;
18169 }
18170
18171
18172 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18173 PyObject *resultobj = 0;
18174 wxFileType *arg1 = (wxFileType *) 0 ;
18175 PyObject *result = 0 ;
18176 void *argp1 = 0 ;
18177 int res1 = 0 ;
18178 PyObject *swig_obj[1] ;
18179
18180 if (!args) SWIG_fail;
18181 swig_obj[0] = args;
18182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18183 if (!SWIG_IsOK(res1)) {
18184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18185 }
18186 arg1 = reinterpret_cast< wxFileType * >(argp1);
18187 {
18188 PyThreadState* __tstate = wxPyBeginAllowThreads();
18189 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 resultobj = result;
18194 return resultobj;
18195 fail:
18196 return NULL;
18197 }
18198
18199
18200 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18201 PyObject *resultobj = 0;
18202 wxFileType *arg1 = (wxFileType *) 0 ;
18203 PyObject *result = 0 ;
18204 void *argp1 = 0 ;
18205 int res1 = 0 ;
18206 PyObject *swig_obj[1] ;
18207
18208 if (!args) SWIG_fail;
18209 swig_obj[0] = args;
18210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18211 if (!SWIG_IsOK(res1)) {
18212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18213 }
18214 arg1 = reinterpret_cast< wxFileType * >(argp1);
18215 {
18216 PyThreadState* __tstate = wxPyBeginAllowThreads();
18217 result = (PyObject *)wxFileType_GetExtensions(arg1);
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 resultobj = result;
18222 return resultobj;
18223 fail:
18224 return NULL;
18225 }
18226
18227
18228 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18229 PyObject *resultobj = 0;
18230 wxFileType *arg1 = (wxFileType *) 0 ;
18231 wxIcon *result = 0 ;
18232 void *argp1 = 0 ;
18233 int res1 = 0 ;
18234 PyObject *swig_obj[1] ;
18235
18236 if (!args) SWIG_fail;
18237 swig_obj[0] = args;
18238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18239 if (!SWIG_IsOK(res1)) {
18240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18241 }
18242 arg1 = reinterpret_cast< wxFileType * >(argp1);
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (wxIcon *)wxFileType_GetIcon(arg1);
18246 wxPyEndAllowThreads(__tstate);
18247 if (PyErr_Occurred()) SWIG_fail;
18248 }
18249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18257 PyObject *resultobj = 0;
18258 wxFileType *arg1 = (wxFileType *) 0 ;
18259 PyObject *result = 0 ;
18260 void *argp1 = 0 ;
18261 int res1 = 0 ;
18262 PyObject *swig_obj[1] ;
18263
18264 if (!args) SWIG_fail;
18265 swig_obj[0] = args;
18266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18267 if (!SWIG_IsOK(res1)) {
18268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18269 }
18270 arg1 = reinterpret_cast< wxFileType * >(argp1);
18271 {
18272 PyThreadState* __tstate = wxPyBeginAllowThreads();
18273 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18274 wxPyEndAllowThreads(__tstate);
18275 if (PyErr_Occurred()) SWIG_fail;
18276 }
18277 resultobj = result;
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18285 PyObject *resultobj = 0;
18286 wxFileType *arg1 = (wxFileType *) 0 ;
18287 PyObject *result = 0 ;
18288 void *argp1 = 0 ;
18289 int res1 = 0 ;
18290 PyObject *swig_obj[1] ;
18291
18292 if (!args) SWIG_fail;
18293 swig_obj[0] = args;
18294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18295 if (!SWIG_IsOK(res1)) {
18296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18297 }
18298 arg1 = reinterpret_cast< wxFileType * >(argp1);
18299 {
18300 PyThreadState* __tstate = wxPyBeginAllowThreads();
18301 result = (PyObject *)wxFileType_GetDescription(arg1);
18302 wxPyEndAllowThreads(__tstate);
18303 if (PyErr_Occurred()) SWIG_fail;
18304 }
18305 resultobj = result;
18306 return resultobj;
18307 fail:
18308 return NULL;
18309 }
18310
18311
18312 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18313 PyObject *resultobj = 0;
18314 wxFileType *arg1 = (wxFileType *) 0 ;
18315 wxString *arg2 = 0 ;
18316 wxString const &arg3_defvalue = wxPyEmptyString ;
18317 wxString *arg3 = (wxString *) &arg3_defvalue ;
18318 PyObject *result = 0 ;
18319 void *argp1 = 0 ;
18320 int res1 = 0 ;
18321 bool temp2 = false ;
18322 bool temp3 = false ;
18323 PyObject * obj0 = 0 ;
18324 PyObject * obj1 = 0 ;
18325 PyObject * obj2 = 0 ;
18326 char * kwnames[] = {
18327 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18328 };
18329
18330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18332 if (!SWIG_IsOK(res1)) {
18333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18334 }
18335 arg1 = reinterpret_cast< wxFileType * >(argp1);
18336 {
18337 arg2 = wxString_in_helper(obj1);
18338 if (arg2 == NULL) SWIG_fail;
18339 temp2 = true;
18340 }
18341 if (obj2) {
18342 {
18343 arg3 = wxString_in_helper(obj2);
18344 if (arg3 == NULL) SWIG_fail;
18345 temp3 = true;
18346 }
18347 }
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18351 wxPyEndAllowThreads(__tstate);
18352 if (PyErr_Occurred()) SWIG_fail;
18353 }
18354 resultobj = result;
18355 {
18356 if (temp2)
18357 delete arg2;
18358 }
18359 {
18360 if (temp3)
18361 delete arg3;
18362 }
18363 return resultobj;
18364 fail:
18365 {
18366 if (temp2)
18367 delete arg2;
18368 }
18369 {
18370 if (temp3)
18371 delete arg3;
18372 }
18373 return NULL;
18374 }
18375
18376
18377 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18378 PyObject *resultobj = 0;
18379 wxFileType *arg1 = (wxFileType *) 0 ;
18380 wxString *arg2 = 0 ;
18381 wxString const &arg3_defvalue = wxPyEmptyString ;
18382 wxString *arg3 = (wxString *) &arg3_defvalue ;
18383 PyObject *result = 0 ;
18384 void *argp1 = 0 ;
18385 int res1 = 0 ;
18386 bool temp2 = false ;
18387 bool temp3 = false ;
18388 PyObject * obj0 = 0 ;
18389 PyObject * obj1 = 0 ;
18390 PyObject * obj2 = 0 ;
18391 char * kwnames[] = {
18392 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18393 };
18394
18395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18397 if (!SWIG_IsOK(res1)) {
18398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18399 }
18400 arg1 = reinterpret_cast< wxFileType * >(argp1);
18401 {
18402 arg2 = wxString_in_helper(obj1);
18403 if (arg2 == NULL) SWIG_fail;
18404 temp2 = true;
18405 }
18406 if (obj2) {
18407 {
18408 arg3 = wxString_in_helper(obj2);
18409 if (arg3 == NULL) SWIG_fail;
18410 temp3 = true;
18411 }
18412 }
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = result;
18420 {
18421 if (temp2)
18422 delete arg2;
18423 }
18424 {
18425 if (temp3)
18426 delete arg3;
18427 }
18428 return resultobj;
18429 fail:
18430 {
18431 if (temp2)
18432 delete arg2;
18433 }
18434 {
18435 if (temp3)
18436 delete arg3;
18437 }
18438 return NULL;
18439 }
18440
18441
18442 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj = 0;
18444 wxFileType *arg1 = (wxFileType *) 0 ;
18445 wxString *arg2 = 0 ;
18446 wxString const &arg3_defvalue = wxPyEmptyString ;
18447 wxString *arg3 = (wxString *) &arg3_defvalue ;
18448 PyObject *result = 0 ;
18449 void *argp1 = 0 ;
18450 int res1 = 0 ;
18451 bool temp2 = false ;
18452 bool temp3 = false ;
18453 PyObject * obj0 = 0 ;
18454 PyObject * obj1 = 0 ;
18455 PyObject * obj2 = 0 ;
18456 char * kwnames[] = {
18457 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18458 };
18459
18460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18462 if (!SWIG_IsOK(res1)) {
18463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18464 }
18465 arg1 = reinterpret_cast< wxFileType * >(argp1);
18466 {
18467 arg2 = wxString_in_helper(obj1);
18468 if (arg2 == NULL) SWIG_fail;
18469 temp2 = true;
18470 }
18471 if (obj2) {
18472 {
18473 arg3 = wxString_in_helper(obj2);
18474 if (arg3 == NULL) SWIG_fail;
18475 temp3 = true;
18476 }
18477 }
18478 {
18479 PyThreadState* __tstate = wxPyBeginAllowThreads();
18480 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18481 wxPyEndAllowThreads(__tstate);
18482 if (PyErr_Occurred()) SWIG_fail;
18483 }
18484 resultobj = result;
18485 {
18486 if (temp2)
18487 delete arg2;
18488 }
18489 {
18490 if (temp3)
18491 delete arg3;
18492 }
18493 return resultobj;
18494 fail:
18495 {
18496 if (temp2)
18497 delete arg2;
18498 }
18499 {
18500 if (temp3)
18501 delete arg3;
18502 }
18503 return NULL;
18504 }
18505
18506
18507 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18508 PyObject *resultobj = 0;
18509 wxFileType *arg1 = (wxFileType *) 0 ;
18510 wxString *arg2 = 0 ;
18511 wxString *arg3 = 0 ;
18512 bool arg4 = (bool) true ;
18513 bool result;
18514 void *argp1 = 0 ;
18515 int res1 = 0 ;
18516 bool temp2 = false ;
18517 bool temp3 = false ;
18518 bool val4 ;
18519 int ecode4 = 0 ;
18520 PyObject * obj0 = 0 ;
18521 PyObject * obj1 = 0 ;
18522 PyObject * obj2 = 0 ;
18523 PyObject * obj3 = 0 ;
18524 char * kwnames[] = {
18525 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18526 };
18527
18528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18530 if (!SWIG_IsOK(res1)) {
18531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18532 }
18533 arg1 = reinterpret_cast< wxFileType * >(argp1);
18534 {
18535 arg2 = wxString_in_helper(obj1);
18536 if (arg2 == NULL) SWIG_fail;
18537 temp2 = true;
18538 }
18539 {
18540 arg3 = wxString_in_helper(obj2);
18541 if (arg3 == NULL) SWIG_fail;
18542 temp3 = true;
18543 }
18544 if (obj3) {
18545 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18546 if (!SWIG_IsOK(ecode4)) {
18547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18548 }
18549 arg4 = static_cast< bool >(val4);
18550 }
18551 {
18552 PyThreadState* __tstate = wxPyBeginAllowThreads();
18553 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18554 wxPyEndAllowThreads(__tstate);
18555 if (PyErr_Occurred()) SWIG_fail;
18556 }
18557 {
18558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18559 }
18560 {
18561 if (temp2)
18562 delete arg2;
18563 }
18564 {
18565 if (temp3)
18566 delete arg3;
18567 }
18568 return resultobj;
18569 fail:
18570 {
18571 if (temp2)
18572 delete arg2;
18573 }
18574 {
18575 if (temp3)
18576 delete arg3;
18577 }
18578 return NULL;
18579 }
18580
18581
18582 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18583 PyObject *resultobj = 0;
18584 wxFileType *arg1 = (wxFileType *) 0 ;
18585 wxString const &arg2_defvalue = wxPyEmptyString ;
18586 wxString *arg2 = (wxString *) &arg2_defvalue ;
18587 int arg3 = (int) 0 ;
18588 bool result;
18589 void *argp1 = 0 ;
18590 int res1 = 0 ;
18591 bool temp2 = false ;
18592 int val3 ;
18593 int ecode3 = 0 ;
18594 PyObject * obj0 = 0 ;
18595 PyObject * obj1 = 0 ;
18596 PyObject * obj2 = 0 ;
18597 char * kwnames[] = {
18598 (char *) "self",(char *) "cmd",(char *) "index", NULL
18599 };
18600
18601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18603 if (!SWIG_IsOK(res1)) {
18604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18605 }
18606 arg1 = reinterpret_cast< wxFileType * >(argp1);
18607 if (obj1) {
18608 {
18609 arg2 = wxString_in_helper(obj1);
18610 if (arg2 == NULL) SWIG_fail;
18611 temp2 = true;
18612 }
18613 }
18614 if (obj2) {
18615 ecode3 = SWIG_AsVal_int(obj2, &val3);
18616 if (!SWIG_IsOK(ecode3)) {
18617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18618 }
18619 arg3 = static_cast< int >(val3);
18620 }
18621 {
18622 PyThreadState* __tstate = wxPyBeginAllowThreads();
18623 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18624 wxPyEndAllowThreads(__tstate);
18625 if (PyErr_Occurred()) SWIG_fail;
18626 }
18627 {
18628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18629 }
18630 {
18631 if (temp2)
18632 delete arg2;
18633 }
18634 return resultobj;
18635 fail:
18636 {
18637 if (temp2)
18638 delete arg2;
18639 }
18640 return NULL;
18641 }
18642
18643
18644 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18645 PyObject *resultobj = 0;
18646 wxFileType *arg1 = (wxFileType *) 0 ;
18647 bool result;
18648 void *argp1 = 0 ;
18649 int res1 = 0 ;
18650 PyObject *swig_obj[1] ;
18651
18652 if (!args) SWIG_fail;
18653 swig_obj[0] = args;
18654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18655 if (!SWIG_IsOK(res1)) {
18656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18657 }
18658 arg1 = reinterpret_cast< wxFileType * >(argp1);
18659 {
18660 PyThreadState* __tstate = wxPyBeginAllowThreads();
18661 result = (bool)(arg1)->Unassociate();
18662 wxPyEndAllowThreads(__tstate);
18663 if (PyErr_Occurred()) SWIG_fail;
18664 }
18665 {
18666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18667 }
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj = 0;
18676 wxString *arg1 = 0 ;
18677 wxString *arg2 = 0 ;
18678 wxString const &arg3_defvalue = wxPyEmptyString ;
18679 wxString *arg3 = (wxString *) &arg3_defvalue ;
18680 wxString result;
18681 bool temp1 = false ;
18682 bool temp2 = false ;
18683 bool temp3 = false ;
18684 PyObject * obj0 = 0 ;
18685 PyObject * obj1 = 0 ;
18686 PyObject * obj2 = 0 ;
18687 char * kwnames[] = {
18688 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18689 };
18690
18691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18692 {
18693 arg1 = wxString_in_helper(obj0);
18694 if (arg1 == NULL) SWIG_fail;
18695 temp1 = true;
18696 }
18697 {
18698 arg2 = wxString_in_helper(obj1);
18699 if (arg2 == NULL) SWIG_fail;
18700 temp2 = true;
18701 }
18702 if (obj2) {
18703 {
18704 arg3 = wxString_in_helper(obj2);
18705 if (arg3 == NULL) SWIG_fail;
18706 temp3 = true;
18707 }
18708 }
18709 {
18710 PyThreadState* __tstate = wxPyBeginAllowThreads();
18711 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18712 wxPyEndAllowThreads(__tstate);
18713 if (PyErr_Occurred()) SWIG_fail;
18714 }
18715 {
18716 #if wxUSE_UNICODE
18717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18718 #else
18719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18720 #endif
18721 }
18722 {
18723 if (temp1)
18724 delete arg1;
18725 }
18726 {
18727 if (temp2)
18728 delete arg2;
18729 }
18730 {
18731 if (temp3)
18732 delete arg3;
18733 }
18734 return resultobj;
18735 fail:
18736 {
18737 if (temp1)
18738 delete arg1;
18739 }
18740 {
18741 if (temp2)
18742 delete arg2;
18743 }
18744 {
18745 if (temp3)
18746 delete arg3;
18747 }
18748 return NULL;
18749 }
18750
18751
18752 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18753 PyObject *obj;
18754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18755 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18756 return SWIG_Py_Void();
18757 }
18758
18759 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18760 return SWIG_Python_InitShadowInstance(args);
18761 }
18762
18763 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18764 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18765 return 1;
18766 }
18767
18768
18769 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18770 PyObject *pyobj = 0;
18771
18772 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18773 return pyobj;
18774 }
18775
18776
18777 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18778 PyObject *resultobj = 0;
18779 wxString *arg1 = 0 ;
18780 wxString *arg2 = 0 ;
18781 bool result;
18782 bool temp1 = false ;
18783 bool temp2 = false ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 char * kwnames[] = {
18787 (char *) "mimeType",(char *) "wildcard", NULL
18788 };
18789
18790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18791 {
18792 arg1 = wxString_in_helper(obj0);
18793 if (arg1 == NULL) SWIG_fail;
18794 temp1 = true;
18795 }
18796 {
18797 arg2 = wxString_in_helper(obj1);
18798 if (arg2 == NULL) SWIG_fail;
18799 temp2 = true;
18800 }
18801 {
18802 PyThreadState* __tstate = wxPyBeginAllowThreads();
18803 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18804 wxPyEndAllowThreads(__tstate);
18805 if (PyErr_Occurred()) SWIG_fail;
18806 }
18807 {
18808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18809 }
18810 {
18811 if (temp1)
18812 delete arg1;
18813 }
18814 {
18815 if (temp2)
18816 delete arg2;
18817 }
18818 return resultobj;
18819 fail:
18820 {
18821 if (temp1)
18822 delete arg1;
18823 }
18824 {
18825 if (temp2)
18826 delete arg2;
18827 }
18828 return NULL;
18829 }
18830
18831
18832 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18833 PyObject *resultobj = 0;
18834 wxMimeTypesManager *result = 0 ;
18835
18836 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18837 {
18838 PyThreadState* __tstate = wxPyBeginAllowThreads();
18839 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18840 wxPyEndAllowThreads(__tstate);
18841 if (PyErr_Occurred()) SWIG_fail;
18842 }
18843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18844 return resultobj;
18845 fail:
18846 return NULL;
18847 }
18848
18849
18850 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18851 PyObject *resultobj = 0;
18852 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18853 int arg2 = (int) wxMAILCAP_ALL ;
18854 wxString const &arg3_defvalue = wxPyEmptyString ;
18855 wxString *arg3 = (wxString *) &arg3_defvalue ;
18856 void *argp1 = 0 ;
18857 int res1 = 0 ;
18858 int val2 ;
18859 int ecode2 = 0 ;
18860 bool temp3 = false ;
18861 PyObject * obj0 = 0 ;
18862 PyObject * obj1 = 0 ;
18863 PyObject * obj2 = 0 ;
18864 char * kwnames[] = {
18865 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18866 };
18867
18868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18870 if (!SWIG_IsOK(res1)) {
18871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18872 }
18873 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18874 if (obj1) {
18875 ecode2 = SWIG_AsVal_int(obj1, &val2);
18876 if (!SWIG_IsOK(ecode2)) {
18877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18878 }
18879 arg2 = static_cast< int >(val2);
18880 }
18881 if (obj2) {
18882 {
18883 arg3 = wxString_in_helper(obj2);
18884 if (arg3 == NULL) SWIG_fail;
18885 temp3 = true;
18886 }
18887 }
18888 {
18889 PyThreadState* __tstate = wxPyBeginAllowThreads();
18890 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18891 wxPyEndAllowThreads(__tstate);
18892 if (PyErr_Occurred()) SWIG_fail;
18893 }
18894 resultobj = SWIG_Py_Void();
18895 {
18896 if (temp3)
18897 delete arg3;
18898 }
18899 return resultobj;
18900 fail:
18901 {
18902 if (temp3)
18903 delete arg3;
18904 }
18905 return NULL;
18906 }
18907
18908
18909 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18910 PyObject *resultobj = 0;
18911 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18912 void *argp1 = 0 ;
18913 int res1 = 0 ;
18914 PyObject *swig_obj[1] ;
18915
18916 if (!args) SWIG_fail;
18917 swig_obj[0] = args;
18918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18919 if (!SWIG_IsOK(res1)) {
18920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18921 }
18922 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18923 {
18924 PyThreadState* __tstate = wxPyBeginAllowThreads();
18925 (arg1)->ClearData();
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 resultobj = SWIG_Py_Void();
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj = 0;
18938 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18939 wxString *arg2 = 0 ;
18940 wxFileType *result = 0 ;
18941 void *argp1 = 0 ;
18942 int res1 = 0 ;
18943 bool temp2 = false ;
18944 PyObject * obj0 = 0 ;
18945 PyObject * obj1 = 0 ;
18946 char * kwnames[] = {
18947 (char *) "self",(char *) "ext", NULL
18948 };
18949
18950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18952 if (!SWIG_IsOK(res1)) {
18953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18954 }
18955 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18956 {
18957 arg2 = wxString_in_helper(obj1);
18958 if (arg2 == NULL) SWIG_fail;
18959 temp2 = true;
18960 }
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18964 wxPyEndAllowThreads(__tstate);
18965 if (PyErr_Occurred()) SWIG_fail;
18966 }
18967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18968 {
18969 if (temp2)
18970 delete arg2;
18971 }
18972 return resultobj;
18973 fail:
18974 {
18975 if (temp2)
18976 delete arg2;
18977 }
18978 return NULL;
18979 }
18980
18981
18982 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj = 0;
18984 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18985 wxString *arg2 = 0 ;
18986 wxFileType *result = 0 ;
18987 void *argp1 = 0 ;
18988 int res1 = 0 ;
18989 bool temp2 = false ;
18990 PyObject * obj0 = 0 ;
18991 PyObject * obj1 = 0 ;
18992 char * kwnames[] = {
18993 (char *) "self",(char *) "mimeType", NULL
18994 };
18995
18996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19000 }
19001 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19002 {
19003 arg2 = wxString_in_helper(obj1);
19004 if (arg2 == NULL) SWIG_fail;
19005 temp2 = true;
19006 }
19007 {
19008 PyThreadState* __tstate = wxPyBeginAllowThreads();
19009 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19010 wxPyEndAllowThreads(__tstate);
19011 if (PyErr_Occurred()) SWIG_fail;
19012 }
19013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19014 {
19015 if (temp2)
19016 delete arg2;
19017 }
19018 return resultobj;
19019 fail:
19020 {
19021 if (temp2)
19022 delete arg2;
19023 }
19024 return NULL;
19025 }
19026
19027
19028 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19029 PyObject *resultobj = 0;
19030 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19031 wxString *arg2 = 0 ;
19032 bool arg3 = (bool) false ;
19033 bool result;
19034 void *argp1 = 0 ;
19035 int res1 = 0 ;
19036 bool temp2 = false ;
19037 bool val3 ;
19038 int ecode3 = 0 ;
19039 PyObject * obj0 = 0 ;
19040 PyObject * obj1 = 0 ;
19041 PyObject * obj2 = 0 ;
19042 char * kwnames[] = {
19043 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19044 };
19045
19046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19048 if (!SWIG_IsOK(res1)) {
19049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19050 }
19051 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19052 {
19053 arg2 = wxString_in_helper(obj1);
19054 if (arg2 == NULL) SWIG_fail;
19055 temp2 = true;
19056 }
19057 if (obj2) {
19058 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19059 if (!SWIG_IsOK(ecode3)) {
19060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19061 }
19062 arg3 = static_cast< bool >(val3);
19063 }
19064 {
19065 PyThreadState* __tstate = wxPyBeginAllowThreads();
19066 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19067 wxPyEndAllowThreads(__tstate);
19068 if (PyErr_Occurred()) SWIG_fail;
19069 }
19070 {
19071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19072 }
19073 {
19074 if (temp2)
19075 delete arg2;
19076 }
19077 return resultobj;
19078 fail:
19079 {
19080 if (temp2)
19081 delete arg2;
19082 }
19083 return NULL;
19084 }
19085
19086
19087 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19088 PyObject *resultobj = 0;
19089 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19090 wxString *arg2 = 0 ;
19091 bool result;
19092 void *argp1 = 0 ;
19093 int res1 = 0 ;
19094 bool temp2 = false ;
19095 PyObject * obj0 = 0 ;
19096 PyObject * obj1 = 0 ;
19097 char * kwnames[] = {
19098 (char *) "self",(char *) "filename", NULL
19099 };
19100
19101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19103 if (!SWIG_IsOK(res1)) {
19104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19105 }
19106 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19107 {
19108 arg2 = wxString_in_helper(obj1);
19109 if (arg2 == NULL) SWIG_fail;
19110 temp2 = true;
19111 }
19112 {
19113 PyThreadState* __tstate = wxPyBeginAllowThreads();
19114 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19115 wxPyEndAllowThreads(__tstate);
19116 if (PyErr_Occurred()) SWIG_fail;
19117 }
19118 {
19119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19120 }
19121 {
19122 if (temp2)
19123 delete arg2;
19124 }
19125 return resultobj;
19126 fail:
19127 {
19128 if (temp2)
19129 delete arg2;
19130 }
19131 return NULL;
19132 }
19133
19134
19135 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19136 PyObject *resultobj = 0;
19137 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19138 PyObject *result = 0 ;
19139 void *argp1 = 0 ;
19140 int res1 = 0 ;
19141 PyObject *swig_obj[1] ;
19142
19143 if (!args) SWIG_fail;
19144 swig_obj[0] = args;
19145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19146 if (!SWIG_IsOK(res1)) {
19147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19148 }
19149 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19150 {
19151 PyThreadState* __tstate = wxPyBeginAllowThreads();
19152 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19153 wxPyEndAllowThreads(__tstate);
19154 if (PyErr_Occurred()) SWIG_fail;
19155 }
19156 resultobj = result;
19157 return resultobj;
19158 fail:
19159 return NULL;
19160 }
19161
19162
19163 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19164 PyObject *resultobj = 0;
19165 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19166 wxFileTypeInfo *arg2 = 0 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 void *argp2 = 0 ;
19170 int res2 = 0 ;
19171 PyObject * obj0 = 0 ;
19172 PyObject * obj1 = 0 ;
19173 char * kwnames[] = {
19174 (char *) "self",(char *) "ft", NULL
19175 };
19176
19177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19179 if (!SWIG_IsOK(res1)) {
19180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19181 }
19182 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19183 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19184 if (!SWIG_IsOK(res2)) {
19185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19186 }
19187 if (!argp2) {
19188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19189 }
19190 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19191 {
19192 PyThreadState* __tstate = wxPyBeginAllowThreads();
19193 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 resultobj = SWIG_Py_Void();
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19205 PyObject *resultobj = 0;
19206 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19207 wxFileTypeInfo *arg2 = 0 ;
19208 wxFileType *result = 0 ;
19209 void *argp1 = 0 ;
19210 int res1 = 0 ;
19211 void *argp2 = 0 ;
19212 int res2 = 0 ;
19213 PyObject * obj0 = 0 ;
19214 PyObject * obj1 = 0 ;
19215 char * kwnames[] = {
19216 (char *) "self",(char *) "ftInfo", NULL
19217 };
19218
19219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19221 if (!SWIG_IsOK(res1)) {
19222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19223 }
19224 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19225 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19226 if (!SWIG_IsOK(res2)) {
19227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19228 }
19229 if (!argp2) {
19230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19231 }
19232 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19247 PyObject *resultobj = 0;
19248 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19249 wxFileType *arg2 = (wxFileType *) 0 ;
19250 bool result;
19251 void *argp1 = 0 ;
19252 int res1 = 0 ;
19253 void *argp2 = 0 ;
19254 int res2 = 0 ;
19255 PyObject * obj0 = 0 ;
19256 PyObject * obj1 = 0 ;
19257 char * kwnames[] = {
19258 (char *) "self",(char *) "ft", NULL
19259 };
19260
19261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19263 if (!SWIG_IsOK(res1)) {
19264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19265 }
19266 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19268 if (!SWIG_IsOK(res2)) {
19269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19270 }
19271 arg2 = reinterpret_cast< wxFileType * >(argp2);
19272 {
19273 PyThreadState* __tstate = wxPyBeginAllowThreads();
19274 result = (bool)(arg1)->Unassociate(arg2);
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 {
19279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19280 }
19281 return resultobj;
19282 fail:
19283 return NULL;
19284 }
19285
19286
19287 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19288 PyObject *resultobj = 0;
19289 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19290 void *argp1 = 0 ;
19291 int res1 = 0 ;
19292 PyObject *swig_obj[1] ;
19293
19294 if (!args) SWIG_fail;
19295 swig_obj[0] = args;
19296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19297 if (!SWIG_IsOK(res1)) {
19298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19299 }
19300 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 delete arg1;
19304
19305 wxPyEndAllowThreads(__tstate);
19306 if (PyErr_Occurred()) SWIG_fail;
19307 }
19308 resultobj = SWIG_Py_Void();
19309 return resultobj;
19310 fail:
19311 return NULL;
19312 }
19313
19314
19315 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19316 PyObject *obj;
19317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19318 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19319 return SWIG_Py_Void();
19320 }
19321
19322 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19323 return SWIG_Python_InitShadowInstance(args);
19324 }
19325
19326 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19327 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19328 return 1;
19329 }
19330
19331
19332 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19333 PyObject *pyobj = 0;
19334
19335 {
19336 #if wxUSE_UNICODE
19337 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19338 #else
19339 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19340 #endif
19341 }
19342 return pyobj;
19343 }
19344
19345
19346 SWIGINTERN int ART_MENU_set(PyObject *) {
19347 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19348 return 1;
19349 }
19350
19351
19352 SWIGINTERN PyObject *ART_MENU_get(void) {
19353 PyObject *pyobj = 0;
19354
19355 {
19356 #if wxUSE_UNICODE
19357 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19358 #else
19359 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19360 #endif
19361 }
19362 return pyobj;
19363 }
19364
19365
19366 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19367 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19368 return 1;
19369 }
19370
19371
19372 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19373 PyObject *pyobj = 0;
19374
19375 {
19376 #if wxUSE_UNICODE
19377 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19378 #else
19379 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19380 #endif
19381 }
19382 return pyobj;
19383 }
19384
19385
19386 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19387 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19388 return 1;
19389 }
19390
19391
19392 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19393 PyObject *pyobj = 0;
19394
19395 {
19396 #if wxUSE_UNICODE
19397 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19398 #else
19399 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19400 #endif
19401 }
19402 return pyobj;
19403 }
19404
19405
19406 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19407 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19408 return 1;
19409 }
19410
19411
19412 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19413 PyObject *pyobj = 0;
19414
19415 {
19416 #if wxUSE_UNICODE
19417 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19418 #else
19419 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19420 #endif
19421 }
19422 return pyobj;
19423 }
19424
19425
19426 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19427 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19428 return 1;
19429 }
19430
19431
19432 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19433 PyObject *pyobj = 0;
19434
19435 {
19436 #if wxUSE_UNICODE
19437 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19438 #else
19439 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19440 #endif
19441 }
19442 return pyobj;
19443 }
19444
19445
19446 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19447 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19448 return 1;
19449 }
19450
19451
19452 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19453 PyObject *pyobj = 0;
19454
19455 {
19456 #if wxUSE_UNICODE
19457 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19458 #else
19459 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19460 #endif
19461 }
19462 return pyobj;
19463 }
19464
19465
19466 SWIGINTERN int ART_OTHER_set(PyObject *) {
19467 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19468 return 1;
19469 }
19470
19471
19472 SWIGINTERN PyObject *ART_OTHER_get(void) {
19473 PyObject *pyobj = 0;
19474
19475 {
19476 #if wxUSE_UNICODE
19477 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19478 #else
19479 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19480 #endif
19481 }
19482 return pyobj;
19483 }
19484
19485
19486 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19487 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19488 return 1;
19489 }
19490
19491
19492 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19493 PyObject *pyobj = 0;
19494
19495 {
19496 #if wxUSE_UNICODE
19497 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19498 #else
19499 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19500 #endif
19501 }
19502 return pyobj;
19503 }
19504
19505
19506 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19507 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19508 return 1;
19509 }
19510
19511
19512 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19513 PyObject *pyobj = 0;
19514
19515 {
19516 #if wxUSE_UNICODE
19517 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19518 #else
19519 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19520 #endif
19521 }
19522 return pyobj;
19523 }
19524
19525
19526 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19527 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19528 return 1;
19529 }
19530
19531
19532 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19533 PyObject *pyobj = 0;
19534
19535 {
19536 #if wxUSE_UNICODE
19537 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19538 #else
19539 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19540 #endif
19541 }
19542 return pyobj;
19543 }
19544
19545
19546 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19547 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19548 return 1;
19549 }
19550
19551
19552 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19553 PyObject *pyobj = 0;
19554
19555 {
19556 #if wxUSE_UNICODE
19557 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19558 #else
19559 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19560 #endif
19561 }
19562 return pyobj;
19563 }
19564
19565
19566 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19567 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19568 return 1;
19569 }
19570
19571
19572 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19573 PyObject *pyobj = 0;
19574
19575 {
19576 #if wxUSE_UNICODE
19577 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19578 #else
19579 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19580 #endif
19581 }
19582 return pyobj;
19583 }
19584
19585
19586 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19587 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19588 return 1;
19589 }
19590
19591
19592 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19593 PyObject *pyobj = 0;
19594
19595 {
19596 #if wxUSE_UNICODE
19597 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19598 #else
19599 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19600 #endif
19601 }
19602 return pyobj;
19603 }
19604
19605
19606 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19607 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19608 return 1;
19609 }
19610
19611
19612 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19613 PyObject *pyobj = 0;
19614
19615 {
19616 #if wxUSE_UNICODE
19617 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19618 #else
19619 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19620 #endif
19621 }
19622 return pyobj;
19623 }
19624
19625
19626 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19627 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19628 return 1;
19629 }
19630
19631
19632 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19633 PyObject *pyobj = 0;
19634
19635 {
19636 #if wxUSE_UNICODE
19637 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19638 #else
19639 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19640 #endif
19641 }
19642 return pyobj;
19643 }
19644
19645
19646 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19647 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19648 return 1;
19649 }
19650
19651
19652 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19653 PyObject *pyobj = 0;
19654
19655 {
19656 #if wxUSE_UNICODE
19657 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19658 #else
19659 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19660 #endif
19661 }
19662 return pyobj;
19663 }
19664
19665
19666 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19667 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19668 return 1;
19669 }
19670
19671
19672 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19673 PyObject *pyobj = 0;
19674
19675 {
19676 #if wxUSE_UNICODE
19677 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19678 #else
19679 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19680 #endif
19681 }
19682 return pyobj;
19683 }
19684
19685
19686 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19687 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19688 return 1;
19689 }
19690
19691
19692 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19693 PyObject *pyobj = 0;
19694
19695 {
19696 #if wxUSE_UNICODE
19697 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19698 #else
19699 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19700 #endif
19701 }
19702 return pyobj;
19703 }
19704
19705
19706 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19707 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19708 return 1;
19709 }
19710
19711
19712 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19713 PyObject *pyobj = 0;
19714
19715 {
19716 #if wxUSE_UNICODE
19717 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19718 #else
19719 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19720 #endif
19721 }
19722 return pyobj;
19723 }
19724
19725
19726 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19727 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19728 return 1;
19729 }
19730
19731
19732 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19733 PyObject *pyobj = 0;
19734
19735 {
19736 #if wxUSE_UNICODE
19737 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19738 #else
19739 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19740 #endif
19741 }
19742 return pyobj;
19743 }
19744
19745
19746 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19747 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19748 return 1;
19749 }
19750
19751
19752 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19753 PyObject *pyobj = 0;
19754
19755 {
19756 #if wxUSE_UNICODE
19757 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19758 #else
19759 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19760 #endif
19761 }
19762 return pyobj;
19763 }
19764
19765
19766 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19767 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19768 return 1;
19769 }
19770
19771
19772 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19773 PyObject *pyobj = 0;
19774
19775 {
19776 #if wxUSE_UNICODE
19777 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19778 #else
19779 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19780 #endif
19781 }
19782 return pyobj;
19783 }
19784
19785
19786 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19787 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19788 return 1;
19789 }
19790
19791
19792 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19793 PyObject *pyobj = 0;
19794
19795 {
19796 #if wxUSE_UNICODE
19797 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19798 #else
19799 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19800 #endif
19801 }
19802 return pyobj;
19803 }
19804
19805
19806 SWIGINTERN int ART_PRINT_set(PyObject *) {
19807 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19808 return 1;
19809 }
19810
19811
19812 SWIGINTERN PyObject *ART_PRINT_get(void) {
19813 PyObject *pyobj = 0;
19814
19815 {
19816 #if wxUSE_UNICODE
19817 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19818 #else
19819 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19820 #endif
19821 }
19822 return pyobj;
19823 }
19824
19825
19826 SWIGINTERN int ART_HELP_set(PyObject *) {
19827 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19828 return 1;
19829 }
19830
19831
19832 SWIGINTERN PyObject *ART_HELP_get(void) {
19833 PyObject *pyobj = 0;
19834
19835 {
19836 #if wxUSE_UNICODE
19837 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19838 #else
19839 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19840 #endif
19841 }
19842 return pyobj;
19843 }
19844
19845
19846 SWIGINTERN int ART_TIP_set(PyObject *) {
19847 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19848 return 1;
19849 }
19850
19851
19852 SWIGINTERN PyObject *ART_TIP_get(void) {
19853 PyObject *pyobj = 0;
19854
19855 {
19856 #if wxUSE_UNICODE
19857 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19858 #else
19859 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19860 #endif
19861 }
19862 return pyobj;
19863 }
19864
19865
19866 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19867 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19868 return 1;
19869 }
19870
19871
19872 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19873 PyObject *pyobj = 0;
19874
19875 {
19876 #if wxUSE_UNICODE
19877 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19878 #else
19879 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19880 #endif
19881 }
19882 return pyobj;
19883 }
19884
19885
19886 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19887 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19888 return 1;
19889 }
19890
19891
19892 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19893 PyObject *pyobj = 0;
19894
19895 {
19896 #if wxUSE_UNICODE
19897 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19898 #else
19899 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19900 #endif
19901 }
19902 return pyobj;
19903 }
19904
19905
19906 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19907 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19908 return 1;
19909 }
19910
19911
19912 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19913 PyObject *pyobj = 0;
19914
19915 {
19916 #if wxUSE_UNICODE
19917 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19918 #else
19919 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19920 #endif
19921 }
19922 return pyobj;
19923 }
19924
19925
19926 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19927 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19928 return 1;
19929 }
19930
19931
19932 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19933 PyObject *pyobj = 0;
19934
19935 {
19936 #if wxUSE_UNICODE
19937 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19938 #else
19939 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19940 #endif
19941 }
19942 return pyobj;
19943 }
19944
19945
19946 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19947 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19948 return 1;
19949 }
19950
19951
19952 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19953 PyObject *pyobj = 0;
19954
19955 {
19956 #if wxUSE_UNICODE
19957 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19958 #else
19959 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19960 #endif
19961 }
19962 return pyobj;
19963 }
19964
19965
19966 SWIGINTERN int ART_CDROM_set(PyObject *) {
19967 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19968 return 1;
19969 }
19970
19971
19972 SWIGINTERN PyObject *ART_CDROM_get(void) {
19973 PyObject *pyobj = 0;
19974
19975 {
19976 #if wxUSE_UNICODE
19977 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19978 #else
19979 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19980 #endif
19981 }
19982 return pyobj;
19983 }
19984
19985
19986 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19987 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19988 return 1;
19989 }
19990
19991
19992 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19993 PyObject *pyobj = 0;
19994
19995 {
19996 #if wxUSE_UNICODE
19997 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19998 #else
19999 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20000 #endif
20001 }
20002 return pyobj;
20003 }
20004
20005
20006 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20007 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20008 return 1;
20009 }
20010
20011
20012 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20013 PyObject *pyobj = 0;
20014
20015 {
20016 #if wxUSE_UNICODE
20017 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20018 #else
20019 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20020 #endif
20021 }
20022 return pyobj;
20023 }
20024
20025
20026 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20027 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20028 return 1;
20029 }
20030
20031
20032 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20033 PyObject *pyobj = 0;
20034
20035 {
20036 #if wxUSE_UNICODE
20037 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20038 #else
20039 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20040 #endif
20041 }
20042 return pyobj;
20043 }
20044
20045
20046 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20047 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20048 return 1;
20049 }
20050
20051
20052 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20053 PyObject *pyobj = 0;
20054
20055 {
20056 #if wxUSE_UNICODE
20057 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20058 #else
20059 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20060 #endif
20061 }
20062 return pyobj;
20063 }
20064
20065
20066 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20067 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20068 return 1;
20069 }
20070
20071
20072 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20073 PyObject *pyobj = 0;
20074
20075 {
20076 #if wxUSE_UNICODE
20077 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20078 #else
20079 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20080 #endif
20081 }
20082 return pyobj;
20083 }
20084
20085
20086 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20087 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20088 return 1;
20089 }
20090
20091
20092 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20093 PyObject *pyobj = 0;
20094
20095 {
20096 #if wxUSE_UNICODE
20097 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20098 #else
20099 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20100 #endif
20101 }
20102 return pyobj;
20103 }
20104
20105
20106 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20107 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20108 return 1;
20109 }
20110
20111
20112 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20113 PyObject *pyobj = 0;
20114
20115 {
20116 #if wxUSE_UNICODE
20117 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20118 #else
20119 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20120 #endif
20121 }
20122 return pyobj;
20123 }
20124
20125
20126 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20127 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20128 return 1;
20129 }
20130
20131
20132 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20133 PyObject *pyobj = 0;
20134
20135 {
20136 #if wxUSE_UNICODE
20137 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20138 #else
20139 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20140 #endif
20141 }
20142 return pyobj;
20143 }
20144
20145
20146 SWIGINTERN int ART_ERROR_set(PyObject *) {
20147 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20148 return 1;
20149 }
20150
20151
20152 SWIGINTERN PyObject *ART_ERROR_get(void) {
20153 PyObject *pyobj = 0;
20154
20155 {
20156 #if wxUSE_UNICODE
20157 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20158 #else
20159 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20160 #endif
20161 }
20162 return pyobj;
20163 }
20164
20165
20166 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20167 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20168 return 1;
20169 }
20170
20171
20172 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20173 PyObject *pyobj = 0;
20174
20175 {
20176 #if wxUSE_UNICODE
20177 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20178 #else
20179 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20180 #endif
20181 }
20182 return pyobj;
20183 }
20184
20185
20186 SWIGINTERN int ART_WARNING_set(PyObject *) {
20187 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20188 return 1;
20189 }
20190
20191
20192 SWIGINTERN PyObject *ART_WARNING_get(void) {
20193 PyObject *pyobj = 0;
20194
20195 {
20196 #if wxUSE_UNICODE
20197 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20198 #else
20199 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20200 #endif
20201 }
20202 return pyobj;
20203 }
20204
20205
20206 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20207 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20208 return 1;
20209 }
20210
20211
20212 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20213 PyObject *pyobj = 0;
20214
20215 {
20216 #if wxUSE_UNICODE
20217 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20218 #else
20219 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20220 #endif
20221 }
20222 return pyobj;
20223 }
20224
20225
20226 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20227 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20228 return 1;
20229 }
20230
20231
20232 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20233 PyObject *pyobj = 0;
20234
20235 {
20236 #if wxUSE_UNICODE
20237 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20238 #else
20239 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20240 #endif
20241 }
20242 return pyobj;
20243 }
20244
20245
20246 SWIGINTERN int ART_COPY_set(PyObject *) {
20247 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20248 return 1;
20249 }
20250
20251
20252 SWIGINTERN PyObject *ART_COPY_get(void) {
20253 PyObject *pyobj = 0;
20254
20255 {
20256 #if wxUSE_UNICODE
20257 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20258 #else
20259 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20260 #endif
20261 }
20262 return pyobj;
20263 }
20264
20265
20266 SWIGINTERN int ART_CUT_set(PyObject *) {
20267 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20268 return 1;
20269 }
20270
20271
20272 SWIGINTERN PyObject *ART_CUT_get(void) {
20273 PyObject *pyobj = 0;
20274
20275 {
20276 #if wxUSE_UNICODE
20277 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20278 #else
20279 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20280 #endif
20281 }
20282 return pyobj;
20283 }
20284
20285
20286 SWIGINTERN int ART_PASTE_set(PyObject *) {
20287 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20288 return 1;
20289 }
20290
20291
20292 SWIGINTERN PyObject *ART_PASTE_get(void) {
20293 PyObject *pyobj = 0;
20294
20295 {
20296 #if wxUSE_UNICODE
20297 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20298 #else
20299 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20300 #endif
20301 }
20302 return pyobj;
20303 }
20304
20305
20306 SWIGINTERN int ART_DELETE_set(PyObject *) {
20307 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20308 return 1;
20309 }
20310
20311
20312 SWIGINTERN PyObject *ART_DELETE_get(void) {
20313 PyObject *pyobj = 0;
20314
20315 {
20316 #if wxUSE_UNICODE
20317 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20318 #else
20319 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20320 #endif
20321 }
20322 return pyobj;
20323 }
20324
20325
20326 SWIGINTERN int ART_NEW_set(PyObject *) {
20327 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20328 return 1;
20329 }
20330
20331
20332 SWIGINTERN PyObject *ART_NEW_get(void) {
20333 PyObject *pyobj = 0;
20334
20335 {
20336 #if wxUSE_UNICODE
20337 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20338 #else
20339 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20340 #endif
20341 }
20342 return pyobj;
20343 }
20344
20345
20346 SWIGINTERN int ART_UNDO_set(PyObject *) {
20347 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20348 return 1;
20349 }
20350
20351
20352 SWIGINTERN PyObject *ART_UNDO_get(void) {
20353 PyObject *pyobj = 0;
20354
20355 {
20356 #if wxUSE_UNICODE
20357 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20358 #else
20359 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20360 #endif
20361 }
20362 return pyobj;
20363 }
20364
20365
20366 SWIGINTERN int ART_REDO_set(PyObject *) {
20367 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20368 return 1;
20369 }
20370
20371
20372 SWIGINTERN PyObject *ART_REDO_get(void) {
20373 PyObject *pyobj = 0;
20374
20375 {
20376 #if wxUSE_UNICODE
20377 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20378 #else
20379 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20380 #endif
20381 }
20382 return pyobj;
20383 }
20384
20385
20386 SWIGINTERN int ART_QUIT_set(PyObject *) {
20387 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20388 return 1;
20389 }
20390
20391
20392 SWIGINTERN PyObject *ART_QUIT_get(void) {
20393 PyObject *pyobj = 0;
20394
20395 {
20396 #if wxUSE_UNICODE
20397 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20398 #else
20399 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20400 #endif
20401 }
20402 return pyobj;
20403 }
20404
20405
20406 SWIGINTERN int ART_FIND_set(PyObject *) {
20407 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20408 return 1;
20409 }
20410
20411
20412 SWIGINTERN PyObject *ART_FIND_get(void) {
20413 PyObject *pyobj = 0;
20414
20415 {
20416 #if wxUSE_UNICODE
20417 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20418 #else
20419 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20420 #endif
20421 }
20422 return pyobj;
20423 }
20424
20425
20426 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20427 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20428 return 1;
20429 }
20430
20431
20432 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20433 PyObject *pyobj = 0;
20434
20435 {
20436 #if wxUSE_UNICODE
20437 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20438 #else
20439 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20440 #endif
20441 }
20442 return pyobj;
20443 }
20444
20445
20446 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20447 PyObject *resultobj = 0;
20448 wxPyArtProvider *result = 0 ;
20449
20450 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20451 {
20452 if (!wxPyCheckForApp()) SWIG_fail;
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = (wxPyArtProvider *)new wxPyArtProvider();
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20459 return resultobj;
20460 fail:
20461 return NULL;
20462 }
20463
20464
20465 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20466 PyObject *resultobj = 0;
20467 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20468 void *argp1 = 0 ;
20469 int res1 = 0 ;
20470 PyObject *swig_obj[1] ;
20471
20472 if (!args) SWIG_fail;
20473 swig_obj[0] = args;
20474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20475 if (!SWIG_IsOK(res1)) {
20476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20477 }
20478 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20479 {
20480 PyThreadState* __tstate = wxPyBeginAllowThreads();
20481 delete arg1;
20482
20483 wxPyEndAllowThreads(__tstate);
20484 if (PyErr_Occurred()) SWIG_fail;
20485 }
20486 resultobj = SWIG_Py_Void();
20487 return resultobj;
20488 fail:
20489 return NULL;
20490 }
20491
20492
20493 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20494 PyObject *resultobj = 0;
20495 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20496 PyObject *arg2 = (PyObject *) 0 ;
20497 PyObject *arg3 = (PyObject *) 0 ;
20498 void *argp1 = 0 ;
20499 int res1 = 0 ;
20500 PyObject * obj0 = 0 ;
20501 PyObject * obj1 = 0 ;
20502 PyObject * obj2 = 0 ;
20503 char * kwnames[] = {
20504 (char *) "self",(char *) "self",(char *) "_class", NULL
20505 };
20506
20507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20509 if (!SWIG_IsOK(res1)) {
20510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20511 }
20512 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20513 arg2 = obj1;
20514 arg3 = obj2;
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 (arg1)->_setCallbackInfo(arg2,arg3);
20518 wxPyEndAllowThreads(__tstate);
20519 if (PyErr_Occurred()) SWIG_fail;
20520 }
20521 resultobj = SWIG_Py_Void();
20522 return resultobj;
20523 fail:
20524 return NULL;
20525 }
20526
20527
20528 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20529 PyObject *resultobj = 0;
20530 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20531 int res1 = 0 ;
20532 PyObject * obj0 = 0 ;
20533 char * kwnames[] = {
20534 (char *) "provider", NULL
20535 };
20536
20537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20538 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20539 if (!SWIG_IsOK(res1)) {
20540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20541 }
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 wxPyArtProvider::Push(arg1);
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 resultobj = SWIG_Py_Void();
20549 return resultobj;
20550 fail:
20551 return NULL;
20552 }
20553
20554
20555 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20556 PyObject *resultobj = 0;
20557 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20558 int res1 = 0 ;
20559 PyObject * obj0 = 0 ;
20560 char * kwnames[] = {
20561 (char *) "provider", NULL
20562 };
20563
20564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20565 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20566 if (!SWIG_IsOK(res1)) {
20567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20568 }
20569 {
20570 PyThreadState* __tstate = wxPyBeginAllowThreads();
20571 wxPyArtProvider::Insert(arg1);
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 resultobj = SWIG_Py_Void();
20576 return resultobj;
20577 fail:
20578 return NULL;
20579 }
20580
20581
20582 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20583 PyObject *resultobj = 0;
20584 bool result;
20585
20586 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20587 {
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 result = (bool)wxPyArtProvider::Pop();
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 {
20594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20595 }
20596 return resultobj;
20597 fail:
20598 return NULL;
20599 }
20600
20601
20602 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20603 PyObject *resultobj = 0;
20604 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20605 bool result;
20606 void *argp1 = 0 ;
20607 int res1 = 0 ;
20608 PyObject * obj0 = 0 ;
20609 char * kwnames[] = {
20610 (char *) "provider", NULL
20611 };
20612
20613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20615 if (!SWIG_IsOK(res1)) {
20616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20617 }
20618 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20619 {
20620 PyThreadState* __tstate = wxPyBeginAllowThreads();
20621 result = (bool)wxPyArtProvider::Delete(arg1);
20622 wxPyEndAllowThreads(__tstate);
20623 if (PyErr_Occurred()) SWIG_fail;
20624 }
20625 {
20626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20627 }
20628 return resultobj;
20629 fail:
20630 return NULL;
20631 }
20632
20633
20634 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20635 PyObject *resultobj = 0;
20636 wxString *arg1 = 0 ;
20637 wxString const &arg2_defvalue = wxPyART_OTHER ;
20638 wxString *arg2 = (wxString *) &arg2_defvalue ;
20639 wxSize const &arg3_defvalue = wxDefaultSize ;
20640 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20641 wxBitmap result;
20642 bool temp1 = false ;
20643 bool temp2 = false ;
20644 wxSize temp3 ;
20645 PyObject * obj0 = 0 ;
20646 PyObject * obj1 = 0 ;
20647 PyObject * obj2 = 0 ;
20648 char * kwnames[] = {
20649 (char *) "id",(char *) "client",(char *) "size", NULL
20650 };
20651
20652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20653 {
20654 arg1 = wxString_in_helper(obj0);
20655 if (arg1 == NULL) SWIG_fail;
20656 temp1 = true;
20657 }
20658 if (obj1) {
20659 {
20660 arg2 = wxString_in_helper(obj1);
20661 if (arg2 == NULL) SWIG_fail;
20662 temp2 = true;
20663 }
20664 }
20665 if (obj2) {
20666 {
20667 arg3 = &temp3;
20668 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20669 }
20670 }
20671 {
20672 if (!wxPyCheckForApp()) SWIG_fail;
20673 PyThreadState* __tstate = wxPyBeginAllowThreads();
20674 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20675 wxPyEndAllowThreads(__tstate);
20676 if (PyErr_Occurred()) SWIG_fail;
20677 }
20678 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20679 {
20680 if (temp1)
20681 delete arg1;
20682 }
20683 {
20684 if (temp2)
20685 delete arg2;
20686 }
20687 return resultobj;
20688 fail:
20689 {
20690 if (temp1)
20691 delete arg1;
20692 }
20693 {
20694 if (temp2)
20695 delete arg2;
20696 }
20697 return NULL;
20698 }
20699
20700
20701 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj = 0;
20703 wxString *arg1 = 0 ;
20704 wxString const &arg2_defvalue = wxPyART_OTHER ;
20705 wxString *arg2 = (wxString *) &arg2_defvalue ;
20706 wxSize const &arg3_defvalue = wxDefaultSize ;
20707 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20708 wxIcon result;
20709 bool temp1 = false ;
20710 bool temp2 = false ;
20711 wxSize temp3 ;
20712 PyObject * obj0 = 0 ;
20713 PyObject * obj1 = 0 ;
20714 PyObject * obj2 = 0 ;
20715 char * kwnames[] = {
20716 (char *) "id",(char *) "client",(char *) "size", NULL
20717 };
20718
20719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20720 {
20721 arg1 = wxString_in_helper(obj0);
20722 if (arg1 == NULL) SWIG_fail;
20723 temp1 = true;
20724 }
20725 if (obj1) {
20726 {
20727 arg2 = wxString_in_helper(obj1);
20728 if (arg2 == NULL) SWIG_fail;
20729 temp2 = true;
20730 }
20731 }
20732 if (obj2) {
20733 {
20734 arg3 = &temp3;
20735 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20736 }
20737 }
20738 {
20739 if (!wxPyCheckForApp()) SWIG_fail;
20740 PyThreadState* __tstate = wxPyBeginAllowThreads();
20741 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20742 wxPyEndAllowThreads(__tstate);
20743 if (PyErr_Occurred()) SWIG_fail;
20744 }
20745 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20746 {
20747 if (temp1)
20748 delete arg1;
20749 }
20750 {
20751 if (temp2)
20752 delete arg2;
20753 }
20754 return resultobj;
20755 fail:
20756 {
20757 if (temp1)
20758 delete arg1;
20759 }
20760 {
20761 if (temp2)
20762 delete arg2;
20763 }
20764 return NULL;
20765 }
20766
20767
20768 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20769 PyObject *resultobj = 0;
20770 wxString *arg1 = 0 ;
20771 bool arg2 = (bool) false ;
20772 wxSize result;
20773 bool temp1 = false ;
20774 bool val2 ;
20775 int ecode2 = 0 ;
20776 PyObject * obj0 = 0 ;
20777 PyObject * obj1 = 0 ;
20778 char * kwnames[] = {
20779 (char *) "client",(char *) "platform_dependent", NULL
20780 };
20781
20782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20783 {
20784 arg1 = wxString_in_helper(obj0);
20785 if (arg1 == NULL) SWIG_fail;
20786 temp1 = true;
20787 }
20788 if (obj1) {
20789 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20790 if (!SWIG_IsOK(ecode2)) {
20791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20792 }
20793 arg2 = static_cast< bool >(val2);
20794 }
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20802 {
20803 if (temp1)
20804 delete arg1;
20805 }
20806 return resultobj;
20807 fail:
20808 {
20809 if (temp1)
20810 delete arg1;
20811 }
20812 return NULL;
20813 }
20814
20815
20816 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20817 PyObject *resultobj = 0;
20818 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20819 void *argp1 = 0 ;
20820 int res1 = 0 ;
20821 PyObject *swig_obj[1] ;
20822
20823 if (!args) SWIG_fail;
20824 swig_obj[0] = args;
20825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20826 if (!SWIG_IsOK(res1)) {
20827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20828 }
20829 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20830 {
20831 PyThreadState* __tstate = wxPyBeginAllowThreads();
20832 wxPyArtProvider_Destroy(arg1);
20833 wxPyEndAllowThreads(__tstate);
20834 if (PyErr_Occurred()) SWIG_fail;
20835 }
20836 resultobj = SWIG_Py_Void();
20837 return resultobj;
20838 fail:
20839 return NULL;
20840 }
20841
20842
20843 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20844 PyObject *obj;
20845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20846 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20847 return SWIG_Py_Void();
20848 }
20849
20850 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20851 return SWIG_Python_InitShadowInstance(args);
20852 }
20853
20854 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *resultobj = 0;
20856 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20857 void *argp1 = 0 ;
20858 int res1 = 0 ;
20859 PyObject *swig_obj[1] ;
20860
20861 if (!args) SWIG_fail;
20862 swig_obj[0] = args;
20863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20864 if (!SWIG_IsOK(res1)) {
20865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20866 }
20867 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20868 {
20869 PyThreadState* __tstate = wxPyBeginAllowThreads();
20870 delete arg1;
20871
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 resultobj = SWIG_Py_Void();
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20883 PyObject *resultobj = 0;
20884 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20885 wxConfigBase *result = 0 ;
20886 int res1 = 0 ;
20887 PyObject * obj0 = 0 ;
20888 char * kwnames[] = {
20889 (char *) "config", NULL
20890 };
20891
20892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20893 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20894 if (!SWIG_IsOK(res1)) {
20895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20896 }
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20900 wxPyEndAllowThreads(__tstate);
20901 if (PyErr_Occurred()) SWIG_fail;
20902 }
20903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20911 PyObject *resultobj = 0;
20912 bool arg1 = (bool) true ;
20913 wxConfigBase *result = 0 ;
20914 bool val1 ;
20915 int ecode1 = 0 ;
20916 PyObject * obj0 = 0 ;
20917 char * kwnames[] = {
20918 (char *) "createOnDemand", NULL
20919 };
20920
20921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20922 if (obj0) {
20923 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20924 if (!SWIG_IsOK(ecode1)) {
20925 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20926 }
20927 arg1 = static_cast< bool >(val1);
20928 }
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *resultobj = 0;
20944 wxConfigBase *result = 0 ;
20945
20946 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20947 {
20948 PyThreadState* __tstate = wxPyBeginAllowThreads();
20949 result = (wxConfigBase *)wxConfigBase::Create();
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20961 PyObject *resultobj = 0;
20962
20963 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 wxConfigBase::DontCreateOnDemand();
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 resultobj = SWIG_Py_Void();
20971 return resultobj;
20972 fail:
20973 return NULL;
20974 }
20975
20976
20977 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20978 PyObject *resultobj = 0;
20979 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20980 wxString *arg2 = 0 ;
20981 void *argp1 = 0 ;
20982 int res1 = 0 ;
20983 bool temp2 = false ;
20984 PyObject * obj0 = 0 ;
20985 PyObject * obj1 = 0 ;
20986 char * kwnames[] = {
20987 (char *) "self",(char *) "path", NULL
20988 };
20989
20990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20992 if (!SWIG_IsOK(res1)) {
20993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20994 }
20995 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20996 {
20997 arg2 = wxString_in_helper(obj1);
20998 if (arg2 == NULL) SWIG_fail;
20999 temp2 = true;
21000 }
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 (arg1)->SetPath((wxString const &)*arg2);
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 resultobj = SWIG_Py_Void();
21008 {
21009 if (temp2)
21010 delete arg2;
21011 }
21012 return resultobj;
21013 fail:
21014 {
21015 if (temp2)
21016 delete arg2;
21017 }
21018 return NULL;
21019 }
21020
21021
21022 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21023 PyObject *resultobj = 0;
21024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21025 wxString *result = 0 ;
21026 void *argp1 = 0 ;
21027 int res1 = 0 ;
21028 PyObject *swig_obj[1] ;
21029
21030 if (!args) SWIG_fail;
21031 swig_obj[0] = args;
21032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21033 if (!SWIG_IsOK(res1)) {
21034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21035 }
21036 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21037 {
21038 PyThreadState* __tstate = wxPyBeginAllowThreads();
21039 {
21040 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21041 result = (wxString *) &_result_ref;
21042 }
21043 wxPyEndAllowThreads(__tstate);
21044 if (PyErr_Occurred()) SWIG_fail;
21045 }
21046 {
21047 #if wxUSE_UNICODE
21048 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21049 #else
21050 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21051 #endif
21052 }
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21060 PyObject *resultobj = 0;
21061 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21062 PyObject *result = 0 ;
21063 void *argp1 = 0 ;
21064 int res1 = 0 ;
21065 PyObject *swig_obj[1] ;
21066
21067 if (!args) SWIG_fail;
21068 swig_obj[0] = args;
21069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21070 if (!SWIG_IsOK(res1)) {
21071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21072 }
21073 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21074 {
21075 PyThreadState* __tstate = wxPyBeginAllowThreads();
21076 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21077 wxPyEndAllowThreads(__tstate);
21078 if (PyErr_Occurred()) SWIG_fail;
21079 }
21080 resultobj = result;
21081 return resultobj;
21082 fail:
21083 return NULL;
21084 }
21085
21086
21087 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21088 PyObject *resultobj = 0;
21089 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21090 long arg2 ;
21091 PyObject *result = 0 ;
21092 void *argp1 = 0 ;
21093 int res1 = 0 ;
21094 long val2 ;
21095 int ecode2 = 0 ;
21096 PyObject * obj0 = 0 ;
21097 PyObject * obj1 = 0 ;
21098 char * kwnames[] = {
21099 (char *) "self",(char *) "index", NULL
21100 };
21101
21102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21104 if (!SWIG_IsOK(res1)) {
21105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21106 }
21107 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21108 ecode2 = SWIG_AsVal_long(obj1, &val2);
21109 if (!SWIG_IsOK(ecode2)) {
21110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21111 }
21112 arg2 = static_cast< long >(val2);
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21116 wxPyEndAllowThreads(__tstate);
21117 if (PyErr_Occurred()) SWIG_fail;
21118 }
21119 resultobj = result;
21120 return resultobj;
21121 fail:
21122 return NULL;
21123 }
21124
21125
21126 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21127 PyObject *resultobj = 0;
21128 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21129 PyObject *result = 0 ;
21130 void *argp1 = 0 ;
21131 int res1 = 0 ;
21132 PyObject *swig_obj[1] ;
21133
21134 if (!args) SWIG_fail;
21135 swig_obj[0] = args;
21136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21137 if (!SWIG_IsOK(res1)) {
21138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21139 }
21140 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21141 {
21142 PyThreadState* __tstate = wxPyBeginAllowThreads();
21143 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21144 wxPyEndAllowThreads(__tstate);
21145 if (PyErr_Occurred()) SWIG_fail;
21146 }
21147 resultobj = result;
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21155 PyObject *resultobj = 0;
21156 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21157 long arg2 ;
21158 PyObject *result = 0 ;
21159 void *argp1 = 0 ;
21160 int res1 = 0 ;
21161 long val2 ;
21162 int ecode2 = 0 ;
21163 PyObject * obj0 = 0 ;
21164 PyObject * obj1 = 0 ;
21165 char * kwnames[] = {
21166 (char *) "self",(char *) "index", NULL
21167 };
21168
21169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21171 if (!SWIG_IsOK(res1)) {
21172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21173 }
21174 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21175 ecode2 = SWIG_AsVal_long(obj1, &val2);
21176 if (!SWIG_IsOK(ecode2)) {
21177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21178 }
21179 arg2 = static_cast< long >(val2);
21180 {
21181 PyThreadState* __tstate = wxPyBeginAllowThreads();
21182 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21183 wxPyEndAllowThreads(__tstate);
21184 if (PyErr_Occurred()) SWIG_fail;
21185 }
21186 resultobj = result;
21187 return resultobj;
21188 fail:
21189 return NULL;
21190 }
21191
21192
21193 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21194 PyObject *resultobj = 0;
21195 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21196 bool arg2 = (bool) false ;
21197 size_t result;
21198 void *argp1 = 0 ;
21199 int res1 = 0 ;
21200 bool val2 ;
21201 int ecode2 = 0 ;
21202 PyObject * obj0 = 0 ;
21203 PyObject * obj1 = 0 ;
21204 char * kwnames[] = {
21205 (char *) "self",(char *) "recursive", NULL
21206 };
21207
21208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21210 if (!SWIG_IsOK(res1)) {
21211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21212 }
21213 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21214 if (obj1) {
21215 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21216 if (!SWIG_IsOK(ecode2)) {
21217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21218 }
21219 arg2 = static_cast< bool >(val2);
21220 }
21221 {
21222 PyThreadState* __tstate = wxPyBeginAllowThreads();
21223 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21224 wxPyEndAllowThreads(__tstate);
21225 if (PyErr_Occurred()) SWIG_fail;
21226 }
21227 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj = 0;
21236 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21237 bool arg2 = (bool) false ;
21238 size_t result;
21239 void *argp1 = 0 ;
21240 int res1 = 0 ;
21241 bool val2 ;
21242 int ecode2 = 0 ;
21243 PyObject * obj0 = 0 ;
21244 PyObject * obj1 = 0 ;
21245 char * kwnames[] = {
21246 (char *) "self",(char *) "recursive", NULL
21247 };
21248
21249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21251 if (!SWIG_IsOK(res1)) {
21252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21253 }
21254 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21255 if (obj1) {
21256 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21257 if (!SWIG_IsOK(ecode2)) {
21258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21259 }
21260 arg2 = static_cast< bool >(val2);
21261 }
21262 {
21263 PyThreadState* __tstate = wxPyBeginAllowThreads();
21264 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21269 return resultobj;
21270 fail:
21271 return NULL;
21272 }
21273
21274
21275 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21276 PyObject *resultobj = 0;
21277 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21278 wxString *arg2 = 0 ;
21279 bool result;
21280 void *argp1 = 0 ;
21281 int res1 = 0 ;
21282 bool temp2 = false ;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 char * kwnames[] = {
21286 (char *) "self",(char *) "name", NULL
21287 };
21288
21289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21291 if (!SWIG_IsOK(res1)) {
21292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21293 }
21294 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21295 {
21296 arg2 = wxString_in_helper(obj1);
21297 if (arg2 == NULL) SWIG_fail;
21298 temp2 = true;
21299 }
21300 {
21301 PyThreadState* __tstate = wxPyBeginAllowThreads();
21302 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 {
21307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21308 }
21309 {
21310 if (temp2)
21311 delete arg2;
21312 }
21313 return resultobj;
21314 fail:
21315 {
21316 if (temp2)
21317 delete arg2;
21318 }
21319 return NULL;
21320 }
21321
21322
21323 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21324 PyObject *resultobj = 0;
21325 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21326 wxString *arg2 = 0 ;
21327 bool result;
21328 void *argp1 = 0 ;
21329 int res1 = 0 ;
21330 bool temp2 = false ;
21331 PyObject * obj0 = 0 ;
21332 PyObject * obj1 = 0 ;
21333 char * kwnames[] = {
21334 (char *) "self",(char *) "name", NULL
21335 };
21336
21337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21339 if (!SWIG_IsOK(res1)) {
21340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21341 }
21342 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21343 {
21344 arg2 = wxString_in_helper(obj1);
21345 if (arg2 == NULL) SWIG_fail;
21346 temp2 = true;
21347 }
21348 {
21349 PyThreadState* __tstate = wxPyBeginAllowThreads();
21350 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 {
21355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21356 }
21357 {
21358 if (temp2)
21359 delete arg2;
21360 }
21361 return resultobj;
21362 fail:
21363 {
21364 if (temp2)
21365 delete arg2;
21366 }
21367 return NULL;
21368 }
21369
21370
21371 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21372 PyObject *resultobj = 0;
21373 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21374 wxString *arg2 = 0 ;
21375 bool result;
21376 void *argp1 = 0 ;
21377 int res1 = 0 ;
21378 bool temp2 = false ;
21379 PyObject * obj0 = 0 ;
21380 PyObject * obj1 = 0 ;
21381 char * kwnames[] = {
21382 (char *) "self",(char *) "name", NULL
21383 };
21384
21385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21389 }
21390 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21391 {
21392 arg2 = wxString_in_helper(obj1);
21393 if (arg2 == NULL) SWIG_fail;
21394 temp2 = true;
21395 }
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 {
21403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21404 }
21405 {
21406 if (temp2)
21407 delete arg2;
21408 }
21409 return resultobj;
21410 fail:
21411 {
21412 if (temp2)
21413 delete arg2;
21414 }
21415 return NULL;
21416 }
21417
21418
21419 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21420 PyObject *resultobj = 0;
21421 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21422 wxString *arg2 = 0 ;
21423 wxConfigBase::EntryType result;
21424 void *argp1 = 0 ;
21425 int res1 = 0 ;
21426 bool temp2 = false ;
21427 PyObject * obj0 = 0 ;
21428 PyObject * obj1 = 0 ;
21429 char * kwnames[] = {
21430 (char *) "self",(char *) "name", NULL
21431 };
21432
21433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21435 if (!SWIG_IsOK(res1)) {
21436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21437 }
21438 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21439 {
21440 arg2 = wxString_in_helper(obj1);
21441 if (arg2 == NULL) SWIG_fail;
21442 temp2 = true;
21443 }
21444 {
21445 PyThreadState* __tstate = wxPyBeginAllowThreads();
21446 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21447 wxPyEndAllowThreads(__tstate);
21448 if (PyErr_Occurred()) SWIG_fail;
21449 }
21450 resultobj = SWIG_From_int(static_cast< int >(result));
21451 {
21452 if (temp2)
21453 delete arg2;
21454 }
21455 return resultobj;
21456 fail:
21457 {
21458 if (temp2)
21459 delete arg2;
21460 }
21461 return NULL;
21462 }
21463
21464
21465 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21466 PyObject *resultobj = 0;
21467 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21468 wxString *arg2 = 0 ;
21469 wxString const &arg3_defvalue = wxPyEmptyString ;
21470 wxString *arg3 = (wxString *) &arg3_defvalue ;
21471 wxString result;
21472 void *argp1 = 0 ;
21473 int res1 = 0 ;
21474 bool temp2 = false ;
21475 bool temp3 = false ;
21476 PyObject * obj0 = 0 ;
21477 PyObject * obj1 = 0 ;
21478 PyObject * obj2 = 0 ;
21479 char * kwnames[] = {
21480 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21481 };
21482
21483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21485 if (!SWIG_IsOK(res1)) {
21486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21487 }
21488 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21489 {
21490 arg2 = wxString_in_helper(obj1);
21491 if (arg2 == NULL) SWIG_fail;
21492 temp2 = true;
21493 }
21494 if (obj2) {
21495 {
21496 arg3 = wxString_in_helper(obj2);
21497 if (arg3 == NULL) SWIG_fail;
21498 temp3 = true;
21499 }
21500 }
21501 {
21502 PyThreadState* __tstate = wxPyBeginAllowThreads();
21503 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21504 wxPyEndAllowThreads(__tstate);
21505 if (PyErr_Occurred()) SWIG_fail;
21506 }
21507 {
21508 #if wxUSE_UNICODE
21509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21510 #else
21511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21512 #endif
21513 }
21514 {
21515 if (temp2)
21516 delete arg2;
21517 }
21518 {
21519 if (temp3)
21520 delete arg3;
21521 }
21522 return resultobj;
21523 fail:
21524 {
21525 if (temp2)
21526 delete arg2;
21527 }
21528 {
21529 if (temp3)
21530 delete arg3;
21531 }
21532 return NULL;
21533 }
21534
21535
21536 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21537 PyObject *resultobj = 0;
21538 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21539 wxString *arg2 = 0 ;
21540 long arg3 = (long) 0 ;
21541 long result;
21542 void *argp1 = 0 ;
21543 int res1 = 0 ;
21544 bool temp2 = false ;
21545 long val3 ;
21546 int ecode3 = 0 ;
21547 PyObject * obj0 = 0 ;
21548 PyObject * obj1 = 0 ;
21549 PyObject * obj2 = 0 ;
21550 char * kwnames[] = {
21551 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21552 };
21553
21554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21556 if (!SWIG_IsOK(res1)) {
21557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21558 }
21559 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21560 {
21561 arg2 = wxString_in_helper(obj1);
21562 if (arg2 == NULL) SWIG_fail;
21563 temp2 = true;
21564 }
21565 if (obj2) {
21566 ecode3 = SWIG_AsVal_long(obj2, &val3);
21567 if (!SWIG_IsOK(ecode3)) {
21568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21569 }
21570 arg3 = static_cast< long >(val3);
21571 }
21572 {
21573 PyThreadState* __tstate = wxPyBeginAllowThreads();
21574 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21575 wxPyEndAllowThreads(__tstate);
21576 if (PyErr_Occurred()) SWIG_fail;
21577 }
21578 resultobj = SWIG_From_long(static_cast< long >(result));
21579 {
21580 if (temp2)
21581 delete arg2;
21582 }
21583 return resultobj;
21584 fail:
21585 {
21586 if (temp2)
21587 delete arg2;
21588 }
21589 return NULL;
21590 }
21591
21592
21593 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21594 PyObject *resultobj = 0;
21595 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21596 wxString *arg2 = 0 ;
21597 double arg3 = (double) 0.0 ;
21598 double result;
21599 void *argp1 = 0 ;
21600 int res1 = 0 ;
21601 bool temp2 = false ;
21602 double val3 ;
21603 int ecode3 = 0 ;
21604 PyObject * obj0 = 0 ;
21605 PyObject * obj1 = 0 ;
21606 PyObject * obj2 = 0 ;
21607 char * kwnames[] = {
21608 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21609 };
21610
21611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21613 if (!SWIG_IsOK(res1)) {
21614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21615 }
21616 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21617 {
21618 arg2 = wxString_in_helper(obj1);
21619 if (arg2 == NULL) SWIG_fail;
21620 temp2 = true;
21621 }
21622 if (obj2) {
21623 ecode3 = SWIG_AsVal_double(obj2, &val3);
21624 if (!SWIG_IsOK(ecode3)) {
21625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21626 }
21627 arg3 = static_cast< double >(val3);
21628 }
21629 {
21630 PyThreadState* __tstate = wxPyBeginAllowThreads();
21631 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21632 wxPyEndAllowThreads(__tstate);
21633 if (PyErr_Occurred()) SWIG_fail;
21634 }
21635 resultobj = SWIG_From_double(static_cast< double >(result));
21636 {
21637 if (temp2)
21638 delete arg2;
21639 }
21640 return resultobj;
21641 fail:
21642 {
21643 if (temp2)
21644 delete arg2;
21645 }
21646 return NULL;
21647 }
21648
21649
21650 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21651 PyObject *resultobj = 0;
21652 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21653 wxString *arg2 = 0 ;
21654 bool arg3 = (bool) false ;
21655 bool result;
21656 void *argp1 = 0 ;
21657 int res1 = 0 ;
21658 bool temp2 = false ;
21659 bool val3 ;
21660 int ecode3 = 0 ;
21661 PyObject * obj0 = 0 ;
21662 PyObject * obj1 = 0 ;
21663 PyObject * obj2 = 0 ;
21664 char * kwnames[] = {
21665 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21666 };
21667
21668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21670 if (!SWIG_IsOK(res1)) {
21671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21672 }
21673 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21674 {
21675 arg2 = wxString_in_helper(obj1);
21676 if (arg2 == NULL) SWIG_fail;
21677 temp2 = true;
21678 }
21679 if (obj2) {
21680 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21681 if (!SWIG_IsOK(ecode3)) {
21682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21683 }
21684 arg3 = static_cast< bool >(val3);
21685 }
21686 {
21687 PyThreadState* __tstate = wxPyBeginAllowThreads();
21688 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21689 wxPyEndAllowThreads(__tstate);
21690 if (PyErr_Occurred()) SWIG_fail;
21691 }
21692 {
21693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21694 }
21695 {
21696 if (temp2)
21697 delete arg2;
21698 }
21699 return resultobj;
21700 fail:
21701 {
21702 if (temp2)
21703 delete arg2;
21704 }
21705 return NULL;
21706 }
21707
21708
21709 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21710 PyObject *resultobj = 0;
21711 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21712 wxString *arg2 = 0 ;
21713 wxString *arg3 = 0 ;
21714 bool result;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 bool temp2 = false ;
21718 bool temp3 = false ;
21719 PyObject * obj0 = 0 ;
21720 PyObject * obj1 = 0 ;
21721 PyObject * obj2 = 0 ;
21722 char * kwnames[] = {
21723 (char *) "self",(char *) "key",(char *) "value", NULL
21724 };
21725
21726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21728 if (!SWIG_IsOK(res1)) {
21729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21730 }
21731 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21732 {
21733 arg2 = wxString_in_helper(obj1);
21734 if (arg2 == NULL) SWIG_fail;
21735 temp2 = true;
21736 }
21737 {
21738 arg3 = wxString_in_helper(obj2);
21739 if (arg3 == NULL) SWIG_fail;
21740 temp3 = true;
21741 }
21742 {
21743 PyThreadState* __tstate = wxPyBeginAllowThreads();
21744 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21745 wxPyEndAllowThreads(__tstate);
21746 if (PyErr_Occurred()) SWIG_fail;
21747 }
21748 {
21749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21750 }
21751 {
21752 if (temp2)
21753 delete arg2;
21754 }
21755 {
21756 if (temp3)
21757 delete arg3;
21758 }
21759 return resultobj;
21760 fail:
21761 {
21762 if (temp2)
21763 delete arg2;
21764 }
21765 {
21766 if (temp3)
21767 delete arg3;
21768 }
21769 return NULL;
21770 }
21771
21772
21773 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21774 PyObject *resultobj = 0;
21775 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21776 wxString *arg2 = 0 ;
21777 long arg3 ;
21778 bool result;
21779 void *argp1 = 0 ;
21780 int res1 = 0 ;
21781 bool temp2 = false ;
21782 long val3 ;
21783 int ecode3 = 0 ;
21784 PyObject * obj0 = 0 ;
21785 PyObject * obj1 = 0 ;
21786 PyObject * obj2 = 0 ;
21787 char * kwnames[] = {
21788 (char *) "self",(char *) "key",(char *) "value", NULL
21789 };
21790
21791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21793 if (!SWIG_IsOK(res1)) {
21794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21795 }
21796 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21797 {
21798 arg2 = wxString_in_helper(obj1);
21799 if (arg2 == NULL) SWIG_fail;
21800 temp2 = true;
21801 }
21802 ecode3 = SWIG_AsVal_long(obj2, &val3);
21803 if (!SWIG_IsOK(ecode3)) {
21804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21805 }
21806 arg3 = static_cast< long >(val3);
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 {
21814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21815 }
21816 {
21817 if (temp2)
21818 delete arg2;
21819 }
21820 return resultobj;
21821 fail:
21822 {
21823 if (temp2)
21824 delete arg2;
21825 }
21826 return NULL;
21827 }
21828
21829
21830 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj = 0;
21832 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21833 wxString *arg2 = 0 ;
21834 double arg3 ;
21835 bool result;
21836 void *argp1 = 0 ;
21837 int res1 = 0 ;
21838 bool temp2 = false ;
21839 double val3 ;
21840 int ecode3 = 0 ;
21841 PyObject * obj0 = 0 ;
21842 PyObject * obj1 = 0 ;
21843 PyObject * obj2 = 0 ;
21844 char * kwnames[] = {
21845 (char *) "self",(char *) "key",(char *) "value", NULL
21846 };
21847
21848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21850 if (!SWIG_IsOK(res1)) {
21851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21852 }
21853 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21854 {
21855 arg2 = wxString_in_helper(obj1);
21856 if (arg2 == NULL) SWIG_fail;
21857 temp2 = true;
21858 }
21859 ecode3 = SWIG_AsVal_double(obj2, &val3);
21860 if (!SWIG_IsOK(ecode3)) {
21861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21862 }
21863 arg3 = static_cast< double >(val3);
21864 {
21865 PyThreadState* __tstate = wxPyBeginAllowThreads();
21866 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21867 wxPyEndAllowThreads(__tstate);
21868 if (PyErr_Occurred()) SWIG_fail;
21869 }
21870 {
21871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21872 }
21873 {
21874 if (temp2)
21875 delete arg2;
21876 }
21877 return resultobj;
21878 fail:
21879 {
21880 if (temp2)
21881 delete arg2;
21882 }
21883 return NULL;
21884 }
21885
21886
21887 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21888 PyObject *resultobj = 0;
21889 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21890 wxString *arg2 = 0 ;
21891 bool arg3 ;
21892 bool result;
21893 void *argp1 = 0 ;
21894 int res1 = 0 ;
21895 bool temp2 = false ;
21896 bool val3 ;
21897 int ecode3 = 0 ;
21898 PyObject * obj0 = 0 ;
21899 PyObject * obj1 = 0 ;
21900 PyObject * obj2 = 0 ;
21901 char * kwnames[] = {
21902 (char *) "self",(char *) "key",(char *) "value", NULL
21903 };
21904
21905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21907 if (!SWIG_IsOK(res1)) {
21908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21909 }
21910 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21911 {
21912 arg2 = wxString_in_helper(obj1);
21913 if (arg2 == NULL) SWIG_fail;
21914 temp2 = true;
21915 }
21916 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21917 if (!SWIG_IsOK(ecode3)) {
21918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21919 }
21920 arg3 = static_cast< bool >(val3);
21921 {
21922 PyThreadState* __tstate = wxPyBeginAllowThreads();
21923 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21924 wxPyEndAllowThreads(__tstate);
21925 if (PyErr_Occurred()) SWIG_fail;
21926 }
21927 {
21928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21929 }
21930 {
21931 if (temp2)
21932 delete arg2;
21933 }
21934 return resultobj;
21935 fail:
21936 {
21937 if (temp2)
21938 delete arg2;
21939 }
21940 return NULL;
21941 }
21942
21943
21944 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21945 PyObject *resultobj = 0;
21946 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21947 bool arg2 = (bool) false ;
21948 bool result;
21949 void *argp1 = 0 ;
21950 int res1 = 0 ;
21951 bool val2 ;
21952 int ecode2 = 0 ;
21953 PyObject * obj0 = 0 ;
21954 PyObject * obj1 = 0 ;
21955 char * kwnames[] = {
21956 (char *) "self",(char *) "currentOnly", NULL
21957 };
21958
21959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21961 if (!SWIG_IsOK(res1)) {
21962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21963 }
21964 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21965 if (obj1) {
21966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21967 if (!SWIG_IsOK(ecode2)) {
21968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21969 }
21970 arg2 = static_cast< bool >(val2);
21971 }
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 result = (bool)(arg1)->Flush(arg2);
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 {
21979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21980 }
21981 return resultobj;
21982 fail:
21983 return NULL;
21984 }
21985
21986
21987 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21988 PyObject *resultobj = 0;
21989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21990 wxString *arg2 = 0 ;
21991 wxString *arg3 = 0 ;
21992 bool result;
21993 void *argp1 = 0 ;
21994 int res1 = 0 ;
21995 bool temp2 = false ;
21996 bool temp3 = false ;
21997 PyObject * obj0 = 0 ;
21998 PyObject * obj1 = 0 ;
21999 PyObject * obj2 = 0 ;
22000 char * kwnames[] = {
22001 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22002 };
22003
22004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22006 if (!SWIG_IsOK(res1)) {
22007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22008 }
22009 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22010 {
22011 arg2 = wxString_in_helper(obj1);
22012 if (arg2 == NULL) SWIG_fail;
22013 temp2 = true;
22014 }
22015 {
22016 arg3 = wxString_in_helper(obj2);
22017 if (arg3 == NULL) SWIG_fail;
22018 temp3 = true;
22019 }
22020 {
22021 PyThreadState* __tstate = wxPyBeginAllowThreads();
22022 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 {
22027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22028 }
22029 {
22030 if (temp2)
22031 delete arg2;
22032 }
22033 {
22034 if (temp3)
22035 delete arg3;
22036 }
22037 return resultobj;
22038 fail:
22039 {
22040 if (temp2)
22041 delete arg2;
22042 }
22043 {
22044 if (temp3)
22045 delete arg3;
22046 }
22047 return NULL;
22048 }
22049
22050
22051 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22052 PyObject *resultobj = 0;
22053 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22054 wxString *arg2 = 0 ;
22055 wxString *arg3 = 0 ;
22056 bool result;
22057 void *argp1 = 0 ;
22058 int res1 = 0 ;
22059 bool temp2 = false ;
22060 bool temp3 = false ;
22061 PyObject * obj0 = 0 ;
22062 PyObject * obj1 = 0 ;
22063 PyObject * obj2 = 0 ;
22064 char * kwnames[] = {
22065 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22066 };
22067
22068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22070 if (!SWIG_IsOK(res1)) {
22071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22072 }
22073 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22074 {
22075 arg2 = wxString_in_helper(obj1);
22076 if (arg2 == NULL) SWIG_fail;
22077 temp2 = true;
22078 }
22079 {
22080 arg3 = wxString_in_helper(obj2);
22081 if (arg3 == NULL) SWIG_fail;
22082 temp3 = true;
22083 }
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 {
22091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22092 }
22093 {
22094 if (temp2)
22095 delete arg2;
22096 }
22097 {
22098 if (temp3)
22099 delete arg3;
22100 }
22101 return resultobj;
22102 fail:
22103 {
22104 if (temp2)
22105 delete arg2;
22106 }
22107 {
22108 if (temp3)
22109 delete arg3;
22110 }
22111 return NULL;
22112 }
22113
22114
22115 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22116 PyObject *resultobj = 0;
22117 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22118 wxString *arg2 = 0 ;
22119 bool arg3 = (bool) true ;
22120 bool result;
22121 void *argp1 = 0 ;
22122 int res1 = 0 ;
22123 bool temp2 = false ;
22124 bool val3 ;
22125 int ecode3 = 0 ;
22126 PyObject * obj0 = 0 ;
22127 PyObject * obj1 = 0 ;
22128 PyObject * obj2 = 0 ;
22129 char * kwnames[] = {
22130 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22131 };
22132
22133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22135 if (!SWIG_IsOK(res1)) {
22136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22137 }
22138 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22139 {
22140 arg2 = wxString_in_helper(obj1);
22141 if (arg2 == NULL) SWIG_fail;
22142 temp2 = true;
22143 }
22144 if (obj2) {
22145 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22146 if (!SWIG_IsOK(ecode3)) {
22147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22148 }
22149 arg3 = static_cast< bool >(val3);
22150 }
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 {
22158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22159 }
22160 {
22161 if (temp2)
22162 delete arg2;
22163 }
22164 return resultobj;
22165 fail:
22166 {
22167 if (temp2)
22168 delete arg2;
22169 }
22170 return NULL;
22171 }
22172
22173
22174 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22175 PyObject *resultobj = 0;
22176 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22177 wxString *arg2 = 0 ;
22178 bool result;
22179 void *argp1 = 0 ;
22180 int res1 = 0 ;
22181 bool temp2 = false ;
22182 PyObject * obj0 = 0 ;
22183 PyObject * obj1 = 0 ;
22184 char * kwnames[] = {
22185 (char *) "self",(char *) "key", NULL
22186 };
22187
22188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22190 if (!SWIG_IsOK(res1)) {
22191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22192 }
22193 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22194 {
22195 arg2 = wxString_in_helper(obj1);
22196 if (arg2 == NULL) SWIG_fail;
22197 temp2 = true;
22198 }
22199 {
22200 PyThreadState* __tstate = wxPyBeginAllowThreads();
22201 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22202 wxPyEndAllowThreads(__tstate);
22203 if (PyErr_Occurred()) SWIG_fail;
22204 }
22205 {
22206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22207 }
22208 {
22209 if (temp2)
22210 delete arg2;
22211 }
22212 return resultobj;
22213 fail:
22214 {
22215 if (temp2)
22216 delete arg2;
22217 }
22218 return NULL;
22219 }
22220
22221
22222 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22223 PyObject *resultobj = 0;
22224 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22225 bool result;
22226 void *argp1 = 0 ;
22227 int res1 = 0 ;
22228 PyObject *swig_obj[1] ;
22229
22230 if (!args) SWIG_fail;
22231 swig_obj[0] = args;
22232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22233 if (!SWIG_IsOK(res1)) {
22234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22235 }
22236 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 result = (bool)(arg1)->DeleteAll();
22240 wxPyEndAllowThreads(__tstate);
22241 if (PyErr_Occurred()) SWIG_fail;
22242 }
22243 {
22244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22245 }
22246 return resultobj;
22247 fail:
22248 return NULL;
22249 }
22250
22251
22252 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22253 PyObject *resultobj = 0;
22254 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22255 bool arg2 = (bool) true ;
22256 void *argp1 = 0 ;
22257 int res1 = 0 ;
22258 bool val2 ;
22259 int ecode2 = 0 ;
22260 PyObject * obj0 = 0 ;
22261 PyObject * obj1 = 0 ;
22262 char * kwnames[] = {
22263 (char *) "self",(char *) "doIt", NULL
22264 };
22265
22266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22268 if (!SWIG_IsOK(res1)) {
22269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22270 }
22271 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22272 if (obj1) {
22273 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22274 if (!SWIG_IsOK(ecode2)) {
22275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22276 }
22277 arg2 = static_cast< bool >(val2);
22278 }
22279 {
22280 PyThreadState* __tstate = wxPyBeginAllowThreads();
22281 (arg1)->SetExpandEnvVars(arg2);
22282 wxPyEndAllowThreads(__tstate);
22283 if (PyErr_Occurred()) SWIG_fail;
22284 }
22285 resultobj = SWIG_Py_Void();
22286 return resultobj;
22287 fail:
22288 return NULL;
22289 }
22290
22291
22292 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22293 PyObject *resultobj = 0;
22294 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22295 bool result;
22296 void *argp1 = 0 ;
22297 int res1 = 0 ;
22298 PyObject *swig_obj[1] ;
22299
22300 if (!args) SWIG_fail;
22301 swig_obj[0] = args;
22302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22303 if (!SWIG_IsOK(res1)) {
22304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22305 }
22306 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22307 {
22308 PyThreadState* __tstate = wxPyBeginAllowThreads();
22309 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 {
22314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22315 }
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22323 PyObject *resultobj = 0;
22324 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22325 bool arg2 = (bool) true ;
22326 void *argp1 = 0 ;
22327 int res1 = 0 ;
22328 bool val2 ;
22329 int ecode2 = 0 ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 char * kwnames[] = {
22333 (char *) "self",(char *) "doIt", NULL
22334 };
22335
22336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22338 if (!SWIG_IsOK(res1)) {
22339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22340 }
22341 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22342 if (obj1) {
22343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22344 if (!SWIG_IsOK(ecode2)) {
22345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22346 }
22347 arg2 = static_cast< bool >(val2);
22348 }
22349 {
22350 PyThreadState* __tstate = wxPyBeginAllowThreads();
22351 (arg1)->SetRecordDefaults(arg2);
22352 wxPyEndAllowThreads(__tstate);
22353 if (PyErr_Occurred()) SWIG_fail;
22354 }
22355 resultobj = SWIG_Py_Void();
22356 return resultobj;
22357 fail:
22358 return NULL;
22359 }
22360
22361
22362 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22363 PyObject *resultobj = 0;
22364 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22365 bool result;
22366 void *argp1 = 0 ;
22367 int res1 = 0 ;
22368 PyObject *swig_obj[1] ;
22369
22370 if (!args) SWIG_fail;
22371 swig_obj[0] = args;
22372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22373 if (!SWIG_IsOK(res1)) {
22374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22375 }
22376 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22377 {
22378 PyThreadState* __tstate = wxPyBeginAllowThreads();
22379 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22380 wxPyEndAllowThreads(__tstate);
22381 if (PyErr_Occurred()) SWIG_fail;
22382 }
22383 {
22384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22385 }
22386 return resultobj;
22387 fail:
22388 return NULL;
22389 }
22390
22391
22392 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22393 PyObject *resultobj = 0;
22394 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22395 wxString *arg2 = 0 ;
22396 wxString result;
22397 void *argp1 = 0 ;
22398 int res1 = 0 ;
22399 bool temp2 = false ;
22400 PyObject * obj0 = 0 ;
22401 PyObject * obj1 = 0 ;
22402 char * kwnames[] = {
22403 (char *) "self",(char *) "str", NULL
22404 };
22405
22406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22408 if (!SWIG_IsOK(res1)) {
22409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22410 }
22411 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22412 {
22413 arg2 = wxString_in_helper(obj1);
22414 if (arg2 == NULL) SWIG_fail;
22415 temp2 = true;
22416 }
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22420 wxPyEndAllowThreads(__tstate);
22421 if (PyErr_Occurred()) SWIG_fail;
22422 }
22423 {
22424 #if wxUSE_UNICODE
22425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22426 #else
22427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22428 #endif
22429 }
22430 {
22431 if (temp2)
22432 delete arg2;
22433 }
22434 return resultobj;
22435 fail:
22436 {
22437 if (temp2)
22438 delete arg2;
22439 }
22440 return NULL;
22441 }
22442
22443
22444 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22445 PyObject *resultobj = 0;
22446 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22447 wxString result;
22448 void *argp1 = 0 ;
22449 int res1 = 0 ;
22450 PyObject *swig_obj[1] ;
22451
22452 if (!args) SWIG_fail;
22453 swig_obj[0] = args;
22454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22455 if (!SWIG_IsOK(res1)) {
22456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22457 }
22458 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22459 {
22460 PyThreadState* __tstate = wxPyBeginAllowThreads();
22461 result = ((wxConfigBase const *)arg1)->GetAppName();
22462 wxPyEndAllowThreads(__tstate);
22463 if (PyErr_Occurred()) SWIG_fail;
22464 }
22465 {
22466 #if wxUSE_UNICODE
22467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22468 #else
22469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22470 #endif
22471 }
22472 return resultobj;
22473 fail:
22474 return NULL;
22475 }
22476
22477
22478 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22479 PyObject *resultobj = 0;
22480 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22481 wxString result;
22482 void *argp1 = 0 ;
22483 int res1 = 0 ;
22484 PyObject *swig_obj[1] ;
22485
22486 if (!args) SWIG_fail;
22487 swig_obj[0] = args;
22488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22489 if (!SWIG_IsOK(res1)) {
22490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22491 }
22492 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22493 {
22494 PyThreadState* __tstate = wxPyBeginAllowThreads();
22495 result = ((wxConfigBase const *)arg1)->GetVendorName();
22496 wxPyEndAllowThreads(__tstate);
22497 if (PyErr_Occurred()) SWIG_fail;
22498 }
22499 {
22500 #if wxUSE_UNICODE
22501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22502 #else
22503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22504 #endif
22505 }
22506 return resultobj;
22507 fail:
22508 return NULL;
22509 }
22510
22511
22512 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22513 PyObject *resultobj = 0;
22514 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22515 wxString *arg2 = 0 ;
22516 void *argp1 = 0 ;
22517 int res1 = 0 ;
22518 bool temp2 = false ;
22519 PyObject * obj0 = 0 ;
22520 PyObject * obj1 = 0 ;
22521 char * kwnames[] = {
22522 (char *) "self",(char *) "appName", NULL
22523 };
22524
22525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22527 if (!SWIG_IsOK(res1)) {
22528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22529 }
22530 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22531 {
22532 arg2 = wxString_in_helper(obj1);
22533 if (arg2 == NULL) SWIG_fail;
22534 temp2 = true;
22535 }
22536 {
22537 PyThreadState* __tstate = wxPyBeginAllowThreads();
22538 (arg1)->SetAppName((wxString const &)*arg2);
22539 wxPyEndAllowThreads(__tstate);
22540 if (PyErr_Occurred()) SWIG_fail;
22541 }
22542 resultobj = SWIG_Py_Void();
22543 {
22544 if (temp2)
22545 delete arg2;
22546 }
22547 return resultobj;
22548 fail:
22549 {
22550 if (temp2)
22551 delete arg2;
22552 }
22553 return NULL;
22554 }
22555
22556
22557 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22558 PyObject *resultobj = 0;
22559 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22560 wxString *arg2 = 0 ;
22561 void *argp1 = 0 ;
22562 int res1 = 0 ;
22563 bool temp2 = false ;
22564 PyObject * obj0 = 0 ;
22565 PyObject * obj1 = 0 ;
22566 char * kwnames[] = {
22567 (char *) "self",(char *) "vendorName", NULL
22568 };
22569
22570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22572 if (!SWIG_IsOK(res1)) {
22573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22574 }
22575 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22576 {
22577 arg2 = wxString_in_helper(obj1);
22578 if (arg2 == NULL) SWIG_fail;
22579 temp2 = true;
22580 }
22581 {
22582 PyThreadState* __tstate = wxPyBeginAllowThreads();
22583 (arg1)->SetVendorName((wxString const &)*arg2);
22584 wxPyEndAllowThreads(__tstate);
22585 if (PyErr_Occurred()) SWIG_fail;
22586 }
22587 resultobj = SWIG_Py_Void();
22588 {
22589 if (temp2)
22590 delete arg2;
22591 }
22592 return resultobj;
22593 fail:
22594 {
22595 if (temp2)
22596 delete arg2;
22597 }
22598 return NULL;
22599 }
22600
22601
22602 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22603 PyObject *resultobj = 0;
22604 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22605 long arg2 ;
22606 void *argp1 = 0 ;
22607 int res1 = 0 ;
22608 long val2 ;
22609 int ecode2 = 0 ;
22610 PyObject * obj0 = 0 ;
22611 PyObject * obj1 = 0 ;
22612 char * kwnames[] = {
22613 (char *) "self",(char *) "style", NULL
22614 };
22615
22616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22618 if (!SWIG_IsOK(res1)) {
22619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22620 }
22621 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22622 ecode2 = SWIG_AsVal_long(obj1, &val2);
22623 if (!SWIG_IsOK(ecode2)) {
22624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22625 }
22626 arg2 = static_cast< long >(val2);
22627 {
22628 PyThreadState* __tstate = wxPyBeginAllowThreads();
22629 (arg1)->SetStyle(arg2);
22630 wxPyEndAllowThreads(__tstate);
22631 if (PyErr_Occurred()) SWIG_fail;
22632 }
22633 resultobj = SWIG_Py_Void();
22634 return resultobj;
22635 fail:
22636 return NULL;
22637 }
22638
22639
22640 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22641 PyObject *resultobj = 0;
22642 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22643 long result;
22644 void *argp1 = 0 ;
22645 int res1 = 0 ;
22646 PyObject *swig_obj[1] ;
22647
22648 if (!args) SWIG_fail;
22649 swig_obj[0] = args;
22650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22651 if (!SWIG_IsOK(res1)) {
22652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22653 }
22654 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22655 {
22656 PyThreadState* __tstate = wxPyBeginAllowThreads();
22657 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22658 wxPyEndAllowThreads(__tstate);
22659 if (PyErr_Occurred()) SWIG_fail;
22660 }
22661 resultobj = SWIG_From_long(static_cast< long >(result));
22662 return resultobj;
22663 fail:
22664 return NULL;
22665 }
22666
22667
22668 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22669 PyObject *obj;
22670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22671 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22672 return SWIG_Py_Void();
22673 }
22674
22675 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22676 PyObject *resultobj = 0;
22677 wxString const &arg1_defvalue = wxPyEmptyString ;
22678 wxString *arg1 = (wxString *) &arg1_defvalue ;
22679 wxString const &arg2_defvalue = wxPyEmptyString ;
22680 wxString *arg2 = (wxString *) &arg2_defvalue ;
22681 wxString const &arg3_defvalue = wxPyEmptyString ;
22682 wxString *arg3 = (wxString *) &arg3_defvalue ;
22683 wxString const &arg4_defvalue = wxPyEmptyString ;
22684 wxString *arg4 = (wxString *) &arg4_defvalue ;
22685 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22686 wxConfig *result = 0 ;
22687 bool temp1 = false ;
22688 bool temp2 = false ;
22689 bool temp3 = false ;
22690 bool temp4 = false ;
22691 long val5 ;
22692 int ecode5 = 0 ;
22693 PyObject * obj0 = 0 ;
22694 PyObject * obj1 = 0 ;
22695 PyObject * obj2 = 0 ;
22696 PyObject * obj3 = 0 ;
22697 PyObject * obj4 = 0 ;
22698 char * kwnames[] = {
22699 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22700 };
22701
22702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22703 if (obj0) {
22704 {
22705 arg1 = wxString_in_helper(obj0);
22706 if (arg1 == NULL) SWIG_fail;
22707 temp1 = true;
22708 }
22709 }
22710 if (obj1) {
22711 {
22712 arg2 = wxString_in_helper(obj1);
22713 if (arg2 == NULL) SWIG_fail;
22714 temp2 = true;
22715 }
22716 }
22717 if (obj2) {
22718 {
22719 arg3 = wxString_in_helper(obj2);
22720 if (arg3 == NULL) SWIG_fail;
22721 temp3 = true;
22722 }
22723 }
22724 if (obj3) {
22725 {
22726 arg4 = wxString_in_helper(obj3);
22727 if (arg4 == NULL) SWIG_fail;
22728 temp4 = true;
22729 }
22730 }
22731 if (obj4) {
22732 ecode5 = SWIG_AsVal_long(obj4, &val5);
22733 if (!SWIG_IsOK(ecode5)) {
22734 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22735 }
22736 arg5 = static_cast< long >(val5);
22737 }
22738 {
22739 PyThreadState* __tstate = wxPyBeginAllowThreads();
22740 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22741 wxPyEndAllowThreads(__tstate);
22742 if (PyErr_Occurred()) SWIG_fail;
22743 }
22744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22745 {
22746 if (temp1)
22747 delete arg1;
22748 }
22749 {
22750 if (temp2)
22751 delete arg2;
22752 }
22753 {
22754 if (temp3)
22755 delete arg3;
22756 }
22757 {
22758 if (temp4)
22759 delete arg4;
22760 }
22761 return resultobj;
22762 fail:
22763 {
22764 if (temp1)
22765 delete arg1;
22766 }
22767 {
22768 if (temp2)
22769 delete arg2;
22770 }
22771 {
22772 if (temp3)
22773 delete arg3;
22774 }
22775 {
22776 if (temp4)
22777 delete arg4;
22778 }
22779 return NULL;
22780 }
22781
22782
22783 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22784 PyObject *resultobj = 0;
22785 wxConfig *arg1 = (wxConfig *) 0 ;
22786 void *argp1 = 0 ;
22787 int res1 = 0 ;
22788 PyObject *swig_obj[1] ;
22789
22790 if (!args) SWIG_fail;
22791 swig_obj[0] = args;
22792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22793 if (!SWIG_IsOK(res1)) {
22794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22795 }
22796 arg1 = reinterpret_cast< wxConfig * >(argp1);
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 delete arg1;
22800
22801 wxPyEndAllowThreads(__tstate);
22802 if (PyErr_Occurred()) SWIG_fail;
22803 }
22804 resultobj = SWIG_Py_Void();
22805 return resultobj;
22806 fail:
22807 return NULL;
22808 }
22809
22810
22811 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22812 PyObject *obj;
22813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22814 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22815 return SWIG_Py_Void();
22816 }
22817
22818 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22819 return SWIG_Python_InitShadowInstance(args);
22820 }
22821
22822 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22823 PyObject *resultobj = 0;
22824 wxString const &arg1_defvalue = wxPyEmptyString ;
22825 wxString *arg1 = (wxString *) &arg1_defvalue ;
22826 wxString const &arg2_defvalue = wxPyEmptyString ;
22827 wxString *arg2 = (wxString *) &arg2_defvalue ;
22828 wxString const &arg3_defvalue = wxPyEmptyString ;
22829 wxString *arg3 = (wxString *) &arg3_defvalue ;
22830 wxString const &arg4_defvalue = wxPyEmptyString ;
22831 wxString *arg4 = (wxString *) &arg4_defvalue ;
22832 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22833 wxFileConfig *result = 0 ;
22834 bool temp1 = false ;
22835 bool temp2 = false ;
22836 bool temp3 = false ;
22837 bool temp4 = false ;
22838 long val5 ;
22839 int ecode5 = 0 ;
22840 PyObject * obj0 = 0 ;
22841 PyObject * obj1 = 0 ;
22842 PyObject * obj2 = 0 ;
22843 PyObject * obj3 = 0 ;
22844 PyObject * obj4 = 0 ;
22845 char * kwnames[] = {
22846 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22847 };
22848
22849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22850 if (obj0) {
22851 {
22852 arg1 = wxString_in_helper(obj0);
22853 if (arg1 == NULL) SWIG_fail;
22854 temp1 = true;
22855 }
22856 }
22857 if (obj1) {
22858 {
22859 arg2 = wxString_in_helper(obj1);
22860 if (arg2 == NULL) SWIG_fail;
22861 temp2 = true;
22862 }
22863 }
22864 if (obj2) {
22865 {
22866 arg3 = wxString_in_helper(obj2);
22867 if (arg3 == NULL) SWIG_fail;
22868 temp3 = true;
22869 }
22870 }
22871 if (obj3) {
22872 {
22873 arg4 = wxString_in_helper(obj3);
22874 if (arg4 == NULL) SWIG_fail;
22875 temp4 = true;
22876 }
22877 }
22878 if (obj4) {
22879 ecode5 = SWIG_AsVal_long(obj4, &val5);
22880 if (!SWIG_IsOK(ecode5)) {
22881 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22882 }
22883 arg5 = static_cast< long >(val5);
22884 }
22885 {
22886 PyThreadState* __tstate = wxPyBeginAllowThreads();
22887 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22888 wxPyEndAllowThreads(__tstate);
22889 if (PyErr_Occurred()) SWIG_fail;
22890 }
22891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22892 {
22893 if (temp1)
22894 delete arg1;
22895 }
22896 {
22897 if (temp2)
22898 delete arg2;
22899 }
22900 {
22901 if (temp3)
22902 delete arg3;
22903 }
22904 {
22905 if (temp4)
22906 delete arg4;
22907 }
22908 return resultobj;
22909 fail:
22910 {
22911 if (temp1)
22912 delete arg1;
22913 }
22914 {
22915 if (temp2)
22916 delete arg2;
22917 }
22918 {
22919 if (temp3)
22920 delete arg3;
22921 }
22922 {
22923 if (temp4)
22924 delete arg4;
22925 }
22926 return NULL;
22927 }
22928
22929
22930 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22931 PyObject *resultobj = 0;
22932 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22933 void *argp1 = 0 ;
22934 int res1 = 0 ;
22935 PyObject *swig_obj[1] ;
22936
22937 if (!args) SWIG_fail;
22938 swig_obj[0] = args;
22939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22940 if (!SWIG_IsOK(res1)) {
22941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22942 }
22943 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22944 {
22945 PyThreadState* __tstate = wxPyBeginAllowThreads();
22946 delete arg1;
22947
22948 wxPyEndAllowThreads(__tstate);
22949 if (PyErr_Occurred()) SWIG_fail;
22950 }
22951 resultobj = SWIG_Py_Void();
22952 return resultobj;
22953 fail:
22954 return NULL;
22955 }
22956
22957
22958 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22959 PyObject *obj;
22960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22961 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22962 return SWIG_Py_Void();
22963 }
22964
22965 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22966 return SWIG_Python_InitShadowInstance(args);
22967 }
22968
22969 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22970 PyObject *resultobj = 0;
22971 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22972 wxString *arg2 = 0 ;
22973 wxConfigPathChanger *result = 0 ;
22974 void *argp1 = 0 ;
22975 int res1 = 0 ;
22976 bool temp2 = false ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char * kwnames[] = {
22980 (char *) "config",(char *) "entry", NULL
22981 };
22982
22983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22987 }
22988 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22989 {
22990 arg2 = wxString_in_helper(obj1);
22991 if (arg2 == NULL) SWIG_fail;
22992 temp2 = true;
22993 }
22994 {
22995 PyThreadState* __tstate = wxPyBeginAllowThreads();
22996 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22997 wxPyEndAllowThreads(__tstate);
22998 if (PyErr_Occurred()) SWIG_fail;
22999 }
23000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23001 {
23002 if (temp2)
23003 delete arg2;
23004 }
23005 return resultobj;
23006 fail:
23007 {
23008 if (temp2)
23009 delete arg2;
23010 }
23011 return NULL;
23012 }
23013
23014
23015 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23016 PyObject *resultobj = 0;
23017 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23018 void *argp1 = 0 ;
23019 int res1 = 0 ;
23020 PyObject *swig_obj[1] ;
23021
23022 if (!args) SWIG_fail;
23023 swig_obj[0] = args;
23024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23025 if (!SWIG_IsOK(res1)) {
23026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23027 }
23028 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23029 {
23030 PyThreadState* __tstate = wxPyBeginAllowThreads();
23031 delete arg1;
23032
23033 wxPyEndAllowThreads(__tstate);
23034 if (PyErr_Occurred()) SWIG_fail;
23035 }
23036 resultobj = SWIG_Py_Void();
23037 return resultobj;
23038 fail:
23039 return NULL;
23040 }
23041
23042
23043 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23044 PyObject *resultobj = 0;
23045 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23046 wxString *result = 0 ;
23047 void *argp1 = 0 ;
23048 int res1 = 0 ;
23049 PyObject *swig_obj[1] ;
23050
23051 if (!args) SWIG_fail;
23052 swig_obj[0] = args;
23053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23054 if (!SWIG_IsOK(res1)) {
23055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23056 }
23057 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23058 {
23059 PyThreadState* __tstate = wxPyBeginAllowThreads();
23060 {
23061 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23062 result = (wxString *) &_result_ref;
23063 }
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 {
23068 #if wxUSE_UNICODE
23069 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23070 #else
23071 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23072 #endif
23073 }
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 PyObject *obj;
23082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23083 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23084 return SWIG_Py_Void();
23085 }
23086
23087 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23088 return SWIG_Python_InitShadowInstance(args);
23089 }
23090
23091 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23092 PyObject *resultobj = 0;
23093 wxString *arg1 = 0 ;
23094 wxString result;
23095 bool temp1 = false ;
23096 PyObject * obj0 = 0 ;
23097 char * kwnames[] = {
23098 (char *) "sz", NULL
23099 };
23100
23101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23102 {
23103 arg1 = wxString_in_helper(obj0);
23104 if (arg1 == NULL) SWIG_fail;
23105 temp1 = true;
23106 }
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 result = wxExpandEnvVars((wxString const &)*arg1);
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 {
23114 #if wxUSE_UNICODE
23115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23116 #else
23117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23118 #endif
23119 }
23120 {
23121 if (temp1)
23122 delete arg1;
23123 }
23124 return resultobj;
23125 fail:
23126 {
23127 if (temp1)
23128 delete arg1;
23129 }
23130 return NULL;
23131 }
23132
23133
23134 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23135 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23136 return 1;
23137 }
23138
23139
23140 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23141 PyObject *pyobj = 0;
23142
23143 {
23144 #if wxUSE_UNICODE
23145 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23146 #else
23147 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23148 #endif
23149 }
23150 return pyobj;
23151 }
23152
23153
23154 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23155 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23156 return 1;
23157 }
23158
23159
23160 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23161 PyObject *pyobj = 0;
23162
23163 {
23164 #if wxUSE_UNICODE
23165 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23166 #else
23167 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23168 #endif
23169 }
23170 return pyobj;
23171 }
23172
23173
23174 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23175 PyObject *resultobj = 0;
23176 wxDateTime::Country arg1 ;
23177 int val1 ;
23178 int ecode1 = 0 ;
23179 PyObject * obj0 = 0 ;
23180 char * kwnames[] = {
23181 (char *) "country", NULL
23182 };
23183
23184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23185 ecode1 = SWIG_AsVal_int(obj0, &val1);
23186 if (!SWIG_IsOK(ecode1)) {
23187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23188 }
23189 arg1 = static_cast< wxDateTime::Country >(val1);
23190 {
23191 PyThreadState* __tstate = wxPyBeginAllowThreads();
23192 wxDateTime::SetCountry(arg1);
23193 wxPyEndAllowThreads(__tstate);
23194 if (PyErr_Occurred()) SWIG_fail;
23195 }
23196 resultobj = SWIG_Py_Void();
23197 return resultobj;
23198 fail:
23199 return NULL;
23200 }
23201
23202
23203 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23204 PyObject *resultobj = 0;
23205 wxDateTime::Country result;
23206
23207 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 result = (wxDateTime::Country)wxDateTime::GetCountry();
23211 wxPyEndAllowThreads(__tstate);
23212 if (PyErr_Occurred()) SWIG_fail;
23213 }
23214 resultobj = SWIG_From_int(static_cast< int >(result));
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23222 PyObject *resultobj = 0;
23223 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23224 bool result;
23225 int val1 ;
23226 int ecode1 = 0 ;
23227 PyObject * obj0 = 0 ;
23228 char * kwnames[] = {
23229 (char *) "country", NULL
23230 };
23231
23232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23233 if (obj0) {
23234 ecode1 = SWIG_AsVal_int(obj0, &val1);
23235 if (!SWIG_IsOK(ecode1)) {
23236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23237 }
23238 arg1 = static_cast< wxDateTime::Country >(val1);
23239 }
23240 {
23241 PyThreadState* __tstate = wxPyBeginAllowThreads();
23242 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23243 wxPyEndAllowThreads(__tstate);
23244 if (PyErr_Occurred()) SWIG_fail;
23245 }
23246 {
23247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23248 }
23249 return resultobj;
23250 fail:
23251 return NULL;
23252 }
23253
23254
23255 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23256 PyObject *resultobj = 0;
23257 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23258 int result;
23259 int val1 ;
23260 int ecode1 = 0 ;
23261 PyObject * obj0 = 0 ;
23262 char * kwnames[] = {
23263 (char *) "cal", NULL
23264 };
23265
23266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23267 if (obj0) {
23268 ecode1 = SWIG_AsVal_int(obj0, &val1);
23269 if (!SWIG_IsOK(ecode1)) {
23270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23271 }
23272 arg1 = static_cast< wxDateTime::Calendar >(val1);
23273 }
23274 {
23275 PyThreadState* __tstate = wxPyBeginAllowThreads();
23276 result = (int)wxDateTime::GetCurrentYear(arg1);
23277 wxPyEndAllowThreads(__tstate);
23278 if (PyErr_Occurred()) SWIG_fail;
23279 }
23280 resultobj = SWIG_From_int(static_cast< int >(result));
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23288 PyObject *resultobj = 0;
23289 int arg1 ;
23290 int result;
23291 int val1 ;
23292 int ecode1 = 0 ;
23293 PyObject * obj0 = 0 ;
23294 char * kwnames[] = {
23295 (char *) "year", NULL
23296 };
23297
23298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23299 ecode1 = SWIG_AsVal_int(obj0, &val1);
23300 if (!SWIG_IsOK(ecode1)) {
23301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23302 }
23303 arg1 = static_cast< int >(val1);
23304 {
23305 PyThreadState* __tstate = wxPyBeginAllowThreads();
23306 result = (int)wxDateTime::ConvertYearToBC(arg1);
23307 wxPyEndAllowThreads(__tstate);
23308 if (PyErr_Occurred()) SWIG_fail;
23309 }
23310 resultobj = SWIG_From_int(static_cast< int >(result));
23311 return resultobj;
23312 fail:
23313 return NULL;
23314 }
23315
23316
23317 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23318 PyObject *resultobj = 0;
23319 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23320 wxDateTime::Month result;
23321 int val1 ;
23322 int ecode1 = 0 ;
23323 PyObject * obj0 = 0 ;
23324 char * kwnames[] = {
23325 (char *) "cal", NULL
23326 };
23327
23328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23329 if (obj0) {
23330 ecode1 = SWIG_AsVal_int(obj0, &val1);
23331 if (!SWIG_IsOK(ecode1)) {
23332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23333 }
23334 arg1 = static_cast< wxDateTime::Calendar >(val1);
23335 }
23336 {
23337 PyThreadState* __tstate = wxPyBeginAllowThreads();
23338 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23339 wxPyEndAllowThreads(__tstate);
23340 if (PyErr_Occurred()) SWIG_fail;
23341 }
23342 resultobj = SWIG_From_int(static_cast< int >(result));
23343 return resultobj;
23344 fail:
23345 return NULL;
23346 }
23347
23348
23349 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23350 PyObject *resultobj = 0;
23351 int arg1 = (int) wxDateTime::Inv_Year ;
23352 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23353 bool result;
23354 int val1 ;
23355 int ecode1 = 0 ;
23356 int val2 ;
23357 int ecode2 = 0 ;
23358 PyObject * obj0 = 0 ;
23359 PyObject * obj1 = 0 ;
23360 char * kwnames[] = {
23361 (char *) "year",(char *) "cal", NULL
23362 };
23363
23364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23365 if (obj0) {
23366 ecode1 = SWIG_AsVal_int(obj0, &val1);
23367 if (!SWIG_IsOK(ecode1)) {
23368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23369 }
23370 arg1 = static_cast< int >(val1);
23371 }
23372 if (obj1) {
23373 ecode2 = SWIG_AsVal_int(obj1, &val2);
23374 if (!SWIG_IsOK(ecode2)) {
23375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23376 }
23377 arg2 = static_cast< wxDateTime::Calendar >(val2);
23378 }
23379 {
23380 PyThreadState* __tstate = wxPyBeginAllowThreads();
23381 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23382 wxPyEndAllowThreads(__tstate);
23383 if (PyErr_Occurred()) SWIG_fail;
23384 }
23385 {
23386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23387 }
23388 return resultobj;
23389 fail:
23390 return NULL;
23391 }
23392
23393
23394 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23395 PyObject *resultobj = 0;
23396 int arg1 = (int) wxDateTime::Inv_Year ;
23397 int result;
23398 int val1 ;
23399 int ecode1 = 0 ;
23400 PyObject * obj0 = 0 ;
23401 char * kwnames[] = {
23402 (char *) "year", NULL
23403 };
23404
23405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23406 if (obj0) {
23407 ecode1 = SWIG_AsVal_int(obj0, &val1);
23408 if (!SWIG_IsOK(ecode1)) {
23409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23410 }
23411 arg1 = static_cast< int >(val1);
23412 }
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 result = (int)wxDateTime::GetCentury(arg1);
23416 wxPyEndAllowThreads(__tstate);
23417 if (PyErr_Occurred()) SWIG_fail;
23418 }
23419 resultobj = SWIG_From_int(static_cast< int >(result));
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23427 PyObject *resultobj = 0;
23428 int arg1 ;
23429 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23430 int result;
23431 int val1 ;
23432 int ecode1 = 0 ;
23433 int val2 ;
23434 int ecode2 = 0 ;
23435 PyObject * obj0 = 0 ;
23436 PyObject * obj1 = 0 ;
23437 char * kwnames[] = {
23438 (char *) "year",(char *) "cal", NULL
23439 };
23440
23441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23442 ecode1 = SWIG_AsVal_int(obj0, &val1);
23443 if (!SWIG_IsOK(ecode1)) {
23444 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23445 }
23446 arg1 = static_cast< int >(val1);
23447 if (obj1) {
23448 ecode2 = SWIG_AsVal_int(obj1, &val2);
23449 if (!SWIG_IsOK(ecode2)) {
23450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23451 }
23452 arg2 = static_cast< wxDateTime::Calendar >(val2);
23453 }
23454 {
23455 PyThreadState* __tstate = wxPyBeginAllowThreads();
23456 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23457 wxPyEndAllowThreads(__tstate);
23458 if (PyErr_Occurred()) SWIG_fail;
23459 }
23460 resultobj = SWIG_From_int(static_cast< int >(result));
23461 return resultobj;
23462 fail:
23463 return NULL;
23464 }
23465
23466
23467 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23468 PyObject *resultobj = 0;
23469 wxDateTime::Month arg1 ;
23470 int arg2 = (int) wxDateTime::Inv_Year ;
23471 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23472 int result;
23473 int val1 ;
23474 int ecode1 = 0 ;
23475 int val2 ;
23476 int ecode2 = 0 ;
23477 int val3 ;
23478 int ecode3 = 0 ;
23479 PyObject * obj0 = 0 ;
23480 PyObject * obj1 = 0 ;
23481 PyObject * obj2 = 0 ;
23482 char * kwnames[] = {
23483 (char *) "month",(char *) "year",(char *) "cal", NULL
23484 };
23485
23486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23487 ecode1 = SWIG_AsVal_int(obj0, &val1);
23488 if (!SWIG_IsOK(ecode1)) {
23489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23490 }
23491 arg1 = static_cast< wxDateTime::Month >(val1);
23492 if (obj1) {
23493 ecode2 = SWIG_AsVal_int(obj1, &val2);
23494 if (!SWIG_IsOK(ecode2)) {
23495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23496 }
23497 arg2 = static_cast< int >(val2);
23498 }
23499 if (obj2) {
23500 ecode3 = SWIG_AsVal_int(obj2, &val3);
23501 if (!SWIG_IsOK(ecode3)) {
23502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23503 }
23504 arg3 = static_cast< wxDateTime::Calendar >(val3);
23505 }
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23509 wxPyEndAllowThreads(__tstate);
23510 if (PyErr_Occurred()) SWIG_fail;
23511 }
23512 resultobj = SWIG_From_int(static_cast< int >(result));
23513 return resultobj;
23514 fail:
23515 return NULL;
23516 }
23517
23518
23519 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23520 PyObject *resultobj = 0;
23521 wxDateTime::Month arg1 ;
23522 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23523 wxString result;
23524 int val1 ;
23525 int ecode1 = 0 ;
23526 int val2 ;
23527 int ecode2 = 0 ;
23528 PyObject * obj0 = 0 ;
23529 PyObject * obj1 = 0 ;
23530 char * kwnames[] = {
23531 (char *) "month",(char *) "flags", NULL
23532 };
23533
23534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23535 ecode1 = SWIG_AsVal_int(obj0, &val1);
23536 if (!SWIG_IsOK(ecode1)) {
23537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23538 }
23539 arg1 = static_cast< wxDateTime::Month >(val1);
23540 if (obj1) {
23541 ecode2 = SWIG_AsVal_int(obj1, &val2);
23542 if (!SWIG_IsOK(ecode2)) {
23543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23544 }
23545 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23546 }
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = wxDateTime::GetMonthName(arg1,arg2);
23550 wxPyEndAllowThreads(__tstate);
23551 if (PyErr_Occurred()) SWIG_fail;
23552 }
23553 {
23554 #if wxUSE_UNICODE
23555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23556 #else
23557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23558 #endif
23559 }
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj = 0;
23568 wxDateTime::WeekDay arg1 ;
23569 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23570 wxString result;
23571 int val1 ;
23572 int ecode1 = 0 ;
23573 int val2 ;
23574 int ecode2 = 0 ;
23575 PyObject * obj0 = 0 ;
23576 PyObject * obj1 = 0 ;
23577 char * kwnames[] = {
23578 (char *) "weekday",(char *) "flags", NULL
23579 };
23580
23581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23582 ecode1 = SWIG_AsVal_int(obj0, &val1);
23583 if (!SWIG_IsOK(ecode1)) {
23584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23585 }
23586 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23587 if (obj1) {
23588 ecode2 = SWIG_AsVal_int(obj1, &val2);
23589 if (!SWIG_IsOK(ecode2)) {
23590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23591 }
23592 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23593 }
23594 {
23595 PyThreadState* __tstate = wxPyBeginAllowThreads();
23596 result = wxDateTime::GetWeekDayName(arg1,arg2);
23597 wxPyEndAllowThreads(__tstate);
23598 if (PyErr_Occurred()) SWIG_fail;
23599 }
23600 {
23601 #if wxUSE_UNICODE
23602 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23603 #else
23604 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23605 #endif
23606 }
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23614 PyObject *resultobj = 0;
23615 PyObject *result = 0 ;
23616
23617 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23618 {
23619 PyThreadState* __tstate = wxPyBeginAllowThreads();
23620 result = (PyObject *)wxDateTime_GetAmPmStrings();
23621 wxPyEndAllowThreads(__tstate);
23622 if (PyErr_Occurred()) SWIG_fail;
23623 }
23624 resultobj = result;
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj = 0;
23633 int arg1 = (int) wxDateTime::Inv_Year ;
23634 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23635 bool result;
23636 int val1 ;
23637 int ecode1 = 0 ;
23638 int val2 ;
23639 int ecode2 = 0 ;
23640 PyObject * obj0 = 0 ;
23641 PyObject * obj1 = 0 ;
23642 char * kwnames[] = {
23643 (char *) "year",(char *) "country", NULL
23644 };
23645
23646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23647 if (obj0) {
23648 ecode1 = SWIG_AsVal_int(obj0, &val1);
23649 if (!SWIG_IsOK(ecode1)) {
23650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23651 }
23652 arg1 = static_cast< int >(val1);
23653 }
23654 if (obj1) {
23655 ecode2 = SWIG_AsVal_int(obj1, &val2);
23656 if (!SWIG_IsOK(ecode2)) {
23657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23658 }
23659 arg2 = static_cast< wxDateTime::Country >(val2);
23660 }
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 {
23668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23669 }
23670 return resultobj;
23671 fail:
23672 return NULL;
23673 }
23674
23675
23676 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23677 PyObject *resultobj = 0;
23678 int arg1 = (int) wxDateTime::Inv_Year ;
23679 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23680 wxDateTime result;
23681 int val1 ;
23682 int ecode1 = 0 ;
23683 int val2 ;
23684 int ecode2 = 0 ;
23685 PyObject * obj0 = 0 ;
23686 PyObject * obj1 = 0 ;
23687 char * kwnames[] = {
23688 (char *) "year",(char *) "country", NULL
23689 };
23690
23691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23692 if (obj0) {
23693 ecode1 = SWIG_AsVal_int(obj0, &val1);
23694 if (!SWIG_IsOK(ecode1)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23696 }
23697 arg1 = static_cast< int >(val1);
23698 }
23699 if (obj1) {
23700 ecode2 = SWIG_AsVal_int(obj1, &val2);
23701 if (!SWIG_IsOK(ecode2)) {
23702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23703 }
23704 arg2 = static_cast< wxDateTime::Country >(val2);
23705 }
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 result = wxDateTime::GetBeginDST(arg1,arg2);
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj = 0;
23721 int arg1 = (int) wxDateTime::Inv_Year ;
23722 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23723 wxDateTime result;
23724 int val1 ;
23725 int ecode1 = 0 ;
23726 int val2 ;
23727 int ecode2 = 0 ;
23728 PyObject * obj0 = 0 ;
23729 PyObject * obj1 = 0 ;
23730 char * kwnames[] = {
23731 (char *) "year",(char *) "country", NULL
23732 };
23733
23734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23735 if (obj0) {
23736 ecode1 = SWIG_AsVal_int(obj0, &val1);
23737 if (!SWIG_IsOK(ecode1)) {
23738 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23739 }
23740 arg1 = static_cast< int >(val1);
23741 }
23742 if (obj1) {
23743 ecode2 = SWIG_AsVal_int(obj1, &val2);
23744 if (!SWIG_IsOK(ecode2)) {
23745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23746 }
23747 arg2 = static_cast< wxDateTime::Country >(val2);
23748 }
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = wxDateTime::GetEndDST(arg1,arg2);
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23763 PyObject *resultobj = 0;
23764 wxDateTime result;
23765
23766 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23767 {
23768 PyThreadState* __tstate = wxPyBeginAllowThreads();
23769 result = wxDateTime::Now();
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23781 PyObject *resultobj = 0;
23782 wxDateTime result;
23783
23784 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23785 {
23786 PyThreadState* __tstate = wxPyBeginAllowThreads();
23787 result = wxDateTime::UNow();
23788 wxPyEndAllowThreads(__tstate);
23789 if (PyErr_Occurred()) SWIG_fail;
23790 }
23791 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23792 return resultobj;
23793 fail:
23794 return NULL;
23795 }
23796
23797
23798 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23799 PyObject *resultobj = 0;
23800 wxDateTime result;
23801
23802 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23803 {
23804 PyThreadState* __tstate = wxPyBeginAllowThreads();
23805 result = wxDateTime::Today();
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23810 return resultobj;
23811 fail:
23812 return NULL;
23813 }
23814
23815
23816 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23817 PyObject *resultobj = 0;
23818 wxDateTime *result = 0 ;
23819
23820 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23821 {
23822 PyThreadState* __tstate = wxPyBeginAllowThreads();
23823 result = (wxDateTime *)new wxDateTime();
23824 wxPyEndAllowThreads(__tstate);
23825 if (PyErr_Occurred()) SWIG_fail;
23826 }
23827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23828 return resultobj;
23829 fail:
23830 return NULL;
23831 }
23832
23833
23834 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23835 PyObject *resultobj = 0;
23836 time_t arg1 ;
23837 wxDateTime *result = 0 ;
23838 unsigned int val1 ;
23839 int ecode1 = 0 ;
23840 PyObject * obj0 = 0 ;
23841 char * kwnames[] = {
23842 (char *) "timet", NULL
23843 };
23844
23845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23846 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23847 if (!SWIG_IsOK(ecode1)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23849 }
23850 arg1 = static_cast< time_t >(val1);
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (wxDateTime *)new wxDateTime(arg1);
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj = 0;
23866 double arg1 ;
23867 wxDateTime *result = 0 ;
23868 double val1 ;
23869 int ecode1 = 0 ;
23870 PyObject * obj0 = 0 ;
23871 char * kwnames[] = {
23872 (char *) "jdn", NULL
23873 };
23874
23875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23876 ecode1 = SWIG_AsVal_double(obj0, &val1);
23877 if (!SWIG_IsOK(ecode1)) {
23878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23879 }
23880 arg1 = static_cast< double >(val1);
23881 {
23882 PyThreadState* __tstate = wxPyBeginAllowThreads();
23883 result = (wxDateTime *)new wxDateTime(arg1);
23884 wxPyEndAllowThreads(__tstate);
23885 if (PyErr_Occurred()) SWIG_fail;
23886 }
23887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj = 0;
23896 int arg1 ;
23897 int arg2 = (int) 0 ;
23898 int arg3 = (int) 0 ;
23899 int arg4 = (int) 0 ;
23900 wxDateTime *result = 0 ;
23901 int val1 ;
23902 int ecode1 = 0 ;
23903 int val2 ;
23904 int ecode2 = 0 ;
23905 int val3 ;
23906 int ecode3 = 0 ;
23907 int val4 ;
23908 int ecode4 = 0 ;
23909 PyObject * obj0 = 0 ;
23910 PyObject * obj1 = 0 ;
23911 PyObject * obj2 = 0 ;
23912 PyObject * obj3 = 0 ;
23913 char * kwnames[] = {
23914 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23915 };
23916
23917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23918 ecode1 = SWIG_AsVal_int(obj0, &val1);
23919 if (!SWIG_IsOK(ecode1)) {
23920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23921 }
23922 arg1 = static_cast< int >(val1);
23923 if (obj1) {
23924 ecode2 = SWIG_AsVal_int(obj1, &val2);
23925 if (!SWIG_IsOK(ecode2)) {
23926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23927 }
23928 arg2 = static_cast< int >(val2);
23929 }
23930 if (obj2) {
23931 ecode3 = SWIG_AsVal_int(obj2, &val3);
23932 if (!SWIG_IsOK(ecode3)) {
23933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23934 }
23935 arg3 = static_cast< int >(val3);
23936 }
23937 if (obj3) {
23938 ecode4 = SWIG_AsVal_int(obj3, &val4);
23939 if (!SWIG_IsOK(ecode4)) {
23940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23941 }
23942 arg4 = static_cast< int >(val4);
23943 }
23944 {
23945 PyThreadState* __tstate = wxPyBeginAllowThreads();
23946 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23947 wxPyEndAllowThreads(__tstate);
23948 if (PyErr_Occurred()) SWIG_fail;
23949 }
23950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23951 return resultobj;
23952 fail:
23953 return NULL;
23954 }
23955
23956
23957 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23958 PyObject *resultobj = 0;
23959 int arg1 ;
23960 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23961 int arg3 = (int) wxDateTime::Inv_Year ;
23962 int arg4 = (int) 0 ;
23963 int arg5 = (int) 0 ;
23964 int arg6 = (int) 0 ;
23965 int arg7 = (int) 0 ;
23966 wxDateTime *result = 0 ;
23967 int val1 ;
23968 int ecode1 = 0 ;
23969 int val2 ;
23970 int ecode2 = 0 ;
23971 int val3 ;
23972 int ecode3 = 0 ;
23973 int val4 ;
23974 int ecode4 = 0 ;
23975 int val5 ;
23976 int ecode5 = 0 ;
23977 int val6 ;
23978 int ecode6 = 0 ;
23979 int val7 ;
23980 int ecode7 = 0 ;
23981 PyObject * obj0 = 0 ;
23982 PyObject * obj1 = 0 ;
23983 PyObject * obj2 = 0 ;
23984 PyObject * obj3 = 0 ;
23985 PyObject * obj4 = 0 ;
23986 PyObject * obj5 = 0 ;
23987 PyObject * obj6 = 0 ;
23988 char * kwnames[] = {
23989 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23990 };
23991
23992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23993 ecode1 = SWIG_AsVal_int(obj0, &val1);
23994 if (!SWIG_IsOK(ecode1)) {
23995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23996 }
23997 arg1 = static_cast< int >(val1);
23998 if (obj1) {
23999 ecode2 = SWIG_AsVal_int(obj1, &val2);
24000 if (!SWIG_IsOK(ecode2)) {
24001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24002 }
24003 arg2 = static_cast< wxDateTime::Month >(val2);
24004 }
24005 if (obj2) {
24006 ecode3 = SWIG_AsVal_int(obj2, &val3);
24007 if (!SWIG_IsOK(ecode3)) {
24008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24009 }
24010 arg3 = static_cast< int >(val3);
24011 }
24012 if (obj3) {
24013 ecode4 = SWIG_AsVal_int(obj3, &val4);
24014 if (!SWIG_IsOK(ecode4)) {
24015 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24016 }
24017 arg4 = static_cast< int >(val4);
24018 }
24019 if (obj4) {
24020 ecode5 = SWIG_AsVal_int(obj4, &val5);
24021 if (!SWIG_IsOK(ecode5)) {
24022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24023 }
24024 arg5 = static_cast< int >(val5);
24025 }
24026 if (obj5) {
24027 ecode6 = SWIG_AsVal_int(obj5, &val6);
24028 if (!SWIG_IsOK(ecode6)) {
24029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24030 }
24031 arg6 = static_cast< int >(val6);
24032 }
24033 if (obj6) {
24034 ecode7 = SWIG_AsVal_int(obj6, &val7);
24035 if (!SWIG_IsOK(ecode7)) {
24036 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24037 }
24038 arg7 = static_cast< int >(val7);
24039 }
24040 {
24041 PyThreadState* __tstate = wxPyBeginAllowThreads();
24042 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24043 wxPyEndAllowThreads(__tstate);
24044 if (PyErr_Occurred()) SWIG_fail;
24045 }
24046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24047 return resultobj;
24048 fail:
24049 return NULL;
24050 }
24051
24052
24053 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24054 PyObject *resultobj = 0;
24055 wxDateTime *arg1 = 0 ;
24056 wxDateTime *result = 0 ;
24057 void *argp1 = 0 ;
24058 int res1 = 0 ;
24059 PyObject * obj0 = 0 ;
24060 char * kwnames[] = {
24061 (char *) "date", NULL
24062 };
24063
24064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24065 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24066 if (!SWIG_IsOK(res1)) {
24067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24068 }
24069 if (!argp1) {
24070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24071 }
24072 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24073 {
24074 PyThreadState* __tstate = wxPyBeginAllowThreads();
24075 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24076 wxPyEndAllowThreads(__tstate);
24077 if (PyErr_Occurred()) SWIG_fail;
24078 }
24079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24080 return resultobj;
24081 fail:
24082 return NULL;
24083 }
24084
24085
24086 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24087 PyObject *resultobj = 0;
24088 wxDateTime *arg1 = (wxDateTime *) 0 ;
24089 void *argp1 = 0 ;
24090 int res1 = 0 ;
24091 PyObject *swig_obj[1] ;
24092
24093 if (!args) SWIG_fail;
24094 swig_obj[0] = args;
24095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24096 if (!SWIG_IsOK(res1)) {
24097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24098 }
24099 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 delete arg1;
24103
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 resultobj = SWIG_Py_Void();
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24115 PyObject *resultobj = 0;
24116 wxDateTime *arg1 = (wxDateTime *) 0 ;
24117 wxDateTime *result = 0 ;
24118 void *argp1 = 0 ;
24119 int res1 = 0 ;
24120 PyObject *swig_obj[1] ;
24121
24122 if (!args) SWIG_fail;
24123 swig_obj[0] = args;
24124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24125 if (!SWIG_IsOK(res1)) {
24126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24127 }
24128 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24129 {
24130 PyThreadState* __tstate = wxPyBeginAllowThreads();
24131 {
24132 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24133 result = (wxDateTime *) &_result_ref;
24134 }
24135 wxPyEndAllowThreads(__tstate);
24136 if (PyErr_Occurred()) SWIG_fail;
24137 }
24138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24146 PyObject *resultobj = 0;
24147 wxDateTime *arg1 = (wxDateTime *) 0 ;
24148 time_t arg2 ;
24149 wxDateTime *result = 0 ;
24150 void *argp1 = 0 ;
24151 int res1 = 0 ;
24152 unsigned int val2 ;
24153 int ecode2 = 0 ;
24154 PyObject * obj0 = 0 ;
24155 PyObject * obj1 = 0 ;
24156 char * kwnames[] = {
24157 (char *) "self",(char *) "timet", NULL
24158 };
24159
24160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24162 if (!SWIG_IsOK(res1)) {
24163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24164 }
24165 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24166 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24167 if (!SWIG_IsOK(ecode2)) {
24168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24169 }
24170 arg2 = static_cast< time_t >(val2);
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 {
24174 wxDateTime &_result_ref = (arg1)->Set(arg2);
24175 result = (wxDateTime *) &_result_ref;
24176 }
24177 wxPyEndAllowThreads(__tstate);
24178 if (PyErr_Occurred()) SWIG_fail;
24179 }
24180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24181 return resultobj;
24182 fail:
24183 return NULL;
24184 }
24185
24186
24187 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24188 PyObject *resultobj = 0;
24189 wxDateTime *arg1 = (wxDateTime *) 0 ;
24190 double arg2 ;
24191 wxDateTime *result = 0 ;
24192 void *argp1 = 0 ;
24193 int res1 = 0 ;
24194 double val2 ;
24195 int ecode2 = 0 ;
24196 PyObject * obj0 = 0 ;
24197 PyObject * obj1 = 0 ;
24198 char * kwnames[] = {
24199 (char *) "self",(char *) "jdn", NULL
24200 };
24201
24202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24204 if (!SWIG_IsOK(res1)) {
24205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24206 }
24207 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24208 ecode2 = SWIG_AsVal_double(obj1, &val2);
24209 if (!SWIG_IsOK(ecode2)) {
24210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24211 }
24212 arg2 = static_cast< double >(val2);
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 {
24216 wxDateTime &_result_ref = (arg1)->Set(arg2);
24217 result = (wxDateTime *) &_result_ref;
24218 }
24219 wxPyEndAllowThreads(__tstate);
24220 if (PyErr_Occurred()) SWIG_fail;
24221 }
24222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24223 return resultobj;
24224 fail:
24225 return NULL;
24226 }
24227
24228
24229 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24230 PyObject *resultobj = 0;
24231 wxDateTime *arg1 = (wxDateTime *) 0 ;
24232 int arg2 ;
24233 int arg3 = (int) 0 ;
24234 int arg4 = (int) 0 ;
24235 int arg5 = (int) 0 ;
24236 wxDateTime *result = 0 ;
24237 void *argp1 = 0 ;
24238 int res1 = 0 ;
24239 int val2 ;
24240 int ecode2 = 0 ;
24241 int val3 ;
24242 int ecode3 = 0 ;
24243 int val4 ;
24244 int ecode4 = 0 ;
24245 int val5 ;
24246 int ecode5 = 0 ;
24247 PyObject * obj0 = 0 ;
24248 PyObject * obj1 = 0 ;
24249 PyObject * obj2 = 0 ;
24250 PyObject * obj3 = 0 ;
24251 PyObject * obj4 = 0 ;
24252 char * kwnames[] = {
24253 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24254 };
24255
24256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24258 if (!SWIG_IsOK(res1)) {
24259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24260 }
24261 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24262 ecode2 = SWIG_AsVal_int(obj1, &val2);
24263 if (!SWIG_IsOK(ecode2)) {
24264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24265 }
24266 arg2 = static_cast< int >(val2);
24267 if (obj2) {
24268 ecode3 = SWIG_AsVal_int(obj2, &val3);
24269 if (!SWIG_IsOK(ecode3)) {
24270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24271 }
24272 arg3 = static_cast< int >(val3);
24273 }
24274 if (obj3) {
24275 ecode4 = SWIG_AsVal_int(obj3, &val4);
24276 if (!SWIG_IsOK(ecode4)) {
24277 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24278 }
24279 arg4 = static_cast< int >(val4);
24280 }
24281 if (obj4) {
24282 ecode5 = SWIG_AsVal_int(obj4, &val5);
24283 if (!SWIG_IsOK(ecode5)) {
24284 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24285 }
24286 arg5 = static_cast< int >(val5);
24287 }
24288 {
24289 PyThreadState* __tstate = wxPyBeginAllowThreads();
24290 {
24291 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24292 result = (wxDateTime *) &_result_ref;
24293 }
24294 wxPyEndAllowThreads(__tstate);
24295 if (PyErr_Occurred()) SWIG_fail;
24296 }
24297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24298 return resultobj;
24299 fail:
24300 return NULL;
24301 }
24302
24303
24304 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24305 PyObject *resultobj = 0;
24306 wxDateTime *arg1 = (wxDateTime *) 0 ;
24307 int arg2 ;
24308 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24309 int arg4 = (int) wxDateTime::Inv_Year ;
24310 int arg5 = (int) 0 ;
24311 int arg6 = (int) 0 ;
24312 int arg7 = (int) 0 ;
24313 int arg8 = (int) 0 ;
24314 wxDateTime *result = 0 ;
24315 void *argp1 = 0 ;
24316 int res1 = 0 ;
24317 int val2 ;
24318 int ecode2 = 0 ;
24319 int val3 ;
24320 int ecode3 = 0 ;
24321 int val4 ;
24322 int ecode4 = 0 ;
24323 int val5 ;
24324 int ecode5 = 0 ;
24325 int val6 ;
24326 int ecode6 = 0 ;
24327 int val7 ;
24328 int ecode7 = 0 ;
24329 int val8 ;
24330 int ecode8 = 0 ;
24331 PyObject * obj0 = 0 ;
24332 PyObject * obj1 = 0 ;
24333 PyObject * obj2 = 0 ;
24334 PyObject * obj3 = 0 ;
24335 PyObject * obj4 = 0 ;
24336 PyObject * obj5 = 0 ;
24337 PyObject * obj6 = 0 ;
24338 PyObject * obj7 = 0 ;
24339 char * kwnames[] = {
24340 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24341 };
24342
24343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24345 if (!SWIG_IsOK(res1)) {
24346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24347 }
24348 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24349 ecode2 = SWIG_AsVal_int(obj1, &val2);
24350 if (!SWIG_IsOK(ecode2)) {
24351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24352 }
24353 arg2 = static_cast< int >(val2);
24354 if (obj2) {
24355 ecode3 = SWIG_AsVal_int(obj2, &val3);
24356 if (!SWIG_IsOK(ecode3)) {
24357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24358 }
24359 arg3 = static_cast< wxDateTime::Month >(val3);
24360 }
24361 if (obj3) {
24362 ecode4 = SWIG_AsVal_int(obj3, &val4);
24363 if (!SWIG_IsOK(ecode4)) {
24364 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24365 }
24366 arg4 = static_cast< int >(val4);
24367 }
24368 if (obj4) {
24369 ecode5 = SWIG_AsVal_int(obj4, &val5);
24370 if (!SWIG_IsOK(ecode5)) {
24371 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24372 }
24373 arg5 = static_cast< int >(val5);
24374 }
24375 if (obj5) {
24376 ecode6 = SWIG_AsVal_int(obj5, &val6);
24377 if (!SWIG_IsOK(ecode6)) {
24378 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24379 }
24380 arg6 = static_cast< int >(val6);
24381 }
24382 if (obj6) {
24383 ecode7 = SWIG_AsVal_int(obj6, &val7);
24384 if (!SWIG_IsOK(ecode7)) {
24385 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24386 }
24387 arg7 = static_cast< int >(val7);
24388 }
24389 if (obj7) {
24390 ecode8 = SWIG_AsVal_int(obj7, &val8);
24391 if (!SWIG_IsOK(ecode8)) {
24392 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24393 }
24394 arg8 = static_cast< int >(val8);
24395 }
24396 {
24397 PyThreadState* __tstate = wxPyBeginAllowThreads();
24398 {
24399 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24400 result = (wxDateTime *) &_result_ref;
24401 }
24402 wxPyEndAllowThreads(__tstate);
24403 if (PyErr_Occurred()) SWIG_fail;
24404 }
24405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24406 return resultobj;
24407 fail:
24408 return NULL;
24409 }
24410
24411
24412 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24413 PyObject *resultobj = 0;
24414 wxDateTime *arg1 = (wxDateTime *) 0 ;
24415 wxDateTime *result = 0 ;
24416 void *argp1 = 0 ;
24417 int res1 = 0 ;
24418 PyObject *swig_obj[1] ;
24419
24420 if (!args) SWIG_fail;
24421 swig_obj[0] = args;
24422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24423 if (!SWIG_IsOK(res1)) {
24424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24425 }
24426 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 {
24430 wxDateTime &_result_ref = (arg1)->ResetTime();
24431 result = (wxDateTime *) &_result_ref;
24432 }
24433 wxPyEndAllowThreads(__tstate);
24434 if (PyErr_Occurred()) SWIG_fail;
24435 }
24436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj = 0;
24445 wxDateTime *arg1 = (wxDateTime *) 0 ;
24446 int arg2 ;
24447 wxDateTime *result = 0 ;
24448 void *argp1 = 0 ;
24449 int res1 = 0 ;
24450 int val2 ;
24451 int ecode2 = 0 ;
24452 PyObject * obj0 = 0 ;
24453 PyObject * obj1 = 0 ;
24454 char * kwnames[] = {
24455 (char *) "self",(char *) "year", NULL
24456 };
24457
24458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24460 if (!SWIG_IsOK(res1)) {
24461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24462 }
24463 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24464 ecode2 = SWIG_AsVal_int(obj1, &val2);
24465 if (!SWIG_IsOK(ecode2)) {
24466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24467 }
24468 arg2 = static_cast< int >(val2);
24469 {
24470 PyThreadState* __tstate = wxPyBeginAllowThreads();
24471 {
24472 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24473 result = (wxDateTime *) &_result_ref;
24474 }
24475 wxPyEndAllowThreads(__tstate);
24476 if (PyErr_Occurred()) SWIG_fail;
24477 }
24478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24479 return resultobj;
24480 fail:
24481 return NULL;
24482 }
24483
24484
24485 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24486 PyObject *resultobj = 0;
24487 wxDateTime *arg1 = (wxDateTime *) 0 ;
24488 wxDateTime::Month arg2 ;
24489 wxDateTime *result = 0 ;
24490 void *argp1 = 0 ;
24491 int res1 = 0 ;
24492 int val2 ;
24493 int ecode2 = 0 ;
24494 PyObject * obj0 = 0 ;
24495 PyObject * obj1 = 0 ;
24496 char * kwnames[] = {
24497 (char *) "self",(char *) "month", NULL
24498 };
24499
24500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24502 if (!SWIG_IsOK(res1)) {
24503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24504 }
24505 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24506 ecode2 = SWIG_AsVal_int(obj1, &val2);
24507 if (!SWIG_IsOK(ecode2)) {
24508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24509 }
24510 arg2 = static_cast< wxDateTime::Month >(val2);
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 {
24514 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24515 result = (wxDateTime *) &_result_ref;
24516 }
24517 wxPyEndAllowThreads(__tstate);
24518 if (PyErr_Occurred()) SWIG_fail;
24519 }
24520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24521 return resultobj;
24522 fail:
24523 return NULL;
24524 }
24525
24526
24527 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24528 PyObject *resultobj = 0;
24529 wxDateTime *arg1 = (wxDateTime *) 0 ;
24530 int arg2 ;
24531 wxDateTime *result = 0 ;
24532 void *argp1 = 0 ;
24533 int res1 = 0 ;
24534 int val2 ;
24535 int ecode2 = 0 ;
24536 PyObject * obj0 = 0 ;
24537 PyObject * obj1 = 0 ;
24538 char * kwnames[] = {
24539 (char *) "self",(char *) "day", NULL
24540 };
24541
24542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24544 if (!SWIG_IsOK(res1)) {
24545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24546 }
24547 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24548 ecode2 = SWIG_AsVal_int(obj1, &val2);
24549 if (!SWIG_IsOK(ecode2)) {
24550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24551 }
24552 arg2 = static_cast< int >(val2);
24553 {
24554 PyThreadState* __tstate = wxPyBeginAllowThreads();
24555 {
24556 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24557 result = (wxDateTime *) &_result_ref;
24558 }
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24563 return resultobj;
24564 fail:
24565 return NULL;
24566 }
24567
24568
24569 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24570 PyObject *resultobj = 0;
24571 wxDateTime *arg1 = (wxDateTime *) 0 ;
24572 int arg2 ;
24573 wxDateTime *result = 0 ;
24574 void *argp1 = 0 ;
24575 int res1 = 0 ;
24576 int val2 ;
24577 int ecode2 = 0 ;
24578 PyObject * obj0 = 0 ;
24579 PyObject * obj1 = 0 ;
24580 char * kwnames[] = {
24581 (char *) "self",(char *) "hour", NULL
24582 };
24583
24584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24586 if (!SWIG_IsOK(res1)) {
24587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24588 }
24589 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24590 ecode2 = SWIG_AsVal_int(obj1, &val2);
24591 if (!SWIG_IsOK(ecode2)) {
24592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24593 }
24594 arg2 = static_cast< int >(val2);
24595 {
24596 PyThreadState* __tstate = wxPyBeginAllowThreads();
24597 {
24598 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24599 result = (wxDateTime *) &_result_ref;
24600 }
24601 wxPyEndAllowThreads(__tstate);
24602 if (PyErr_Occurred()) SWIG_fail;
24603 }
24604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24605 return resultobj;
24606 fail:
24607 return NULL;
24608 }
24609
24610
24611 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24612 PyObject *resultobj = 0;
24613 wxDateTime *arg1 = (wxDateTime *) 0 ;
24614 int arg2 ;
24615 wxDateTime *result = 0 ;
24616 void *argp1 = 0 ;
24617 int res1 = 0 ;
24618 int val2 ;
24619 int ecode2 = 0 ;
24620 PyObject * obj0 = 0 ;
24621 PyObject * obj1 = 0 ;
24622 char * kwnames[] = {
24623 (char *) "self",(char *) "minute", NULL
24624 };
24625
24626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24628 if (!SWIG_IsOK(res1)) {
24629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24630 }
24631 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24632 ecode2 = SWIG_AsVal_int(obj1, &val2);
24633 if (!SWIG_IsOK(ecode2)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24635 }
24636 arg2 = static_cast< int >(val2);
24637 {
24638 PyThreadState* __tstate = wxPyBeginAllowThreads();
24639 {
24640 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24641 result = (wxDateTime *) &_result_ref;
24642 }
24643 wxPyEndAllowThreads(__tstate);
24644 if (PyErr_Occurred()) SWIG_fail;
24645 }
24646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24647 return resultobj;
24648 fail:
24649 return NULL;
24650 }
24651
24652
24653 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24654 PyObject *resultobj = 0;
24655 wxDateTime *arg1 = (wxDateTime *) 0 ;
24656 int arg2 ;
24657 wxDateTime *result = 0 ;
24658 void *argp1 = 0 ;
24659 int res1 = 0 ;
24660 int val2 ;
24661 int ecode2 = 0 ;
24662 PyObject * obj0 = 0 ;
24663 PyObject * obj1 = 0 ;
24664 char * kwnames[] = {
24665 (char *) "self",(char *) "second", NULL
24666 };
24667
24668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24670 if (!SWIG_IsOK(res1)) {
24671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24672 }
24673 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24674 ecode2 = SWIG_AsVal_int(obj1, &val2);
24675 if (!SWIG_IsOK(ecode2)) {
24676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24677 }
24678 arg2 = static_cast< int >(val2);
24679 {
24680 PyThreadState* __tstate = wxPyBeginAllowThreads();
24681 {
24682 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24683 result = (wxDateTime *) &_result_ref;
24684 }
24685 wxPyEndAllowThreads(__tstate);
24686 if (PyErr_Occurred()) SWIG_fail;
24687 }
24688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24689 return resultobj;
24690 fail:
24691 return NULL;
24692 }
24693
24694
24695 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24696 PyObject *resultobj = 0;
24697 wxDateTime *arg1 = (wxDateTime *) 0 ;
24698 int arg2 ;
24699 wxDateTime *result = 0 ;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 int val2 ;
24703 int ecode2 = 0 ;
24704 PyObject * obj0 = 0 ;
24705 PyObject * obj1 = 0 ;
24706 char * kwnames[] = {
24707 (char *) "self",(char *) "millisecond", NULL
24708 };
24709
24710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24712 if (!SWIG_IsOK(res1)) {
24713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24714 }
24715 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24716 ecode2 = SWIG_AsVal_int(obj1, &val2);
24717 if (!SWIG_IsOK(ecode2)) {
24718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24719 }
24720 arg2 = static_cast< int >(val2);
24721 {
24722 PyThreadState* __tstate = wxPyBeginAllowThreads();
24723 {
24724 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24725 result = (wxDateTime *) &_result_ref;
24726 }
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24738 PyObject *resultobj = 0;
24739 wxDateTime *arg1 = (wxDateTime *) 0 ;
24740 wxDateTime::WeekDay arg2 ;
24741 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24742 wxDateTime *result = 0 ;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 int val2 ;
24746 int ecode2 = 0 ;
24747 int val3 ;
24748 int ecode3 = 0 ;
24749 PyObject * obj0 = 0 ;
24750 PyObject * obj1 = 0 ;
24751 PyObject * obj2 = 0 ;
24752 char * kwnames[] = {
24753 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24754 };
24755
24756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24758 if (!SWIG_IsOK(res1)) {
24759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24760 }
24761 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24762 ecode2 = SWIG_AsVal_int(obj1, &val2);
24763 if (!SWIG_IsOK(ecode2)) {
24764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24765 }
24766 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24767 if (obj2) {
24768 ecode3 = SWIG_AsVal_int(obj2, &val3);
24769 if (!SWIG_IsOK(ecode3)) {
24770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24771 }
24772 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24773 }
24774 {
24775 PyThreadState* __tstate = wxPyBeginAllowThreads();
24776 {
24777 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24778 result = (wxDateTime *) &_result_ref;
24779 }
24780 wxPyEndAllowThreads(__tstate);
24781 if (PyErr_Occurred()) SWIG_fail;
24782 }
24783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24791 PyObject *resultobj = 0;
24792 wxDateTime *arg1 = (wxDateTime *) 0 ;
24793 wxDateTime::WeekDay arg2 ;
24794 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24795 wxDateTime result;
24796 void *argp1 = 0 ;
24797 int res1 = 0 ;
24798 int val2 ;
24799 int ecode2 = 0 ;
24800 int val3 ;
24801 int ecode3 = 0 ;
24802 PyObject * obj0 = 0 ;
24803 PyObject * obj1 = 0 ;
24804 PyObject * obj2 = 0 ;
24805 char * kwnames[] = {
24806 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24807 };
24808
24809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24811 if (!SWIG_IsOK(res1)) {
24812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24813 }
24814 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24815 ecode2 = SWIG_AsVal_int(obj1, &val2);
24816 if (!SWIG_IsOK(ecode2)) {
24817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24818 }
24819 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24820 if (obj2) {
24821 ecode3 = SWIG_AsVal_int(obj2, &val3);
24822 if (!SWIG_IsOK(ecode3)) {
24823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24824 }
24825 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24826 }
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24830 wxPyEndAllowThreads(__tstate);
24831 if (PyErr_Occurred()) SWIG_fail;
24832 }
24833 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24834 return resultobj;
24835 fail:
24836 return NULL;
24837 }
24838
24839
24840 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24841 PyObject *resultobj = 0;
24842 wxDateTime *arg1 = (wxDateTime *) 0 ;
24843 wxDateTime::WeekDay arg2 ;
24844 wxDateTime *result = 0 ;
24845 void *argp1 = 0 ;
24846 int res1 = 0 ;
24847 int val2 ;
24848 int ecode2 = 0 ;
24849 PyObject * obj0 = 0 ;
24850 PyObject * obj1 = 0 ;
24851 char * kwnames[] = {
24852 (char *) "self",(char *) "weekday", NULL
24853 };
24854
24855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24859 }
24860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24861 ecode2 = SWIG_AsVal_int(obj1, &val2);
24862 if (!SWIG_IsOK(ecode2)) {
24863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24864 }
24865 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 {
24869 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24870 result = (wxDateTime *) &_result_ref;
24871 }
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24876 return resultobj;
24877 fail:
24878 return NULL;
24879 }
24880
24881
24882 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24883 PyObject *resultobj = 0;
24884 wxDateTime *arg1 = (wxDateTime *) 0 ;
24885 wxDateTime::WeekDay arg2 ;
24886 wxDateTime result;
24887 void *argp1 = 0 ;
24888 int res1 = 0 ;
24889 int val2 ;
24890 int ecode2 = 0 ;
24891 PyObject * obj0 = 0 ;
24892 PyObject * obj1 = 0 ;
24893 char * kwnames[] = {
24894 (char *) "self",(char *) "weekday", NULL
24895 };
24896
24897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24901 }
24902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24903 ecode2 = SWIG_AsVal_int(obj1, &val2);
24904 if (!SWIG_IsOK(ecode2)) {
24905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24906 }
24907 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24908 {
24909 PyThreadState* __tstate = wxPyBeginAllowThreads();
24910 result = (arg1)->GetNextWeekDay(arg2);
24911 wxPyEndAllowThreads(__tstate);
24912 if (PyErr_Occurred()) SWIG_fail;
24913 }
24914 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24915 return resultobj;
24916 fail:
24917 return NULL;
24918 }
24919
24920
24921 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24922 PyObject *resultobj = 0;
24923 wxDateTime *arg1 = (wxDateTime *) 0 ;
24924 wxDateTime::WeekDay arg2 ;
24925 wxDateTime *result = 0 ;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 int val2 ;
24929 int ecode2 = 0 ;
24930 PyObject * obj0 = 0 ;
24931 PyObject * obj1 = 0 ;
24932 char * kwnames[] = {
24933 (char *) "self",(char *) "weekday", NULL
24934 };
24935
24936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24938 if (!SWIG_IsOK(res1)) {
24939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24940 }
24941 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24942 ecode2 = SWIG_AsVal_int(obj1, &val2);
24943 if (!SWIG_IsOK(ecode2)) {
24944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24945 }
24946 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 {
24950 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24951 result = (wxDateTime *) &_result_ref;
24952 }
24953 wxPyEndAllowThreads(__tstate);
24954 if (PyErr_Occurred()) SWIG_fail;
24955 }
24956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24957 return resultobj;
24958 fail:
24959 return NULL;
24960 }
24961
24962
24963 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24964 PyObject *resultobj = 0;
24965 wxDateTime *arg1 = (wxDateTime *) 0 ;
24966 wxDateTime::WeekDay arg2 ;
24967 wxDateTime result;
24968 void *argp1 = 0 ;
24969 int res1 = 0 ;
24970 int val2 ;
24971 int ecode2 = 0 ;
24972 PyObject * obj0 = 0 ;
24973 PyObject * obj1 = 0 ;
24974 char * kwnames[] = {
24975 (char *) "self",(char *) "weekday", NULL
24976 };
24977
24978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24980 if (!SWIG_IsOK(res1)) {
24981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24982 }
24983 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24984 ecode2 = SWIG_AsVal_int(obj1, &val2);
24985 if (!SWIG_IsOK(ecode2)) {
24986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24987 }
24988 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24989 {
24990 PyThreadState* __tstate = wxPyBeginAllowThreads();
24991 result = (arg1)->GetPrevWeekDay(arg2);
24992 wxPyEndAllowThreads(__tstate);
24993 if (PyErr_Occurred()) SWIG_fail;
24994 }
24995 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25003 PyObject *resultobj = 0;
25004 wxDateTime *arg1 = (wxDateTime *) 0 ;
25005 wxDateTime::WeekDay arg2 ;
25006 int arg3 = (int) 1 ;
25007 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25008 int arg5 = (int) wxDateTime::Inv_Year ;
25009 bool result;
25010 void *argp1 = 0 ;
25011 int res1 = 0 ;
25012 int val2 ;
25013 int ecode2 = 0 ;
25014 int val3 ;
25015 int ecode3 = 0 ;
25016 int val4 ;
25017 int ecode4 = 0 ;
25018 int val5 ;
25019 int ecode5 = 0 ;
25020 PyObject * obj0 = 0 ;
25021 PyObject * obj1 = 0 ;
25022 PyObject * obj2 = 0 ;
25023 PyObject * obj3 = 0 ;
25024 PyObject * obj4 = 0 ;
25025 char * kwnames[] = {
25026 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25027 };
25028
25029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25031 if (!SWIG_IsOK(res1)) {
25032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25033 }
25034 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25035 ecode2 = SWIG_AsVal_int(obj1, &val2);
25036 if (!SWIG_IsOK(ecode2)) {
25037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25038 }
25039 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25040 if (obj2) {
25041 ecode3 = SWIG_AsVal_int(obj2, &val3);
25042 if (!SWIG_IsOK(ecode3)) {
25043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25044 }
25045 arg3 = static_cast< int >(val3);
25046 }
25047 if (obj3) {
25048 ecode4 = SWIG_AsVal_int(obj3, &val4);
25049 if (!SWIG_IsOK(ecode4)) {
25050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25051 }
25052 arg4 = static_cast< wxDateTime::Month >(val4);
25053 }
25054 if (obj4) {
25055 ecode5 = SWIG_AsVal_int(obj4, &val5);
25056 if (!SWIG_IsOK(ecode5)) {
25057 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25058 }
25059 arg5 = static_cast< int >(val5);
25060 }
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25064 wxPyEndAllowThreads(__tstate);
25065 if (PyErr_Occurred()) SWIG_fail;
25066 }
25067 {
25068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25069 }
25070 return resultobj;
25071 fail:
25072 return NULL;
25073 }
25074
25075
25076 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25077 PyObject *resultobj = 0;
25078 wxDateTime *arg1 = (wxDateTime *) 0 ;
25079 wxDateTime::WeekDay arg2 ;
25080 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25081 int arg4 = (int) wxDateTime::Inv_Year ;
25082 bool result;
25083 void *argp1 = 0 ;
25084 int res1 = 0 ;
25085 int val2 ;
25086 int ecode2 = 0 ;
25087 int val3 ;
25088 int ecode3 = 0 ;
25089 int val4 ;
25090 int ecode4 = 0 ;
25091 PyObject * obj0 = 0 ;
25092 PyObject * obj1 = 0 ;
25093 PyObject * obj2 = 0 ;
25094 PyObject * obj3 = 0 ;
25095 char * kwnames[] = {
25096 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25097 };
25098
25099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25101 if (!SWIG_IsOK(res1)) {
25102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25103 }
25104 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25105 ecode2 = SWIG_AsVal_int(obj1, &val2);
25106 if (!SWIG_IsOK(ecode2)) {
25107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25108 }
25109 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25110 if (obj2) {
25111 ecode3 = SWIG_AsVal_int(obj2, &val3);
25112 if (!SWIG_IsOK(ecode3)) {
25113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25114 }
25115 arg3 = static_cast< wxDateTime::Month >(val3);
25116 }
25117 if (obj3) {
25118 ecode4 = SWIG_AsVal_int(obj3, &val4);
25119 if (!SWIG_IsOK(ecode4)) {
25120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25121 }
25122 arg4 = static_cast< int >(val4);
25123 }
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25127 wxPyEndAllowThreads(__tstate);
25128 if (PyErr_Occurred()) SWIG_fail;
25129 }
25130 {
25131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25132 }
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25140 PyObject *resultobj = 0;
25141 wxDateTime *arg1 = (wxDateTime *) 0 ;
25142 wxDateTime::WeekDay arg2 ;
25143 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25144 int arg4 = (int) wxDateTime::Inv_Year ;
25145 wxDateTime result;
25146 void *argp1 = 0 ;
25147 int res1 = 0 ;
25148 int val2 ;
25149 int ecode2 = 0 ;
25150 int val3 ;
25151 int ecode3 = 0 ;
25152 int val4 ;
25153 int ecode4 = 0 ;
25154 PyObject * obj0 = 0 ;
25155 PyObject * obj1 = 0 ;
25156 PyObject * obj2 = 0 ;
25157 PyObject * obj3 = 0 ;
25158 char * kwnames[] = {
25159 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25160 };
25161
25162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25164 if (!SWIG_IsOK(res1)) {
25165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25166 }
25167 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25168 ecode2 = SWIG_AsVal_int(obj1, &val2);
25169 if (!SWIG_IsOK(ecode2)) {
25170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25171 }
25172 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25173 if (obj2) {
25174 ecode3 = SWIG_AsVal_int(obj2, &val3);
25175 if (!SWIG_IsOK(ecode3)) {
25176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25177 }
25178 arg3 = static_cast< wxDateTime::Month >(val3);
25179 }
25180 if (obj3) {
25181 ecode4 = SWIG_AsVal_int(obj3, &val4);
25182 if (!SWIG_IsOK(ecode4)) {
25183 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25184 }
25185 arg4 = static_cast< int >(val4);
25186 }
25187 {
25188 PyThreadState* __tstate = wxPyBeginAllowThreads();
25189 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25190 wxPyEndAllowThreads(__tstate);
25191 if (PyErr_Occurred()) SWIG_fail;
25192 }
25193 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25194 return resultobj;
25195 fail:
25196 return NULL;
25197 }
25198
25199
25200 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25201 PyObject *resultobj = 0;
25202 wxDateTime *arg1 = (wxDateTime *) 0 ;
25203 int arg2 ;
25204 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25205 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25206 bool result;
25207 void *argp1 = 0 ;
25208 int res1 = 0 ;
25209 int val2 ;
25210 int ecode2 = 0 ;
25211 int val3 ;
25212 int ecode3 = 0 ;
25213 int val4 ;
25214 int ecode4 = 0 ;
25215 PyObject * obj0 = 0 ;
25216 PyObject * obj1 = 0 ;
25217 PyObject * obj2 = 0 ;
25218 PyObject * obj3 = 0 ;
25219 char * kwnames[] = {
25220 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25221 };
25222
25223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25225 if (!SWIG_IsOK(res1)) {
25226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25227 }
25228 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25229 ecode2 = SWIG_AsVal_int(obj1, &val2);
25230 if (!SWIG_IsOK(ecode2)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25232 }
25233 arg2 = static_cast< int >(val2);
25234 if (obj2) {
25235 ecode3 = SWIG_AsVal_int(obj2, &val3);
25236 if (!SWIG_IsOK(ecode3)) {
25237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25238 }
25239 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25240 }
25241 if (obj3) {
25242 ecode4 = SWIG_AsVal_int(obj3, &val4);
25243 if (!SWIG_IsOK(ecode4)) {
25244 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25245 }
25246 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25247 }
25248 {
25249 PyThreadState* __tstate = wxPyBeginAllowThreads();
25250 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25251 wxPyEndAllowThreads(__tstate);
25252 if (PyErr_Occurred()) SWIG_fail;
25253 }
25254 {
25255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25256 }
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25264 PyObject *resultobj = 0;
25265 wxDateTime *arg1 = (wxDateTime *) 0 ;
25266 int arg2 ;
25267 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25268 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25269 wxDateTime result;
25270 void *argp1 = 0 ;
25271 int res1 = 0 ;
25272 int val2 ;
25273 int ecode2 = 0 ;
25274 int val3 ;
25275 int ecode3 = 0 ;
25276 int val4 ;
25277 int ecode4 = 0 ;
25278 PyObject * obj0 = 0 ;
25279 PyObject * obj1 = 0 ;
25280 PyObject * obj2 = 0 ;
25281 PyObject * obj3 = 0 ;
25282 char * kwnames[] = {
25283 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25284 };
25285
25286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25288 if (!SWIG_IsOK(res1)) {
25289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25290 }
25291 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25292 ecode2 = SWIG_AsVal_int(obj1, &val2);
25293 if (!SWIG_IsOK(ecode2)) {
25294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25295 }
25296 arg2 = static_cast< int >(val2);
25297 if (obj2) {
25298 ecode3 = SWIG_AsVal_int(obj2, &val3);
25299 if (!SWIG_IsOK(ecode3)) {
25300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25301 }
25302 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25303 }
25304 if (obj3) {
25305 ecode4 = SWIG_AsVal_int(obj3, &val4);
25306 if (!SWIG_IsOK(ecode4)) {
25307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25308 }
25309 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25310 }
25311 {
25312 PyThreadState* __tstate = wxPyBeginAllowThreads();
25313 result = (arg1)->GetWeek(arg2,arg3,arg4);
25314 wxPyEndAllowThreads(__tstate);
25315 if (PyErr_Occurred()) SWIG_fail;
25316 }
25317 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25318 return resultobj;
25319 fail:
25320 return NULL;
25321 }
25322
25323
25324 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25325 PyObject *resultobj = 0;
25326 int arg1 ;
25327 int arg2 ;
25328 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25329 wxDateTime result;
25330 int val1 ;
25331 int ecode1 = 0 ;
25332 int val2 ;
25333 int ecode2 = 0 ;
25334 int val3 ;
25335 int ecode3 = 0 ;
25336 PyObject * obj0 = 0 ;
25337 PyObject * obj1 = 0 ;
25338 PyObject * obj2 = 0 ;
25339 char * kwnames[] = {
25340 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25341 };
25342
25343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25344 ecode1 = SWIG_AsVal_int(obj0, &val1);
25345 if (!SWIG_IsOK(ecode1)) {
25346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25347 }
25348 arg1 = static_cast< int >(val1);
25349 ecode2 = SWIG_AsVal_int(obj1, &val2);
25350 if (!SWIG_IsOK(ecode2)) {
25351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25352 }
25353 arg2 = static_cast< int >(val2);
25354 if (obj2) {
25355 ecode3 = SWIG_AsVal_int(obj2, &val3);
25356 if (!SWIG_IsOK(ecode3)) {
25357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25358 }
25359 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25360 }
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25364 wxPyEndAllowThreads(__tstate);
25365 if (PyErr_Occurred()) SWIG_fail;
25366 }
25367 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25368 return resultobj;
25369 fail:
25370 return NULL;
25371 }
25372
25373
25374 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25375 PyObject *resultobj = 0;
25376 wxDateTime *arg1 = (wxDateTime *) 0 ;
25377 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25378 int arg3 = (int) wxDateTime::Inv_Year ;
25379 wxDateTime *result = 0 ;
25380 void *argp1 = 0 ;
25381 int res1 = 0 ;
25382 int val2 ;
25383 int ecode2 = 0 ;
25384 int val3 ;
25385 int ecode3 = 0 ;
25386 PyObject * obj0 = 0 ;
25387 PyObject * obj1 = 0 ;
25388 PyObject * obj2 = 0 ;
25389 char * kwnames[] = {
25390 (char *) "self",(char *) "month",(char *) "year", NULL
25391 };
25392
25393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25395 if (!SWIG_IsOK(res1)) {
25396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25397 }
25398 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25399 if (obj1) {
25400 ecode2 = SWIG_AsVal_int(obj1, &val2);
25401 if (!SWIG_IsOK(ecode2)) {
25402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25403 }
25404 arg2 = static_cast< wxDateTime::Month >(val2);
25405 }
25406 if (obj2) {
25407 ecode3 = SWIG_AsVal_int(obj2, &val3);
25408 if (!SWIG_IsOK(ecode3)) {
25409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25410 }
25411 arg3 = static_cast< int >(val3);
25412 }
25413 {
25414 PyThreadState* __tstate = wxPyBeginAllowThreads();
25415 {
25416 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25417 result = (wxDateTime *) &_result_ref;
25418 }
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25430 PyObject *resultobj = 0;
25431 wxDateTime *arg1 = (wxDateTime *) 0 ;
25432 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25433 int arg3 = (int) wxDateTime::Inv_Year ;
25434 wxDateTime result;
25435 void *argp1 = 0 ;
25436 int res1 = 0 ;
25437 int val2 ;
25438 int ecode2 = 0 ;
25439 int val3 ;
25440 int ecode3 = 0 ;
25441 PyObject * obj0 = 0 ;
25442 PyObject * obj1 = 0 ;
25443 PyObject * obj2 = 0 ;
25444 char * kwnames[] = {
25445 (char *) "self",(char *) "month",(char *) "year", NULL
25446 };
25447
25448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25450 if (!SWIG_IsOK(res1)) {
25451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25452 }
25453 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25454 if (obj1) {
25455 ecode2 = SWIG_AsVal_int(obj1, &val2);
25456 if (!SWIG_IsOK(ecode2)) {
25457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25458 }
25459 arg2 = static_cast< wxDateTime::Month >(val2);
25460 }
25461 if (obj2) {
25462 ecode3 = SWIG_AsVal_int(obj2, &val3);
25463 if (!SWIG_IsOK(ecode3)) {
25464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25465 }
25466 arg3 = static_cast< int >(val3);
25467 }
25468 {
25469 PyThreadState* __tstate = wxPyBeginAllowThreads();
25470 result = (arg1)->GetLastMonthDay(arg2,arg3);
25471 wxPyEndAllowThreads(__tstate);
25472 if (PyErr_Occurred()) SWIG_fail;
25473 }
25474 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25475 return resultobj;
25476 fail:
25477 return NULL;
25478 }
25479
25480
25481 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25482 PyObject *resultobj = 0;
25483 wxDateTime *arg1 = (wxDateTime *) 0 ;
25484 int arg2 ;
25485 wxDateTime *result = 0 ;
25486 void *argp1 = 0 ;
25487 int res1 = 0 ;
25488 int val2 ;
25489 int ecode2 = 0 ;
25490 PyObject * obj0 = 0 ;
25491 PyObject * obj1 = 0 ;
25492 char * kwnames[] = {
25493 (char *) "self",(char *) "yday", NULL
25494 };
25495
25496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25498 if (!SWIG_IsOK(res1)) {
25499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25500 }
25501 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25502 ecode2 = SWIG_AsVal_int(obj1, &val2);
25503 if (!SWIG_IsOK(ecode2)) {
25504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25505 }
25506 arg2 = static_cast< int >(val2);
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 {
25510 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25511 result = (wxDateTime *) &_result_ref;
25512 }
25513 wxPyEndAllowThreads(__tstate);
25514 if (PyErr_Occurred()) SWIG_fail;
25515 }
25516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25517 return resultobj;
25518 fail:
25519 return NULL;
25520 }
25521
25522
25523 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25524 PyObject *resultobj = 0;
25525 wxDateTime *arg1 = (wxDateTime *) 0 ;
25526 int arg2 ;
25527 wxDateTime result;
25528 void *argp1 = 0 ;
25529 int res1 = 0 ;
25530 int val2 ;
25531 int ecode2 = 0 ;
25532 PyObject * obj0 = 0 ;
25533 PyObject * obj1 = 0 ;
25534 char * kwnames[] = {
25535 (char *) "self",(char *) "yday", NULL
25536 };
25537
25538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25540 if (!SWIG_IsOK(res1)) {
25541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25542 }
25543 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25544 ecode2 = SWIG_AsVal_int(obj1, &val2);
25545 if (!SWIG_IsOK(ecode2)) {
25546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25547 }
25548 arg2 = static_cast< int >(val2);
25549 {
25550 PyThreadState* __tstate = wxPyBeginAllowThreads();
25551 result = (arg1)->GetYearDay(arg2);
25552 wxPyEndAllowThreads(__tstate);
25553 if (PyErr_Occurred()) SWIG_fail;
25554 }
25555 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25556 return resultobj;
25557 fail:
25558 return NULL;
25559 }
25560
25561
25562 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25563 PyObject *resultobj = 0;
25564 wxDateTime *arg1 = (wxDateTime *) 0 ;
25565 double result;
25566 void *argp1 = 0 ;
25567 int res1 = 0 ;
25568 PyObject *swig_obj[1] ;
25569
25570 if (!args) SWIG_fail;
25571 swig_obj[0] = args;
25572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25573 if (!SWIG_IsOK(res1)) {
25574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25575 }
25576 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (double)(arg1)->GetJulianDayNumber();
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_From_double(static_cast< double >(result));
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25591 PyObject *resultobj = 0;
25592 wxDateTime *arg1 = (wxDateTime *) 0 ;
25593 double result;
25594 void *argp1 = 0 ;
25595 int res1 = 0 ;
25596 PyObject *swig_obj[1] ;
25597
25598 if (!args) SWIG_fail;
25599 swig_obj[0] = args;
25600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25601 if (!SWIG_IsOK(res1)) {
25602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25603 }
25604 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25605 {
25606 PyThreadState* __tstate = wxPyBeginAllowThreads();
25607 result = (double)(arg1)->GetJDN();
25608 wxPyEndAllowThreads(__tstate);
25609 if (PyErr_Occurred()) SWIG_fail;
25610 }
25611 resultobj = SWIG_From_double(static_cast< double >(result));
25612 return resultobj;
25613 fail:
25614 return NULL;
25615 }
25616
25617
25618 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25619 PyObject *resultobj = 0;
25620 wxDateTime *arg1 = (wxDateTime *) 0 ;
25621 double result;
25622 void *argp1 = 0 ;
25623 int res1 = 0 ;
25624 PyObject *swig_obj[1] ;
25625
25626 if (!args) SWIG_fail;
25627 swig_obj[0] = args;
25628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25629 if (!SWIG_IsOK(res1)) {
25630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25631 }
25632 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25633 {
25634 PyThreadState* __tstate = wxPyBeginAllowThreads();
25635 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25636 wxPyEndAllowThreads(__tstate);
25637 if (PyErr_Occurred()) SWIG_fail;
25638 }
25639 resultobj = SWIG_From_double(static_cast< double >(result));
25640 return resultobj;
25641 fail:
25642 return NULL;
25643 }
25644
25645
25646 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25647 PyObject *resultobj = 0;
25648 wxDateTime *arg1 = (wxDateTime *) 0 ;
25649 double result;
25650 void *argp1 = 0 ;
25651 int res1 = 0 ;
25652 PyObject *swig_obj[1] ;
25653
25654 if (!args) SWIG_fail;
25655 swig_obj[0] = args;
25656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25657 if (!SWIG_IsOK(res1)) {
25658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25659 }
25660 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25661 {
25662 PyThreadState* __tstate = wxPyBeginAllowThreads();
25663 result = (double)(arg1)->GetMJD();
25664 wxPyEndAllowThreads(__tstate);
25665 if (PyErr_Occurred()) SWIG_fail;
25666 }
25667 resultobj = SWIG_From_double(static_cast< double >(result));
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25675 PyObject *resultobj = 0;
25676 wxDateTime *arg1 = (wxDateTime *) 0 ;
25677 double result;
25678 void *argp1 = 0 ;
25679 int res1 = 0 ;
25680 PyObject *swig_obj[1] ;
25681
25682 if (!args) SWIG_fail;
25683 swig_obj[0] = args;
25684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25685 if (!SWIG_IsOK(res1)) {
25686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25687 }
25688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25689 {
25690 PyThreadState* __tstate = wxPyBeginAllowThreads();
25691 result = (double)(arg1)->GetRataDie();
25692 wxPyEndAllowThreads(__tstate);
25693 if (PyErr_Occurred()) SWIG_fail;
25694 }
25695 resultobj = SWIG_From_double(static_cast< double >(result));
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj = 0;
25704 wxDateTime *arg1 = (wxDateTime *) 0 ;
25705 wxDateTime::TimeZone *arg2 = 0 ;
25706 bool arg3 = (bool) false ;
25707 wxDateTime result;
25708 void *argp1 = 0 ;
25709 int res1 = 0 ;
25710 bool temp2 = false ;
25711 bool val3 ;
25712 int ecode3 = 0 ;
25713 PyObject * obj0 = 0 ;
25714 PyObject * obj1 = 0 ;
25715 PyObject * obj2 = 0 ;
25716 char * kwnames[] = {
25717 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25718 };
25719
25720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25722 if (!SWIG_IsOK(res1)) {
25723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25724 }
25725 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25726 {
25727 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25728 temp2 = true;
25729 }
25730 if (obj2) {
25731 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25732 if (!SWIG_IsOK(ecode3)) {
25733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25734 }
25735 arg3 = static_cast< bool >(val3);
25736 }
25737 {
25738 PyThreadState* __tstate = wxPyBeginAllowThreads();
25739 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25744 {
25745 if (temp2) delete arg2;
25746 }
25747 return resultobj;
25748 fail:
25749 {
25750 if (temp2) delete arg2;
25751 }
25752 return NULL;
25753 }
25754
25755
25756 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25757 PyObject *resultobj = 0;
25758 wxDateTime *arg1 = (wxDateTime *) 0 ;
25759 wxDateTime::TimeZone *arg2 = 0 ;
25760 bool arg3 = (bool) false ;
25761 wxDateTime *result = 0 ;
25762 void *argp1 = 0 ;
25763 int res1 = 0 ;
25764 bool temp2 = false ;
25765 bool val3 ;
25766 int ecode3 = 0 ;
25767 PyObject * obj0 = 0 ;
25768 PyObject * obj1 = 0 ;
25769 PyObject * obj2 = 0 ;
25770 char * kwnames[] = {
25771 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25772 };
25773
25774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25776 if (!SWIG_IsOK(res1)) {
25777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25778 }
25779 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25780 {
25781 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25782 temp2 = true;
25783 }
25784 if (obj2) {
25785 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25786 if (!SWIG_IsOK(ecode3)) {
25787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25788 }
25789 arg3 = static_cast< bool >(val3);
25790 }
25791 {
25792 PyThreadState* __tstate = wxPyBeginAllowThreads();
25793 {
25794 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25795 result = (wxDateTime *) &_result_ref;
25796 }
25797 wxPyEndAllowThreads(__tstate);
25798 if (PyErr_Occurred()) SWIG_fail;
25799 }
25800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25801 {
25802 if (temp2) delete arg2;
25803 }
25804 return resultobj;
25805 fail:
25806 {
25807 if (temp2) delete arg2;
25808 }
25809 return NULL;
25810 }
25811
25812
25813 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25814 PyObject *resultobj = 0;
25815 wxDateTime *arg1 = (wxDateTime *) 0 ;
25816 wxDateTime::TimeZone *arg2 = 0 ;
25817 bool arg3 = (bool) false ;
25818 wxDateTime result;
25819 void *argp1 = 0 ;
25820 int res1 = 0 ;
25821 bool temp2 = false ;
25822 bool val3 ;
25823 int ecode3 = 0 ;
25824 PyObject * obj0 = 0 ;
25825 PyObject * obj1 = 0 ;
25826 PyObject * obj2 = 0 ;
25827 char * kwnames[] = {
25828 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25829 };
25830
25831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25833 if (!SWIG_IsOK(res1)) {
25834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25835 }
25836 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25837 {
25838 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25839 temp2 = true;
25840 }
25841 if (obj2) {
25842 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25843 if (!SWIG_IsOK(ecode3)) {
25844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25845 }
25846 arg3 = static_cast< bool >(val3);
25847 }
25848 {
25849 PyThreadState* __tstate = wxPyBeginAllowThreads();
25850 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25851 wxPyEndAllowThreads(__tstate);
25852 if (PyErr_Occurred()) SWIG_fail;
25853 }
25854 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25855 {
25856 if (temp2) delete arg2;
25857 }
25858 return resultobj;
25859 fail:
25860 {
25861 if (temp2) delete arg2;
25862 }
25863 return NULL;
25864 }
25865
25866
25867 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25868 PyObject *resultobj = 0;
25869 wxDateTime *arg1 = (wxDateTime *) 0 ;
25870 wxDateTime::TimeZone *arg2 = 0 ;
25871 bool arg3 = (bool) false ;
25872 wxDateTime *result = 0 ;
25873 void *argp1 = 0 ;
25874 int res1 = 0 ;
25875 bool temp2 = false ;
25876 bool val3 ;
25877 int ecode3 = 0 ;
25878 PyObject * obj0 = 0 ;
25879 PyObject * obj1 = 0 ;
25880 PyObject * obj2 = 0 ;
25881 char * kwnames[] = {
25882 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25883 };
25884
25885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25887 if (!SWIG_IsOK(res1)) {
25888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25889 }
25890 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25891 {
25892 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25893 temp2 = true;
25894 }
25895 if (obj2) {
25896 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25897 if (!SWIG_IsOK(ecode3)) {
25898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25899 }
25900 arg3 = static_cast< bool >(val3);
25901 }
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 {
25905 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25906 result = (wxDateTime *) &_result_ref;
25907 }
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25912 {
25913 if (temp2) delete arg2;
25914 }
25915 return resultobj;
25916 fail:
25917 {
25918 if (temp2) delete arg2;
25919 }
25920 return NULL;
25921 }
25922
25923
25924 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25925 PyObject *resultobj = 0;
25926 wxDateTime *arg1 = (wxDateTime *) 0 ;
25927 bool arg2 = (bool) false ;
25928 wxDateTime result;
25929 void *argp1 = 0 ;
25930 int res1 = 0 ;
25931 bool val2 ;
25932 int ecode2 = 0 ;
25933 PyObject * obj0 = 0 ;
25934 PyObject * obj1 = 0 ;
25935 char * kwnames[] = {
25936 (char *) "self",(char *) "noDST", NULL
25937 };
25938
25939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25941 if (!SWIG_IsOK(res1)) {
25942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25943 }
25944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25945 if (obj1) {
25946 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25947 if (!SWIG_IsOK(ecode2)) {
25948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25949 }
25950 arg2 = static_cast< bool >(val2);
25951 }
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25966 PyObject *resultobj = 0;
25967 wxDateTime *arg1 = (wxDateTime *) 0 ;
25968 bool arg2 = (bool) false ;
25969 wxDateTime *result = 0 ;
25970 void *argp1 = 0 ;
25971 int res1 = 0 ;
25972 bool val2 ;
25973 int ecode2 = 0 ;
25974 PyObject * obj0 = 0 ;
25975 PyObject * obj1 = 0 ;
25976 char * kwnames[] = {
25977 (char *) "self",(char *) "noDST", NULL
25978 };
25979
25980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25982 if (!SWIG_IsOK(res1)) {
25983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25984 }
25985 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25986 if (obj1) {
25987 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25988 if (!SWIG_IsOK(ecode2)) {
25989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25990 }
25991 arg2 = static_cast< bool >(val2);
25992 }
25993 {
25994 PyThreadState* __tstate = wxPyBeginAllowThreads();
25995 {
25996 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25997 result = (wxDateTime *) &_result_ref;
25998 }
25999 wxPyEndAllowThreads(__tstate);
26000 if (PyErr_Occurred()) SWIG_fail;
26001 }
26002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26003 return resultobj;
26004 fail:
26005 return NULL;
26006 }
26007
26008
26009 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26010 PyObject *resultobj = 0;
26011 wxDateTime *arg1 = (wxDateTime *) 0 ;
26012 bool arg2 = (bool) false ;
26013 wxDateTime result;
26014 void *argp1 = 0 ;
26015 int res1 = 0 ;
26016 bool val2 ;
26017 int ecode2 = 0 ;
26018 PyObject * obj0 = 0 ;
26019 PyObject * obj1 = 0 ;
26020 char * kwnames[] = {
26021 (char *) "self",(char *) "noDST", NULL
26022 };
26023
26024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26026 if (!SWIG_IsOK(res1)) {
26027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26028 }
26029 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26030 if (obj1) {
26031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26032 if (!SWIG_IsOK(ecode2)) {
26033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26034 }
26035 arg2 = static_cast< bool >(val2);
26036 }
26037 {
26038 PyThreadState* __tstate = wxPyBeginAllowThreads();
26039 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26040 wxPyEndAllowThreads(__tstate);
26041 if (PyErr_Occurred()) SWIG_fail;
26042 }
26043 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26044 return resultobj;
26045 fail:
26046 return NULL;
26047 }
26048
26049
26050 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26051 PyObject *resultobj = 0;
26052 wxDateTime *arg1 = (wxDateTime *) 0 ;
26053 bool arg2 = (bool) false ;
26054 wxDateTime *result = 0 ;
26055 void *argp1 = 0 ;
26056 int res1 = 0 ;
26057 bool val2 ;
26058 int ecode2 = 0 ;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 char * kwnames[] = {
26062 (char *) "self",(char *) "noDST", NULL
26063 };
26064
26065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26067 if (!SWIG_IsOK(res1)) {
26068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26069 }
26070 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26071 if (obj1) {
26072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26073 if (!SWIG_IsOK(ecode2)) {
26074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26075 }
26076 arg2 = static_cast< bool >(val2);
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 {
26081 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26082 result = (wxDateTime *) &_result_ref;
26083 }
26084 wxPyEndAllowThreads(__tstate);
26085 if (PyErr_Occurred()) SWIG_fail;
26086 }
26087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj = 0;
26096 wxDateTime *arg1 = (wxDateTime *) 0 ;
26097 bool arg2 = (bool) false ;
26098 wxDateTime result;
26099 void *argp1 = 0 ;
26100 int res1 = 0 ;
26101 bool val2 ;
26102 int ecode2 = 0 ;
26103 PyObject * obj0 = 0 ;
26104 PyObject * obj1 = 0 ;
26105 char * kwnames[] = {
26106 (char *) "self",(char *) "noDST", NULL
26107 };
26108
26109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26111 if (!SWIG_IsOK(res1)) {
26112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26113 }
26114 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26115 if (obj1) {
26116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26117 if (!SWIG_IsOK(ecode2)) {
26118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26119 }
26120 arg2 = static_cast< bool >(val2);
26121 }
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26125 wxPyEndAllowThreads(__tstate);
26126 if (PyErr_Occurred()) SWIG_fail;
26127 }
26128 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26129 return resultobj;
26130 fail:
26131 return NULL;
26132 }
26133
26134
26135 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26136 PyObject *resultobj = 0;
26137 wxDateTime *arg1 = (wxDateTime *) 0 ;
26138 bool arg2 = (bool) false ;
26139 wxDateTime *result = 0 ;
26140 void *argp1 = 0 ;
26141 int res1 = 0 ;
26142 bool val2 ;
26143 int ecode2 = 0 ;
26144 PyObject * obj0 = 0 ;
26145 PyObject * obj1 = 0 ;
26146 char * kwnames[] = {
26147 (char *) "self",(char *) "noDST", NULL
26148 };
26149
26150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26152 if (!SWIG_IsOK(res1)) {
26153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26154 }
26155 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26156 if (obj1) {
26157 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26158 if (!SWIG_IsOK(ecode2)) {
26159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26160 }
26161 arg2 = static_cast< bool >(val2);
26162 }
26163 {
26164 PyThreadState* __tstate = wxPyBeginAllowThreads();
26165 {
26166 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26167 result = (wxDateTime *) &_result_ref;
26168 }
26169 wxPyEndAllowThreads(__tstate);
26170 if (PyErr_Occurred()) SWIG_fail;
26171 }
26172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26173 return resultobj;
26174 fail:
26175 return NULL;
26176 }
26177
26178
26179 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26180 PyObject *resultobj = 0;
26181 wxDateTime *arg1 = (wxDateTime *) 0 ;
26182 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26183 int result;
26184 void *argp1 = 0 ;
26185 int res1 = 0 ;
26186 int val2 ;
26187 int ecode2 = 0 ;
26188 PyObject * obj0 = 0 ;
26189 PyObject * obj1 = 0 ;
26190 char * kwnames[] = {
26191 (char *) "self",(char *) "country", NULL
26192 };
26193
26194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26196 if (!SWIG_IsOK(res1)) {
26197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26198 }
26199 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26200 if (obj1) {
26201 ecode2 = SWIG_AsVal_int(obj1, &val2);
26202 if (!SWIG_IsOK(ecode2)) {
26203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26204 }
26205 arg2 = static_cast< wxDateTime::Country >(val2);
26206 }
26207 {
26208 PyThreadState* __tstate = wxPyBeginAllowThreads();
26209 result = (int)(arg1)->IsDST(arg2);
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 resultobj = SWIG_From_int(static_cast< int >(result));
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26221 PyObject *resultobj = 0;
26222 wxDateTime *arg1 = (wxDateTime *) 0 ;
26223 bool result;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 PyObject *swig_obj[1] ;
26227
26228 if (!args) SWIG_fail;
26229 swig_obj[0] = args;
26230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26231 if (!SWIG_IsOK(res1)) {
26232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26233 }
26234 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26235 {
26236 PyThreadState* __tstate = wxPyBeginAllowThreads();
26237 result = (bool)((wxDateTime const *)arg1)->IsValid();
26238 wxPyEndAllowThreads(__tstate);
26239 if (PyErr_Occurred()) SWIG_fail;
26240 }
26241 {
26242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26243 }
26244 return resultobj;
26245 fail:
26246 return NULL;
26247 }
26248
26249
26250 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26251 PyObject *resultobj = 0;
26252 wxDateTime *arg1 = (wxDateTime *) 0 ;
26253 time_t result;
26254 void *argp1 = 0 ;
26255 int res1 = 0 ;
26256 PyObject *swig_obj[1] ;
26257
26258 if (!args) SWIG_fail;
26259 swig_obj[0] = args;
26260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26261 if (!SWIG_IsOK(res1)) {
26262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26263 }
26264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26279 PyObject *resultobj = 0;
26280 wxDateTime *arg1 = (wxDateTime *) 0 ;
26281 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26282 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26283 int result;
26284 void *argp1 = 0 ;
26285 int res1 = 0 ;
26286 bool temp2 = false ;
26287 PyObject * obj0 = 0 ;
26288 PyObject * obj1 = 0 ;
26289 char * kwnames[] = {
26290 (char *) "self",(char *) "tz", NULL
26291 };
26292
26293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26295 if (!SWIG_IsOK(res1)) {
26296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26297 }
26298 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26299 if (obj1) {
26300 {
26301 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26302 temp2 = true;
26303 }
26304 }
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 resultobj = SWIG_From_int(static_cast< int >(result));
26312 {
26313 if (temp2) delete arg2;
26314 }
26315 return resultobj;
26316 fail:
26317 {
26318 if (temp2) delete arg2;
26319 }
26320 return NULL;
26321 }
26322
26323
26324 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26325 PyObject *resultobj = 0;
26326 wxDateTime *arg1 = (wxDateTime *) 0 ;
26327 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26328 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26329 wxDateTime::Month result;
26330 void *argp1 = 0 ;
26331 int res1 = 0 ;
26332 bool temp2 = false ;
26333 PyObject * obj0 = 0 ;
26334 PyObject * obj1 = 0 ;
26335 char * kwnames[] = {
26336 (char *) "self",(char *) "tz", NULL
26337 };
26338
26339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26341 if (!SWIG_IsOK(res1)) {
26342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26343 }
26344 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26345 if (obj1) {
26346 {
26347 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26348 temp2 = true;
26349 }
26350 }
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26354 wxPyEndAllowThreads(__tstate);
26355 if (PyErr_Occurred()) SWIG_fail;
26356 }
26357 resultobj = SWIG_From_int(static_cast< int >(result));
26358 {
26359 if (temp2) delete arg2;
26360 }
26361 return resultobj;
26362 fail:
26363 {
26364 if (temp2) delete arg2;
26365 }
26366 return NULL;
26367 }
26368
26369
26370 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26371 PyObject *resultobj = 0;
26372 wxDateTime *arg1 = (wxDateTime *) 0 ;
26373 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26374 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26375 int result;
26376 void *argp1 = 0 ;
26377 int res1 = 0 ;
26378 bool temp2 = false ;
26379 PyObject * obj0 = 0 ;
26380 PyObject * obj1 = 0 ;
26381 char * kwnames[] = {
26382 (char *) "self",(char *) "tz", NULL
26383 };
26384
26385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26387 if (!SWIG_IsOK(res1)) {
26388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26389 }
26390 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26391 if (obj1) {
26392 {
26393 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26394 temp2 = true;
26395 }
26396 }
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 resultobj = SWIG_From_int(static_cast< int >(result));
26404 {
26405 if (temp2) delete arg2;
26406 }
26407 return resultobj;
26408 fail:
26409 {
26410 if (temp2) delete arg2;
26411 }
26412 return NULL;
26413 }
26414
26415
26416 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26417 PyObject *resultobj = 0;
26418 wxDateTime *arg1 = (wxDateTime *) 0 ;
26419 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26420 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26421 wxDateTime::WeekDay result;
26422 void *argp1 = 0 ;
26423 int res1 = 0 ;
26424 bool temp2 = false ;
26425 PyObject * obj0 = 0 ;
26426 PyObject * obj1 = 0 ;
26427 char * kwnames[] = {
26428 (char *) "self",(char *) "tz", NULL
26429 };
26430
26431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26433 if (!SWIG_IsOK(res1)) {
26434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26435 }
26436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26437 if (obj1) {
26438 {
26439 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26440 temp2 = true;
26441 }
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26446 wxPyEndAllowThreads(__tstate);
26447 if (PyErr_Occurred()) SWIG_fail;
26448 }
26449 resultobj = SWIG_From_int(static_cast< int >(result));
26450 {
26451 if (temp2) delete arg2;
26452 }
26453 return resultobj;
26454 fail:
26455 {
26456 if (temp2) delete arg2;
26457 }
26458 return NULL;
26459 }
26460
26461
26462 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26463 PyObject *resultobj = 0;
26464 wxDateTime *arg1 = (wxDateTime *) 0 ;
26465 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26466 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26467 int result;
26468 void *argp1 = 0 ;
26469 int res1 = 0 ;
26470 bool temp2 = false ;
26471 PyObject * obj0 = 0 ;
26472 PyObject * obj1 = 0 ;
26473 char * kwnames[] = {
26474 (char *) "self",(char *) "tz", NULL
26475 };
26476
26477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26479 if (!SWIG_IsOK(res1)) {
26480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26481 }
26482 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26483 if (obj1) {
26484 {
26485 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26486 temp2 = true;
26487 }
26488 }
26489 {
26490 PyThreadState* __tstate = wxPyBeginAllowThreads();
26491 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26492 wxPyEndAllowThreads(__tstate);
26493 if (PyErr_Occurred()) SWIG_fail;
26494 }
26495 resultobj = SWIG_From_int(static_cast< int >(result));
26496 {
26497 if (temp2) delete arg2;
26498 }
26499 return resultobj;
26500 fail:
26501 {
26502 if (temp2) delete arg2;
26503 }
26504 return NULL;
26505 }
26506
26507
26508 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26509 PyObject *resultobj = 0;
26510 wxDateTime *arg1 = (wxDateTime *) 0 ;
26511 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26512 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26513 int result;
26514 void *argp1 = 0 ;
26515 int res1 = 0 ;
26516 bool temp2 = false ;
26517 PyObject * obj0 = 0 ;
26518 PyObject * obj1 = 0 ;
26519 char * kwnames[] = {
26520 (char *) "self",(char *) "tz", NULL
26521 };
26522
26523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26525 if (!SWIG_IsOK(res1)) {
26526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26527 }
26528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26529 if (obj1) {
26530 {
26531 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26532 temp2 = true;
26533 }
26534 }
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 resultobj = SWIG_From_int(static_cast< int >(result));
26542 {
26543 if (temp2) delete arg2;
26544 }
26545 return resultobj;
26546 fail:
26547 {
26548 if (temp2) delete arg2;
26549 }
26550 return NULL;
26551 }
26552
26553
26554 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26555 PyObject *resultobj = 0;
26556 wxDateTime *arg1 = (wxDateTime *) 0 ;
26557 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26558 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26559 int result;
26560 void *argp1 = 0 ;
26561 int res1 = 0 ;
26562 bool temp2 = false ;
26563 PyObject * obj0 = 0 ;
26564 PyObject * obj1 = 0 ;
26565 char * kwnames[] = {
26566 (char *) "self",(char *) "tz", NULL
26567 };
26568
26569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26571 if (!SWIG_IsOK(res1)) {
26572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26573 }
26574 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26575 if (obj1) {
26576 {
26577 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26578 temp2 = true;
26579 }
26580 }
26581 {
26582 PyThreadState* __tstate = wxPyBeginAllowThreads();
26583 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26584 wxPyEndAllowThreads(__tstate);
26585 if (PyErr_Occurred()) SWIG_fail;
26586 }
26587 resultobj = SWIG_From_int(static_cast< int >(result));
26588 {
26589 if (temp2) delete arg2;
26590 }
26591 return resultobj;
26592 fail:
26593 {
26594 if (temp2) delete arg2;
26595 }
26596 return NULL;
26597 }
26598
26599
26600 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26601 PyObject *resultobj = 0;
26602 wxDateTime *arg1 = (wxDateTime *) 0 ;
26603 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26604 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26605 int result;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 bool temp2 = false ;
26609 PyObject * obj0 = 0 ;
26610 PyObject * obj1 = 0 ;
26611 char * kwnames[] = {
26612 (char *) "self",(char *) "tz", NULL
26613 };
26614
26615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26617 if (!SWIG_IsOK(res1)) {
26618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26619 }
26620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26621 if (obj1) {
26622 {
26623 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26624 temp2 = true;
26625 }
26626 }
26627 {
26628 PyThreadState* __tstate = wxPyBeginAllowThreads();
26629 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26630 wxPyEndAllowThreads(__tstate);
26631 if (PyErr_Occurred()) SWIG_fail;
26632 }
26633 resultobj = SWIG_From_int(static_cast< int >(result));
26634 {
26635 if (temp2) delete arg2;
26636 }
26637 return resultobj;
26638 fail:
26639 {
26640 if (temp2) delete arg2;
26641 }
26642 return NULL;
26643 }
26644
26645
26646 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26647 PyObject *resultobj = 0;
26648 wxDateTime *arg1 = (wxDateTime *) 0 ;
26649 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26650 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26651 int result;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 bool temp2 = false ;
26655 PyObject * obj0 = 0 ;
26656 PyObject * obj1 = 0 ;
26657 char * kwnames[] = {
26658 (char *) "self",(char *) "tz", NULL
26659 };
26660
26661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26663 if (!SWIG_IsOK(res1)) {
26664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26665 }
26666 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26667 if (obj1) {
26668 {
26669 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26670 temp2 = true;
26671 }
26672 }
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 resultobj = SWIG_From_int(static_cast< int >(result));
26680 {
26681 if (temp2) delete arg2;
26682 }
26683 return resultobj;
26684 fail:
26685 {
26686 if (temp2) delete arg2;
26687 }
26688 return NULL;
26689 }
26690
26691
26692 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26693 PyObject *resultobj = 0;
26694 wxDateTime *arg1 = (wxDateTime *) 0 ;
26695 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26696 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26697 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26698 int result;
26699 void *argp1 = 0 ;
26700 int res1 = 0 ;
26701 int val2 ;
26702 int ecode2 = 0 ;
26703 bool temp3 = false ;
26704 PyObject * obj0 = 0 ;
26705 PyObject * obj1 = 0 ;
26706 PyObject * obj2 = 0 ;
26707 char * kwnames[] = {
26708 (char *) "self",(char *) "flags",(char *) "tz", NULL
26709 };
26710
26711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26715 }
26716 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26717 if (obj1) {
26718 ecode2 = SWIG_AsVal_int(obj1, &val2);
26719 if (!SWIG_IsOK(ecode2)) {
26720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26721 }
26722 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26723 }
26724 if (obj2) {
26725 {
26726 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26727 temp3 = true;
26728 }
26729 }
26730 {
26731 PyThreadState* __tstate = wxPyBeginAllowThreads();
26732 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26733 wxPyEndAllowThreads(__tstate);
26734 if (PyErr_Occurred()) SWIG_fail;
26735 }
26736 resultobj = SWIG_From_int(static_cast< int >(result));
26737 {
26738 if (temp3) delete arg3;
26739 }
26740 return resultobj;
26741 fail:
26742 {
26743 if (temp3) delete arg3;
26744 }
26745 return NULL;
26746 }
26747
26748
26749 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj = 0;
26751 wxDateTime *arg1 = (wxDateTime *) 0 ;
26752 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26753 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26754 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26755 int result;
26756 void *argp1 = 0 ;
26757 int res1 = 0 ;
26758 int val2 ;
26759 int ecode2 = 0 ;
26760 bool temp3 = false ;
26761 PyObject * obj0 = 0 ;
26762 PyObject * obj1 = 0 ;
26763 PyObject * obj2 = 0 ;
26764 char * kwnames[] = {
26765 (char *) "self",(char *) "flags",(char *) "tz", NULL
26766 };
26767
26768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26770 if (!SWIG_IsOK(res1)) {
26771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26772 }
26773 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26774 if (obj1) {
26775 ecode2 = SWIG_AsVal_int(obj1, &val2);
26776 if (!SWIG_IsOK(ecode2)) {
26777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26778 }
26779 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26780 }
26781 if (obj2) {
26782 {
26783 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26784 temp3 = true;
26785 }
26786 }
26787 {
26788 PyThreadState* __tstate = wxPyBeginAllowThreads();
26789 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26790 wxPyEndAllowThreads(__tstate);
26791 if (PyErr_Occurred()) SWIG_fail;
26792 }
26793 resultobj = SWIG_From_int(static_cast< int >(result));
26794 {
26795 if (temp3) delete arg3;
26796 }
26797 return resultobj;
26798 fail:
26799 {
26800 if (temp3) delete arg3;
26801 }
26802 return NULL;
26803 }
26804
26805
26806 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26807 PyObject *resultobj = 0;
26808 wxDateTime *arg1 = (wxDateTime *) 0 ;
26809 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26810 bool result;
26811 void *argp1 = 0 ;
26812 int res1 = 0 ;
26813 int val2 ;
26814 int ecode2 = 0 ;
26815 PyObject * obj0 = 0 ;
26816 PyObject * obj1 = 0 ;
26817 char * kwnames[] = {
26818 (char *) "self",(char *) "country", NULL
26819 };
26820
26821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26823 if (!SWIG_IsOK(res1)) {
26824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26825 }
26826 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26827 if (obj1) {
26828 ecode2 = SWIG_AsVal_int(obj1, &val2);
26829 if (!SWIG_IsOK(ecode2)) {
26830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26831 }
26832 arg2 = static_cast< wxDateTime::Country >(val2);
26833 }
26834 {
26835 PyThreadState* __tstate = wxPyBeginAllowThreads();
26836 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26837 wxPyEndAllowThreads(__tstate);
26838 if (PyErr_Occurred()) SWIG_fail;
26839 }
26840 {
26841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26842 }
26843 return resultobj;
26844 fail:
26845 return NULL;
26846 }
26847
26848
26849 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26850 PyObject *resultobj = 0;
26851 wxDateTime *arg1 = (wxDateTime *) 0 ;
26852 wxDateTime *arg2 = 0 ;
26853 bool result;
26854 void *argp1 = 0 ;
26855 int res1 = 0 ;
26856 void *argp2 = 0 ;
26857 int res2 = 0 ;
26858 PyObject * obj0 = 0 ;
26859 PyObject * obj1 = 0 ;
26860 char * kwnames[] = {
26861 (char *) "self",(char *) "datetime", NULL
26862 };
26863
26864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26866 if (!SWIG_IsOK(res1)) {
26867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26868 }
26869 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26870 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26871 if (!SWIG_IsOK(res2)) {
26872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26873 }
26874 if (!argp2) {
26875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26876 }
26877 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26881 wxPyEndAllowThreads(__tstate);
26882 if (PyErr_Occurred()) SWIG_fail;
26883 }
26884 {
26885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26886 }
26887 return resultobj;
26888 fail:
26889 return NULL;
26890 }
26891
26892
26893 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26894 PyObject *resultobj = 0;
26895 wxDateTime *arg1 = (wxDateTime *) 0 ;
26896 wxDateTime *arg2 = 0 ;
26897 bool result;
26898 void *argp1 = 0 ;
26899 int res1 = 0 ;
26900 void *argp2 = 0 ;
26901 int res2 = 0 ;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 char * kwnames[] = {
26905 (char *) "self",(char *) "datetime", NULL
26906 };
26907
26908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26910 if (!SWIG_IsOK(res1)) {
26911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26912 }
26913 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26914 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26915 if (!SWIG_IsOK(res2)) {
26916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26917 }
26918 if (!argp2) {
26919 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26920 }
26921 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26922 {
26923 PyThreadState* __tstate = wxPyBeginAllowThreads();
26924 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26925 wxPyEndAllowThreads(__tstate);
26926 if (PyErr_Occurred()) SWIG_fail;
26927 }
26928 {
26929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26930 }
26931 return resultobj;
26932 fail:
26933 return NULL;
26934 }
26935
26936
26937 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26938 PyObject *resultobj = 0;
26939 wxDateTime *arg1 = (wxDateTime *) 0 ;
26940 wxDateTime *arg2 = 0 ;
26941 bool result;
26942 void *argp1 = 0 ;
26943 int res1 = 0 ;
26944 void *argp2 = 0 ;
26945 int res2 = 0 ;
26946 PyObject * obj0 = 0 ;
26947 PyObject * obj1 = 0 ;
26948 char * kwnames[] = {
26949 (char *) "self",(char *) "datetime", NULL
26950 };
26951
26952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26954 if (!SWIG_IsOK(res1)) {
26955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26956 }
26957 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26958 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26959 if (!SWIG_IsOK(res2)) {
26960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26961 }
26962 if (!argp2) {
26963 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26964 }
26965 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 {
26973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26974 }
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj = 0;
26983 wxDateTime *arg1 = (wxDateTime *) 0 ;
26984 wxDateTime *arg2 = 0 ;
26985 wxDateTime *arg3 = 0 ;
26986 bool result;
26987 void *argp1 = 0 ;
26988 int res1 = 0 ;
26989 void *argp2 = 0 ;
26990 int res2 = 0 ;
26991 void *argp3 = 0 ;
26992 int res3 = 0 ;
26993 PyObject * obj0 = 0 ;
26994 PyObject * obj1 = 0 ;
26995 PyObject * obj2 = 0 ;
26996 char * kwnames[] = {
26997 (char *) "self",(char *) "t1",(char *) "t2", NULL
26998 };
26999
27000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27002 if (!SWIG_IsOK(res1)) {
27003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27004 }
27005 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27006 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27007 if (!SWIG_IsOK(res2)) {
27008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27009 }
27010 if (!argp2) {
27011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27012 }
27013 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27014 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27015 if (!SWIG_IsOK(res3)) {
27016 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27017 }
27018 if (!argp3) {
27019 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27020 }
27021 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 {
27029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27030 }
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27038 PyObject *resultobj = 0;
27039 wxDateTime *arg1 = (wxDateTime *) 0 ;
27040 wxDateTime *arg2 = 0 ;
27041 wxDateTime *arg3 = 0 ;
27042 bool result;
27043 void *argp1 = 0 ;
27044 int res1 = 0 ;
27045 void *argp2 = 0 ;
27046 int res2 = 0 ;
27047 void *argp3 = 0 ;
27048 int res3 = 0 ;
27049 PyObject * obj0 = 0 ;
27050 PyObject * obj1 = 0 ;
27051 PyObject * obj2 = 0 ;
27052 char * kwnames[] = {
27053 (char *) "self",(char *) "t1",(char *) "t2", NULL
27054 };
27055
27056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27058 if (!SWIG_IsOK(res1)) {
27059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27060 }
27061 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27062 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27063 if (!SWIG_IsOK(res2)) {
27064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27065 }
27066 if (!argp2) {
27067 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27068 }
27069 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27070 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27071 if (!SWIG_IsOK(res3)) {
27072 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27073 }
27074 if (!argp3) {
27075 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27076 }
27077 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 {
27085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27086 }
27087 return resultobj;
27088 fail:
27089 return NULL;
27090 }
27091
27092
27093 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj = 0;
27095 wxDateTime *arg1 = (wxDateTime *) 0 ;
27096 wxDateTime *arg2 = 0 ;
27097 bool result;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 void *argp2 = 0 ;
27101 int res2 = 0 ;
27102 PyObject * obj0 = 0 ;
27103 PyObject * obj1 = 0 ;
27104 char * kwnames[] = {
27105 (char *) "self",(char *) "dt", NULL
27106 };
27107
27108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27110 if (!SWIG_IsOK(res1)) {
27111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27112 }
27113 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27115 if (!SWIG_IsOK(res2)) {
27116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27117 }
27118 if (!argp2) {
27119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27120 }
27121 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 {
27129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27130 }
27131 return resultobj;
27132 fail:
27133 return NULL;
27134 }
27135
27136
27137 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27138 PyObject *resultobj = 0;
27139 wxDateTime *arg1 = (wxDateTime *) 0 ;
27140 wxDateTime *arg2 = 0 ;
27141 bool result;
27142 void *argp1 = 0 ;
27143 int res1 = 0 ;
27144 void *argp2 = 0 ;
27145 int res2 = 0 ;
27146 PyObject * obj0 = 0 ;
27147 PyObject * obj1 = 0 ;
27148 char * kwnames[] = {
27149 (char *) "self",(char *) "dt", NULL
27150 };
27151
27152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27154 if (!SWIG_IsOK(res1)) {
27155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27156 }
27157 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27158 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27159 if (!SWIG_IsOK(res2)) {
27160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27161 }
27162 if (!argp2) {
27163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27164 }
27165 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27166 {
27167 PyThreadState* __tstate = wxPyBeginAllowThreads();
27168 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27169 wxPyEndAllowThreads(__tstate);
27170 if (PyErr_Occurred()) SWIG_fail;
27171 }
27172 {
27173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27174 }
27175 return resultobj;
27176 fail:
27177 return NULL;
27178 }
27179
27180
27181 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27182 PyObject *resultobj = 0;
27183 wxDateTime *arg1 = (wxDateTime *) 0 ;
27184 wxDateTime *arg2 = 0 ;
27185 wxTimeSpan *arg3 = 0 ;
27186 bool result;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 void *argp2 = 0 ;
27190 int res2 = 0 ;
27191 void *argp3 = 0 ;
27192 int res3 = 0 ;
27193 PyObject * obj0 = 0 ;
27194 PyObject * obj1 = 0 ;
27195 PyObject * obj2 = 0 ;
27196 char * kwnames[] = {
27197 (char *) "self",(char *) "dt",(char *) "ts", NULL
27198 };
27199
27200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27202 if (!SWIG_IsOK(res1)) {
27203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27204 }
27205 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27206 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27207 if (!SWIG_IsOK(res2)) {
27208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27209 }
27210 if (!argp2) {
27211 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27212 }
27213 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27214 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27215 if (!SWIG_IsOK(res3)) {
27216 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27217 }
27218 if (!argp3) {
27219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27220 }
27221 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 {
27229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27230 }
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj = 0;
27239 wxDateTime *arg1 = (wxDateTime *) 0 ;
27240 wxTimeSpan *arg2 = 0 ;
27241 wxDateTime *result = 0 ;
27242 void *argp1 = 0 ;
27243 int res1 = 0 ;
27244 void *argp2 = 0 ;
27245 int res2 = 0 ;
27246 PyObject * obj0 = 0 ;
27247 PyObject * obj1 = 0 ;
27248 char * kwnames[] = {
27249 (char *) "self",(char *) "diff", NULL
27250 };
27251
27252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27254 if (!SWIG_IsOK(res1)) {
27255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27256 }
27257 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27258 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27259 if (!SWIG_IsOK(res2)) {
27260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27261 }
27262 if (!argp2) {
27263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27264 }
27265 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 {
27269 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27270 result = (wxDateTime *) &_result_ref;
27271 }
27272 wxPyEndAllowThreads(__tstate);
27273 if (PyErr_Occurred()) SWIG_fail;
27274 }
27275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27276 return resultobj;
27277 fail:
27278 return NULL;
27279 }
27280
27281
27282 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27283 PyObject *resultobj = 0;
27284 wxDateTime *arg1 = (wxDateTime *) 0 ;
27285 wxDateSpan *arg2 = 0 ;
27286 wxDateTime *result = 0 ;
27287 void *argp1 = 0 ;
27288 int res1 = 0 ;
27289 void *argp2 = 0 ;
27290 int res2 = 0 ;
27291 PyObject * obj0 = 0 ;
27292 PyObject * obj1 = 0 ;
27293 char * kwnames[] = {
27294 (char *) "self",(char *) "diff", NULL
27295 };
27296
27297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27299 if (!SWIG_IsOK(res1)) {
27300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27301 }
27302 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27303 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27304 if (!SWIG_IsOK(res2)) {
27305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27306 }
27307 if (!argp2) {
27308 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27309 }
27310 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 {
27314 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27315 result = (wxDateTime *) &_result_ref;
27316 }
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27321 return resultobj;
27322 fail:
27323 return NULL;
27324 }
27325
27326
27327 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27328 PyObject *resultobj = 0;
27329 wxDateTime *arg1 = (wxDateTime *) 0 ;
27330 wxTimeSpan *arg2 = 0 ;
27331 wxDateTime *result = 0 ;
27332 void *argp1 = 0 ;
27333 int res1 = 0 ;
27334 void *argp2 = 0 ;
27335 int res2 = 0 ;
27336 PyObject * obj0 = 0 ;
27337 PyObject * obj1 = 0 ;
27338 char * kwnames[] = {
27339 (char *) "self",(char *) "diff", NULL
27340 };
27341
27342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27344 if (!SWIG_IsOK(res1)) {
27345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27346 }
27347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27349 if (!SWIG_IsOK(res2)) {
27350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27351 }
27352 if (!argp2) {
27353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27354 }
27355 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27356 {
27357 PyThreadState* __tstate = wxPyBeginAllowThreads();
27358 {
27359 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27360 result = (wxDateTime *) &_result_ref;
27361 }
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27366 return resultobj;
27367 fail:
27368 return NULL;
27369 }
27370
27371
27372 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27373 PyObject *resultobj = 0;
27374 wxDateTime *arg1 = (wxDateTime *) 0 ;
27375 wxDateSpan *arg2 = 0 ;
27376 wxDateTime *result = 0 ;
27377 void *argp1 = 0 ;
27378 int res1 = 0 ;
27379 void *argp2 = 0 ;
27380 int res2 = 0 ;
27381 PyObject * obj0 = 0 ;
27382 PyObject * obj1 = 0 ;
27383 char * kwnames[] = {
27384 (char *) "self",(char *) "diff", NULL
27385 };
27386
27387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27389 if (!SWIG_IsOK(res1)) {
27390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27391 }
27392 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27393 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27394 if (!SWIG_IsOK(res2)) {
27395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27396 }
27397 if (!argp2) {
27398 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27399 }
27400 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27401 {
27402 PyThreadState* __tstate = wxPyBeginAllowThreads();
27403 {
27404 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27405 result = (wxDateTime *) &_result_ref;
27406 }
27407 wxPyEndAllowThreads(__tstate);
27408 if (PyErr_Occurred()) SWIG_fail;
27409 }
27410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27418 PyObject *resultobj = 0;
27419 wxDateTime *arg1 = (wxDateTime *) 0 ;
27420 wxDateTime *arg2 = 0 ;
27421 wxTimeSpan result;
27422 void *argp1 = 0 ;
27423 int res1 = 0 ;
27424 void *argp2 = 0 ;
27425 int res2 = 0 ;
27426 PyObject * obj0 = 0 ;
27427 PyObject * obj1 = 0 ;
27428 char * kwnames[] = {
27429 (char *) "self",(char *) "dt", NULL
27430 };
27431
27432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27434 if (!SWIG_IsOK(res1)) {
27435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27436 }
27437 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27439 if (!SWIG_IsOK(res2)) {
27440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27441 }
27442 if (!argp2) {
27443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27444 }
27445 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27460 PyObject *resultobj = 0;
27461 wxDateTime *arg1 = (wxDateTime *) 0 ;
27462 wxTimeSpan *arg2 = 0 ;
27463 wxDateTime *result = 0 ;
27464 void *argp1 = 0 ;
27465 int res1 = 0 ;
27466 void *argp2 = 0 ;
27467 int res2 = 0 ;
27468
27469 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27471 if (!SWIG_IsOK(res1)) {
27472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27473 }
27474 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27475 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27476 if (!SWIG_IsOK(res2)) {
27477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27478 }
27479 if (!argp2) {
27480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27481 }
27482 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 {
27486 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27487 result = (wxDateTime *) &_result_ref;
27488 }
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27493 return resultobj;
27494 fail:
27495 return NULL;
27496 }
27497
27498
27499 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27500 PyObject *resultobj = 0;
27501 wxDateTime *arg1 = (wxDateTime *) 0 ;
27502 wxDateSpan *arg2 = 0 ;
27503 wxDateTime *result = 0 ;
27504 void *argp1 = 0 ;
27505 int res1 = 0 ;
27506 void *argp2 = 0 ;
27507 int res2 = 0 ;
27508
27509 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27511 if (!SWIG_IsOK(res1)) {
27512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27513 }
27514 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27515 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27516 if (!SWIG_IsOK(res2)) {
27517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27518 }
27519 if (!argp2) {
27520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27521 }
27522 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 {
27526 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27527 result = (wxDateTime *) &_result_ref;
27528 }
27529 wxPyEndAllowThreads(__tstate);
27530 if (PyErr_Occurred()) SWIG_fail;
27531 }
27532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27533 return resultobj;
27534 fail:
27535 return NULL;
27536 }
27537
27538
27539 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27540 int argc;
27541 PyObject *argv[3];
27542
27543 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27544 --argc;
27545 if (argc == 2) {
27546 int _v = 0;
27547 {
27548 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27549 _v = SWIG_CheckState(res);
27550 }
27551 if (!_v) goto check_1;
27552 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27553 }
27554 check_1:
27555
27556 if (argc == 2) {
27557 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27558 }
27559
27560 fail:
27561 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27562 return NULL;
27563 }
27564
27565
27566 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27567 PyObject *resultobj = 0;
27568 wxDateTime *arg1 = (wxDateTime *) 0 ;
27569 wxTimeSpan *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___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27580 }
27581 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27582 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27583 if (!SWIG_IsOK(res2)) {
27584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27585 }
27586 if (!argp2) {
27587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27588 }
27589 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 {
27593 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan 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___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27607 PyObject *resultobj = 0;
27608 wxDateTime *arg1 = (wxDateTime *) 0 ;
27609 wxDateSpan *arg2 = 0 ;
27610 wxDateTime *result = 0 ;
27611 void *argp1 = 0 ;
27612 int res1 = 0 ;
27613 void *argp2 = 0 ;
27614 int res2 = 0 ;
27615
27616 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27618 if (!SWIG_IsOK(res1)) {
27619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27620 }
27621 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27622 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27623 if (!SWIG_IsOK(res2)) {
27624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27625 }
27626 if (!argp2) {
27627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27628 }
27629 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27630 {
27631 PyThreadState* __tstate = wxPyBeginAllowThreads();
27632 {
27633 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27634 result = (wxDateTime *) &_result_ref;
27635 }
27636 wxPyEndAllowThreads(__tstate);
27637 if (PyErr_Occurred()) SWIG_fail;
27638 }
27639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27640 return resultobj;
27641 fail:
27642 return NULL;
27643 }
27644
27645
27646 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27647 int argc;
27648 PyObject *argv[3];
27649
27650 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27651 --argc;
27652 if (argc == 2) {
27653 int _v = 0;
27654 {
27655 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27656 _v = SWIG_CheckState(res);
27657 }
27658 if (!_v) goto check_1;
27659 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27660 }
27661 check_1:
27662
27663 if (argc == 2) {
27664 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27665 }
27666
27667 fail:
27668 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27669 return NULL;
27670 }
27671
27672
27673 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27674 PyObject *resultobj = 0;
27675 wxDateTime *arg1 = (wxDateTime *) 0 ;
27676 wxTimeSpan *arg2 = 0 ;
27677 wxDateTime result;
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, 0 | 0 );
27685 if (!SWIG_IsOK(res1)) {
27686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27687 }
27688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27689 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27690 if (!SWIG_IsOK(res2)) {
27691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27692 }
27693 if (!argp2) {
27694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27695 }
27696 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27711 PyObject *resultobj = 0;
27712 wxDateTime *arg1 = (wxDateTime *) 0 ;
27713 wxDateSpan *arg2 = 0 ;
27714 wxDateTime result;
27715 void *argp1 = 0 ;
27716 int res1 = 0 ;
27717 void *argp2 = 0 ;
27718 int res2 = 0 ;
27719
27720 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27722 if (!SWIG_IsOK(res1)) {
27723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27724 }
27725 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27726 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27727 if (!SWIG_IsOK(res2)) {
27728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27729 }
27730 if (!argp2) {
27731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27732 }
27733 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27734 {
27735 PyThreadState* __tstate = wxPyBeginAllowThreads();
27736 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27737 wxPyEndAllowThreads(__tstate);
27738 if (PyErr_Occurred()) SWIG_fail;
27739 }
27740 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27741 return resultobj;
27742 fail:
27743 return NULL;
27744 }
27745
27746
27747 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27748 int argc;
27749 PyObject *argv[3];
27750
27751 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27752 --argc;
27753 if (argc == 2) {
27754 int _v = 0;
27755 {
27756 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27757 _v = SWIG_CheckState(res);
27758 }
27759 if (!_v) goto check_1;
27760 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27761 }
27762 check_1:
27763
27764 if (argc == 2) {
27765 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27766 }
27767
27768 fail:
27769 Py_INCREF(Py_NotImplemented);
27770 return Py_NotImplemented;
27771 }
27772
27773
27774 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27775 PyObject *resultobj = 0;
27776 wxDateTime *arg1 = (wxDateTime *) 0 ;
27777 wxDateTime *arg2 = 0 ;
27778 wxTimeSpan result;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 void *argp2 = 0 ;
27782 int res2 = 0 ;
27783
27784 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27786 if (!SWIG_IsOK(res1)) {
27787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27788 }
27789 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27790 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27791 if (!SWIG_IsOK(res2)) {
27792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27793 }
27794 if (!argp2) {
27795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27796 }
27797 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27798 {
27799 PyThreadState* __tstate = wxPyBeginAllowThreads();
27800 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27805 return resultobj;
27806 fail:
27807 return NULL;
27808 }
27809
27810
27811 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27812 PyObject *resultobj = 0;
27813 wxDateTime *arg1 = (wxDateTime *) 0 ;
27814 wxTimeSpan *arg2 = 0 ;
27815 wxDateTime result;
27816 void *argp1 = 0 ;
27817 int res1 = 0 ;
27818 void *argp2 = 0 ;
27819 int res2 = 0 ;
27820
27821 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27823 if (!SWIG_IsOK(res1)) {
27824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27825 }
27826 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27827 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27828 if (!SWIG_IsOK(res2)) {
27829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27830 }
27831 if (!argp2) {
27832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27833 }
27834 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27835 {
27836 PyThreadState* __tstate = wxPyBeginAllowThreads();
27837 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27838 wxPyEndAllowThreads(__tstate);
27839 if (PyErr_Occurred()) SWIG_fail;
27840 }
27841 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27842 return resultobj;
27843 fail:
27844 return NULL;
27845 }
27846
27847
27848 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27849 PyObject *resultobj = 0;
27850 wxDateTime *arg1 = (wxDateTime *) 0 ;
27851 wxDateSpan *arg2 = 0 ;
27852 wxDateTime result;
27853 void *argp1 = 0 ;
27854 int res1 = 0 ;
27855 void *argp2 = 0 ;
27856 int res2 = 0 ;
27857
27858 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27860 if (!SWIG_IsOK(res1)) {
27861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27862 }
27863 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27864 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27865 if (!SWIG_IsOK(res2)) {
27866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27867 }
27868 if (!argp2) {
27869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27870 }
27871 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27886 int argc;
27887 PyObject *argv[3];
27888
27889 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27890 --argc;
27891 if (argc == 2) {
27892 int _v = 0;
27893 {
27894 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27895 _v = SWIG_CheckState(res);
27896 }
27897 if (!_v) goto check_1;
27898 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27899 }
27900 check_1:
27901
27902 if (argc == 2) {
27903 int _v = 0;
27904 {
27905 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27906 _v = SWIG_CheckState(res);
27907 }
27908 if (!_v) goto check_2;
27909 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27910 }
27911 check_2:
27912
27913 if (argc == 2) {
27914 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27915 }
27916
27917 fail:
27918 Py_INCREF(Py_NotImplemented);
27919 return Py_NotImplemented;
27920 }
27921
27922
27923 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27924 PyObject *resultobj = 0;
27925 wxDateTime *arg1 = (wxDateTime *) 0 ;
27926 wxDateTime *arg2 = (wxDateTime *) 0 ;
27927 bool result;
27928 void *argp1 = 0 ;
27929 int res1 = 0 ;
27930 void *argp2 = 0 ;
27931 int res2 = 0 ;
27932 PyObject * obj0 = 0 ;
27933 PyObject * obj1 = 0 ;
27934 char * kwnames[] = {
27935 (char *) "self",(char *) "other", NULL
27936 };
27937
27938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27940 if (!SWIG_IsOK(res1)) {
27941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27942 }
27943 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27945 if (!SWIG_IsOK(res2)) {
27946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27947 }
27948 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27952 wxPyEndAllowThreads(__tstate);
27953 if (PyErr_Occurred()) SWIG_fail;
27954 }
27955 {
27956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27957 }
27958 return resultobj;
27959 fail:
27960 return NULL;
27961 }
27962
27963
27964 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27965 PyObject *resultobj = 0;
27966 wxDateTime *arg1 = (wxDateTime *) 0 ;
27967 wxDateTime *arg2 = (wxDateTime *) 0 ;
27968 bool result;
27969 void *argp1 = 0 ;
27970 int res1 = 0 ;
27971 void *argp2 = 0 ;
27972 int res2 = 0 ;
27973 PyObject * obj0 = 0 ;
27974 PyObject * obj1 = 0 ;
27975 char * kwnames[] = {
27976 (char *) "self",(char *) "other", NULL
27977 };
27978
27979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27981 if (!SWIG_IsOK(res1)) {
27982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27983 }
27984 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27986 if (!SWIG_IsOK(res2)) {
27987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27988 }
27989 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 {
27997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27998 }
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28006 PyObject *resultobj = 0;
28007 wxDateTime *arg1 = (wxDateTime *) 0 ;
28008 wxDateTime *arg2 = (wxDateTime *) 0 ;
28009 bool result;
28010 void *argp1 = 0 ;
28011 int res1 = 0 ;
28012 void *argp2 = 0 ;
28013 int res2 = 0 ;
28014 PyObject * obj0 = 0 ;
28015 PyObject * obj1 = 0 ;
28016 char * kwnames[] = {
28017 (char *) "self",(char *) "other", NULL
28018 };
28019
28020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28022 if (!SWIG_IsOK(res1)) {
28023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28024 }
28025 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28027 if (!SWIG_IsOK(res2)) {
28028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28029 }
28030 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28031 {
28032 PyThreadState* __tstate = wxPyBeginAllowThreads();
28033 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 {
28038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28039 }
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = 0;
28048 wxDateTime *arg1 = (wxDateTime *) 0 ;
28049 wxDateTime *arg2 = (wxDateTime *) 0 ;
28050 bool result;
28051 void *argp1 = 0 ;
28052 int res1 = 0 ;
28053 void *argp2 = 0 ;
28054 int res2 = 0 ;
28055 PyObject * obj0 = 0 ;
28056 PyObject * obj1 = 0 ;
28057 char * kwnames[] = {
28058 (char *) "self",(char *) "other", NULL
28059 };
28060
28061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28063 if (!SWIG_IsOK(res1)) {
28064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28065 }
28066 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28068 if (!SWIG_IsOK(res2)) {
28069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28070 }
28071 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28072 {
28073 PyThreadState* __tstate = wxPyBeginAllowThreads();
28074 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28075 wxPyEndAllowThreads(__tstate);
28076 if (PyErr_Occurred()) SWIG_fail;
28077 }
28078 {
28079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28080 }
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj = 0;
28089 wxDateTime *arg1 = (wxDateTime *) 0 ;
28090 wxDateTime *arg2 = (wxDateTime *) 0 ;
28091 bool result;
28092 void *argp1 = 0 ;
28093 int res1 = 0 ;
28094 void *argp2 = 0 ;
28095 int res2 = 0 ;
28096 PyObject * obj0 = 0 ;
28097 PyObject * obj1 = 0 ;
28098 char * kwnames[] = {
28099 (char *) "self",(char *) "other", NULL
28100 };
28101
28102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28104 if (!SWIG_IsOK(res1)) {
28105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28106 }
28107 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28109 if (!SWIG_IsOK(res2)) {
28110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28111 }
28112 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28113 {
28114 PyThreadState* __tstate = wxPyBeginAllowThreads();
28115 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28116 wxPyEndAllowThreads(__tstate);
28117 if (PyErr_Occurred()) SWIG_fail;
28118 }
28119 {
28120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28121 }
28122 return resultobj;
28123 fail:
28124 return NULL;
28125 }
28126
28127
28128 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28129 PyObject *resultobj = 0;
28130 wxDateTime *arg1 = (wxDateTime *) 0 ;
28131 wxDateTime *arg2 = (wxDateTime *) 0 ;
28132 bool result;
28133 void *argp1 = 0 ;
28134 int res1 = 0 ;
28135 void *argp2 = 0 ;
28136 int res2 = 0 ;
28137 PyObject * obj0 = 0 ;
28138 PyObject * obj1 = 0 ;
28139 char * kwnames[] = {
28140 (char *) "self",(char *) "other", NULL
28141 };
28142
28143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28145 if (!SWIG_IsOK(res1)) {
28146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28147 }
28148 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28150 if (!SWIG_IsOK(res2)) {
28151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28152 }
28153 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28157 wxPyEndAllowThreads(__tstate);
28158 if (PyErr_Occurred()) SWIG_fail;
28159 }
28160 {
28161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28162 }
28163 return resultobj;
28164 fail:
28165 return NULL;
28166 }
28167
28168
28169 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28170 PyObject *resultobj = 0;
28171 wxDateTime *arg1 = (wxDateTime *) 0 ;
28172 wxString *arg2 = 0 ;
28173 int result;
28174 void *argp1 = 0 ;
28175 int res1 = 0 ;
28176 bool temp2 = false ;
28177 PyObject * obj0 = 0 ;
28178 PyObject * obj1 = 0 ;
28179 char * kwnames[] = {
28180 (char *) "self",(char *) "date", NULL
28181 };
28182
28183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28185 if (!SWIG_IsOK(res1)) {
28186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28187 }
28188 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28189 {
28190 arg2 = wxString_in_helper(obj1);
28191 if (arg2 == NULL) SWIG_fail;
28192 temp2 = true;
28193 }
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28197 wxPyEndAllowThreads(__tstate);
28198 if (PyErr_Occurred()) SWIG_fail;
28199 }
28200 resultobj = SWIG_From_int(static_cast< int >(result));
28201 {
28202 if (temp2)
28203 delete arg2;
28204 }
28205 return resultobj;
28206 fail:
28207 {
28208 if (temp2)
28209 delete arg2;
28210 }
28211 return NULL;
28212 }
28213
28214
28215 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28216 PyObject *resultobj = 0;
28217 wxDateTime *arg1 = (wxDateTime *) 0 ;
28218 wxString *arg2 = 0 ;
28219 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28220 wxString *arg3 = (wxString *) &arg3_defvalue ;
28221 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28222 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28223 int result;
28224 void *argp1 = 0 ;
28225 int res1 = 0 ;
28226 bool temp2 = false ;
28227 bool temp3 = false ;
28228 void *argp4 = 0 ;
28229 int res4 = 0 ;
28230 PyObject * obj0 = 0 ;
28231 PyObject * obj1 = 0 ;
28232 PyObject * obj2 = 0 ;
28233 PyObject * obj3 = 0 ;
28234 char * kwnames[] = {
28235 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28236 };
28237
28238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28240 if (!SWIG_IsOK(res1)) {
28241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28242 }
28243 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28244 {
28245 arg2 = wxString_in_helper(obj1);
28246 if (arg2 == NULL) SWIG_fail;
28247 temp2 = true;
28248 }
28249 if (obj2) {
28250 {
28251 arg3 = wxString_in_helper(obj2);
28252 if (arg3 == NULL) SWIG_fail;
28253 temp3 = true;
28254 }
28255 }
28256 if (obj3) {
28257 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28258 if (!SWIG_IsOK(res4)) {
28259 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28260 }
28261 if (!argp4) {
28262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28263 }
28264 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28265 }
28266 {
28267 PyThreadState* __tstate = wxPyBeginAllowThreads();
28268 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28269 wxPyEndAllowThreads(__tstate);
28270 if (PyErr_Occurred()) SWIG_fail;
28271 }
28272 resultobj = SWIG_From_int(static_cast< int >(result));
28273 {
28274 if (temp2)
28275 delete arg2;
28276 }
28277 {
28278 if (temp3)
28279 delete arg3;
28280 }
28281 return resultobj;
28282 fail:
28283 {
28284 if (temp2)
28285 delete arg2;
28286 }
28287 {
28288 if (temp3)
28289 delete arg3;
28290 }
28291 return NULL;
28292 }
28293
28294
28295 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28296 PyObject *resultobj = 0;
28297 wxDateTime *arg1 = (wxDateTime *) 0 ;
28298 wxString *arg2 = 0 ;
28299 int result;
28300 void *argp1 = 0 ;
28301 int res1 = 0 ;
28302 bool temp2 = false ;
28303 PyObject * obj0 = 0 ;
28304 PyObject * obj1 = 0 ;
28305 char * kwnames[] = {
28306 (char *) "self",(char *) "datetime", NULL
28307 };
28308
28309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28311 if (!SWIG_IsOK(res1)) {
28312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28313 }
28314 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28315 {
28316 arg2 = wxString_in_helper(obj1);
28317 if (arg2 == NULL) SWIG_fail;
28318 temp2 = true;
28319 }
28320 {
28321 PyThreadState* __tstate = wxPyBeginAllowThreads();
28322 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28323 wxPyEndAllowThreads(__tstate);
28324 if (PyErr_Occurred()) SWIG_fail;
28325 }
28326 resultobj = SWIG_From_int(static_cast< int >(result));
28327 {
28328 if (temp2)
28329 delete arg2;
28330 }
28331 return resultobj;
28332 fail:
28333 {
28334 if (temp2)
28335 delete arg2;
28336 }
28337 return NULL;
28338 }
28339
28340
28341 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28342 PyObject *resultobj = 0;
28343 wxDateTime *arg1 = (wxDateTime *) 0 ;
28344 wxString *arg2 = 0 ;
28345 int result;
28346 void *argp1 = 0 ;
28347 int res1 = 0 ;
28348 bool temp2 = false ;
28349 PyObject * obj0 = 0 ;
28350 PyObject * obj1 = 0 ;
28351 char * kwnames[] = {
28352 (char *) "self",(char *) "date", NULL
28353 };
28354
28355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28357 if (!SWIG_IsOK(res1)) {
28358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28359 }
28360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28361 {
28362 arg2 = wxString_in_helper(obj1);
28363 if (arg2 == NULL) SWIG_fail;
28364 temp2 = true;
28365 }
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_From_int(static_cast< int >(result));
28373 {
28374 if (temp2)
28375 delete arg2;
28376 }
28377 return resultobj;
28378 fail:
28379 {
28380 if (temp2)
28381 delete arg2;
28382 }
28383 return NULL;
28384 }
28385
28386
28387 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28388 PyObject *resultobj = 0;
28389 wxDateTime *arg1 = (wxDateTime *) 0 ;
28390 wxString *arg2 = 0 ;
28391 int result;
28392 void *argp1 = 0 ;
28393 int res1 = 0 ;
28394 bool temp2 = false ;
28395 PyObject * obj0 = 0 ;
28396 PyObject * obj1 = 0 ;
28397 char * kwnames[] = {
28398 (char *) "self",(char *) "time", NULL
28399 };
28400
28401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28403 if (!SWIG_IsOK(res1)) {
28404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28405 }
28406 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28407 {
28408 arg2 = wxString_in_helper(obj1);
28409 if (arg2 == NULL) SWIG_fail;
28410 temp2 = true;
28411 }
28412 {
28413 PyThreadState* __tstate = wxPyBeginAllowThreads();
28414 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28415 wxPyEndAllowThreads(__tstate);
28416 if (PyErr_Occurred()) SWIG_fail;
28417 }
28418 resultobj = SWIG_From_int(static_cast< int >(result));
28419 {
28420 if (temp2)
28421 delete arg2;
28422 }
28423 return resultobj;
28424 fail:
28425 {
28426 if (temp2)
28427 delete arg2;
28428 }
28429 return NULL;
28430 }
28431
28432
28433 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj = 0;
28435 wxDateTime *arg1 = (wxDateTime *) 0 ;
28436 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28437 wxString *arg2 = (wxString *) &arg2_defvalue ;
28438 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28439 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28440 wxString result;
28441 void *argp1 = 0 ;
28442 int res1 = 0 ;
28443 bool temp2 = false ;
28444 bool temp3 = false ;
28445 PyObject * obj0 = 0 ;
28446 PyObject * obj1 = 0 ;
28447 PyObject * obj2 = 0 ;
28448 char * kwnames[] = {
28449 (char *) "self",(char *) "format",(char *) "tz", NULL
28450 };
28451
28452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28454 if (!SWIG_IsOK(res1)) {
28455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28456 }
28457 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28458 if (obj1) {
28459 {
28460 arg2 = wxString_in_helper(obj1);
28461 if (arg2 == NULL) SWIG_fail;
28462 temp2 = true;
28463 }
28464 }
28465 if (obj2) {
28466 {
28467 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28468 temp3 = true;
28469 }
28470 }
28471 {
28472 PyThreadState* __tstate = wxPyBeginAllowThreads();
28473 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 {
28478 #if wxUSE_UNICODE
28479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28480 #else
28481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28482 #endif
28483 }
28484 {
28485 if (temp2)
28486 delete arg2;
28487 }
28488 {
28489 if (temp3) delete arg3;
28490 }
28491 return resultobj;
28492 fail:
28493 {
28494 if (temp2)
28495 delete arg2;
28496 }
28497 {
28498 if (temp3) delete arg3;
28499 }
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *resultobj = 0;
28506 wxDateTime *arg1 = (wxDateTime *) 0 ;
28507 wxString result;
28508 void *argp1 = 0 ;
28509 int res1 = 0 ;
28510 PyObject *swig_obj[1] ;
28511
28512 if (!args) SWIG_fail;
28513 swig_obj[0] = args;
28514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28515 if (!SWIG_IsOK(res1)) {
28516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28517 }
28518 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28519 {
28520 PyThreadState* __tstate = wxPyBeginAllowThreads();
28521 result = ((wxDateTime const *)arg1)->FormatDate();
28522 wxPyEndAllowThreads(__tstate);
28523 if (PyErr_Occurred()) SWIG_fail;
28524 }
28525 {
28526 #if wxUSE_UNICODE
28527 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28528 #else
28529 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28530 #endif
28531 }
28532 return resultobj;
28533 fail:
28534 return NULL;
28535 }
28536
28537
28538 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28539 PyObject *resultobj = 0;
28540 wxDateTime *arg1 = (wxDateTime *) 0 ;
28541 wxString result;
28542 void *argp1 = 0 ;
28543 int res1 = 0 ;
28544 PyObject *swig_obj[1] ;
28545
28546 if (!args) SWIG_fail;
28547 swig_obj[0] = args;
28548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28549 if (!SWIG_IsOK(res1)) {
28550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28551 }
28552 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28553 {
28554 PyThreadState* __tstate = wxPyBeginAllowThreads();
28555 result = ((wxDateTime const *)arg1)->FormatTime();
28556 wxPyEndAllowThreads(__tstate);
28557 if (PyErr_Occurred()) SWIG_fail;
28558 }
28559 {
28560 #if wxUSE_UNICODE
28561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28562 #else
28563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28564 #endif
28565 }
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28573 PyObject *resultobj = 0;
28574 wxDateTime *arg1 = (wxDateTime *) 0 ;
28575 wxString result;
28576 void *argp1 = 0 ;
28577 int res1 = 0 ;
28578 PyObject *swig_obj[1] ;
28579
28580 if (!args) SWIG_fail;
28581 swig_obj[0] = args;
28582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28583 if (!SWIG_IsOK(res1)) {
28584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28585 }
28586 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 result = ((wxDateTime const *)arg1)->FormatISODate();
28590 wxPyEndAllowThreads(__tstate);
28591 if (PyErr_Occurred()) SWIG_fail;
28592 }
28593 {
28594 #if wxUSE_UNICODE
28595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28596 #else
28597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28598 #endif
28599 }
28600 return resultobj;
28601 fail:
28602 return NULL;
28603 }
28604
28605
28606 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28607 PyObject *resultobj = 0;
28608 wxDateTime *arg1 = (wxDateTime *) 0 ;
28609 wxString result;
28610 void *argp1 = 0 ;
28611 int res1 = 0 ;
28612 PyObject *swig_obj[1] ;
28613
28614 if (!args) SWIG_fail;
28615 swig_obj[0] = args;
28616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28617 if (!SWIG_IsOK(res1)) {
28618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28619 }
28620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28621 {
28622 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 result = ((wxDateTime const *)arg1)->FormatISOTime();
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 {
28628 #if wxUSE_UNICODE
28629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28630 #else
28631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28632 #endif
28633 }
28634 return resultobj;
28635 fail:
28636 return NULL;
28637 }
28638
28639
28640 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28641 PyObject *obj;
28642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28643 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28644 return SWIG_Py_Void();
28645 }
28646
28647 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 return SWIG_Python_InitShadowInstance(args);
28649 }
28650
28651 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28652 PyObject *resultobj = 0;
28653 long arg1 ;
28654 wxTimeSpan result;
28655 long val1 ;
28656 int ecode1 = 0 ;
28657 PyObject * obj0 = 0 ;
28658 char * kwnames[] = {
28659 (char *) "ms", NULL
28660 };
28661
28662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28663 ecode1 = SWIG_AsVal_long(obj0, &val1);
28664 if (!SWIG_IsOK(ecode1)) {
28665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28666 }
28667 arg1 = static_cast< long >(val1);
28668 {
28669 PyThreadState* __tstate = wxPyBeginAllowThreads();
28670 result = wxTimeSpan::Milliseconds(arg1);
28671 wxPyEndAllowThreads(__tstate);
28672 if (PyErr_Occurred()) SWIG_fail;
28673 }
28674 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28675 return resultobj;
28676 fail:
28677 return NULL;
28678 }
28679
28680
28681 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28682 PyObject *resultobj = 0;
28683 wxTimeSpan result;
28684
28685 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 result = wxTimeSpan::Millisecond();
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28700 PyObject *resultobj = 0;
28701 long arg1 ;
28702 wxTimeSpan result;
28703 long val1 ;
28704 int ecode1 = 0 ;
28705 PyObject * obj0 = 0 ;
28706 char * kwnames[] = {
28707 (char *) "sec", NULL
28708 };
28709
28710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28711 ecode1 = SWIG_AsVal_long(obj0, &val1);
28712 if (!SWIG_IsOK(ecode1)) {
28713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28714 }
28715 arg1 = static_cast< long >(val1);
28716 {
28717 PyThreadState* __tstate = wxPyBeginAllowThreads();
28718 result = wxTimeSpan::Seconds(arg1);
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28730 PyObject *resultobj = 0;
28731 wxTimeSpan result;
28732
28733 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = wxTimeSpan::Second();
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28741 return resultobj;
28742 fail:
28743 return NULL;
28744 }
28745
28746
28747 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28748 PyObject *resultobj = 0;
28749 long arg1 ;
28750 wxTimeSpan result;
28751 long val1 ;
28752 int ecode1 = 0 ;
28753 PyObject * obj0 = 0 ;
28754 char * kwnames[] = {
28755 (char *) "min", NULL
28756 };
28757
28758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28759 ecode1 = SWIG_AsVal_long(obj0, &val1);
28760 if (!SWIG_IsOK(ecode1)) {
28761 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28762 }
28763 arg1 = static_cast< long >(val1);
28764 {
28765 PyThreadState* __tstate = wxPyBeginAllowThreads();
28766 result = wxTimeSpan::Minutes(arg1);
28767 wxPyEndAllowThreads(__tstate);
28768 if (PyErr_Occurred()) SWIG_fail;
28769 }
28770 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28778 PyObject *resultobj = 0;
28779 wxTimeSpan result;
28780
28781 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = wxTimeSpan::Minute();
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28796 PyObject *resultobj = 0;
28797 long arg1 ;
28798 wxTimeSpan result;
28799 long val1 ;
28800 int ecode1 = 0 ;
28801 PyObject * obj0 = 0 ;
28802 char * kwnames[] = {
28803 (char *) "hours", NULL
28804 };
28805
28806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28807 ecode1 = SWIG_AsVal_long(obj0, &val1);
28808 if (!SWIG_IsOK(ecode1)) {
28809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28810 }
28811 arg1 = static_cast< long >(val1);
28812 {
28813 PyThreadState* __tstate = wxPyBeginAllowThreads();
28814 result = wxTimeSpan::Hours(arg1);
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28819 return resultobj;
28820 fail:
28821 return NULL;
28822 }
28823
28824
28825 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28826 PyObject *resultobj = 0;
28827 wxTimeSpan result;
28828
28829 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28830 {
28831 PyThreadState* __tstate = wxPyBeginAllowThreads();
28832 result = wxTimeSpan::Hour();
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj = 0;
28845 long arg1 ;
28846 wxTimeSpan result;
28847 long val1 ;
28848 int ecode1 = 0 ;
28849 PyObject * obj0 = 0 ;
28850 char * kwnames[] = {
28851 (char *) "days", NULL
28852 };
28853
28854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28855 ecode1 = SWIG_AsVal_long(obj0, &val1);
28856 if (!SWIG_IsOK(ecode1)) {
28857 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28858 }
28859 arg1 = static_cast< long >(val1);
28860 {
28861 PyThreadState* __tstate = wxPyBeginAllowThreads();
28862 result = wxTimeSpan::Days(arg1);
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28867 return resultobj;
28868 fail:
28869 return NULL;
28870 }
28871
28872
28873 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28874 PyObject *resultobj = 0;
28875 wxTimeSpan result;
28876
28877 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28878 {
28879 PyThreadState* __tstate = wxPyBeginAllowThreads();
28880 result = wxTimeSpan::Day();
28881 wxPyEndAllowThreads(__tstate);
28882 if (PyErr_Occurred()) SWIG_fail;
28883 }
28884 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28892 PyObject *resultobj = 0;
28893 long arg1 ;
28894 wxTimeSpan result;
28895 long val1 ;
28896 int ecode1 = 0 ;
28897 PyObject * obj0 = 0 ;
28898 char * kwnames[] = {
28899 (char *) "days", NULL
28900 };
28901
28902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28903 ecode1 = SWIG_AsVal_long(obj0, &val1);
28904 if (!SWIG_IsOK(ecode1)) {
28905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28906 }
28907 arg1 = static_cast< long >(val1);
28908 {
28909 PyThreadState* __tstate = wxPyBeginAllowThreads();
28910 result = wxTimeSpan::Weeks(arg1);
28911 wxPyEndAllowThreads(__tstate);
28912 if (PyErr_Occurred()) SWIG_fail;
28913 }
28914 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28915 return resultobj;
28916 fail:
28917 return NULL;
28918 }
28919
28920
28921 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28922 PyObject *resultobj = 0;
28923 wxTimeSpan result;
28924
28925 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = wxTimeSpan::Week();
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28940 PyObject *resultobj = 0;
28941 long arg1 = (long) 0 ;
28942 long arg2 = (long) 0 ;
28943 long arg3 = (long) 0 ;
28944 long arg4 = (long) 0 ;
28945 wxTimeSpan *result = 0 ;
28946 long val1 ;
28947 int ecode1 = 0 ;
28948 long val2 ;
28949 int ecode2 = 0 ;
28950 long val3 ;
28951 int ecode3 = 0 ;
28952 long val4 ;
28953 int ecode4 = 0 ;
28954 PyObject * obj0 = 0 ;
28955 PyObject * obj1 = 0 ;
28956 PyObject * obj2 = 0 ;
28957 PyObject * obj3 = 0 ;
28958 char * kwnames[] = {
28959 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28960 };
28961
28962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28963 if (obj0) {
28964 ecode1 = SWIG_AsVal_long(obj0, &val1);
28965 if (!SWIG_IsOK(ecode1)) {
28966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28967 }
28968 arg1 = static_cast< long >(val1);
28969 }
28970 if (obj1) {
28971 ecode2 = SWIG_AsVal_long(obj1, &val2);
28972 if (!SWIG_IsOK(ecode2)) {
28973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28974 }
28975 arg2 = static_cast< long >(val2);
28976 }
28977 if (obj2) {
28978 ecode3 = SWIG_AsVal_long(obj2, &val3);
28979 if (!SWIG_IsOK(ecode3)) {
28980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28981 }
28982 arg3 = static_cast< long >(val3);
28983 }
28984 if (obj3) {
28985 ecode4 = SWIG_AsVal_long(obj3, &val4);
28986 if (!SWIG_IsOK(ecode4)) {
28987 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28988 }
28989 arg4 = static_cast< long >(val4);
28990 }
28991 {
28992 PyThreadState* __tstate = wxPyBeginAllowThreads();
28993 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28994 wxPyEndAllowThreads(__tstate);
28995 if (PyErr_Occurred()) SWIG_fail;
28996 }
28997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28998 return resultobj;
28999 fail:
29000 return NULL;
29001 }
29002
29003
29004 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29005 PyObject *resultobj = 0;
29006 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29007 void *argp1 = 0 ;
29008 int res1 = 0 ;
29009 PyObject *swig_obj[1] ;
29010
29011 if (!args) SWIG_fail;
29012 swig_obj[0] = args;
29013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29014 if (!SWIG_IsOK(res1)) {
29015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29016 }
29017 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29018 {
29019 PyThreadState* __tstate = wxPyBeginAllowThreads();
29020 delete arg1;
29021
29022 wxPyEndAllowThreads(__tstate);
29023 if (PyErr_Occurred()) SWIG_fail;
29024 }
29025 resultobj = SWIG_Py_Void();
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj = 0;
29034 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29035 wxTimeSpan *arg2 = 0 ;
29036 wxTimeSpan *result = 0 ;
29037 void *argp1 = 0 ;
29038 int res1 = 0 ;
29039 void *argp2 = 0 ;
29040 int res2 = 0 ;
29041 PyObject * obj0 = 0 ;
29042 PyObject * obj1 = 0 ;
29043 char * kwnames[] = {
29044 (char *) "self",(char *) "diff", NULL
29045 };
29046
29047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29051 }
29052 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29054 if (!SWIG_IsOK(res2)) {
29055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29056 }
29057 if (!argp2) {
29058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29059 }
29060 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29061 {
29062 PyThreadState* __tstate = wxPyBeginAllowThreads();
29063 {
29064 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29065 result = (wxTimeSpan *) &_result_ref;
29066 }
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj = 0;
29079 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29080 wxTimeSpan *arg2 = 0 ;
29081 wxTimeSpan *result = 0 ;
29082 void *argp1 = 0 ;
29083 int res1 = 0 ;
29084 void *argp2 = 0 ;
29085 int res2 = 0 ;
29086 PyObject * obj0 = 0 ;
29087 PyObject * obj1 = 0 ;
29088 char * kwnames[] = {
29089 (char *) "self",(char *) "diff", NULL
29090 };
29091
29092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29096 }
29097 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29099 if (!SWIG_IsOK(res2)) {
29100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29101 }
29102 if (!argp2) {
29103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29104 }
29105 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 {
29109 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29110 result = (wxTimeSpan *) &_result_ref;
29111 }
29112 wxPyEndAllowThreads(__tstate);
29113 if (PyErr_Occurred()) SWIG_fail;
29114 }
29115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29116 return resultobj;
29117 fail:
29118 return NULL;
29119 }
29120
29121
29122 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29123 PyObject *resultobj = 0;
29124 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29125 int arg2 ;
29126 wxTimeSpan *result = 0 ;
29127 void *argp1 = 0 ;
29128 int res1 = 0 ;
29129 int val2 ;
29130 int ecode2 = 0 ;
29131 PyObject * obj0 = 0 ;
29132 PyObject * obj1 = 0 ;
29133 char * kwnames[] = {
29134 (char *) "self",(char *) "n", NULL
29135 };
29136
29137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29139 if (!SWIG_IsOK(res1)) {
29140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29141 }
29142 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29143 ecode2 = SWIG_AsVal_int(obj1, &val2);
29144 if (!SWIG_IsOK(ecode2)) {
29145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29146 }
29147 arg2 = static_cast< int >(val2);
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 {
29151 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29152 result = (wxTimeSpan *) &_result_ref;
29153 }
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29165 PyObject *resultobj = 0;
29166 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29167 wxTimeSpan *result = 0 ;
29168 void *argp1 = 0 ;
29169 int res1 = 0 ;
29170 PyObject *swig_obj[1] ;
29171
29172 if (!args) SWIG_fail;
29173 swig_obj[0] = args;
29174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29175 if (!SWIG_IsOK(res1)) {
29176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29177 }
29178 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 {
29182 wxTimeSpan &_result_ref = (arg1)->Neg();
29183 result = (wxTimeSpan *) &_result_ref;
29184 }
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29196 PyObject *resultobj = 0;
29197 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29198 wxTimeSpan result;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 PyObject *swig_obj[1] ;
29202
29203 if (!args) SWIG_fail;
29204 swig_obj[0] = args;
29205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29206 if (!SWIG_IsOK(res1)) {
29207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29208 }
29209 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29210 {
29211 PyThreadState* __tstate = wxPyBeginAllowThreads();
29212 result = ((wxTimeSpan const *)arg1)->Abs();
29213 wxPyEndAllowThreads(__tstate);
29214 if (PyErr_Occurred()) SWIG_fail;
29215 }
29216 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29224 PyObject *resultobj = 0;
29225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29226 wxTimeSpan *arg2 = 0 ;
29227 wxTimeSpan *result = 0 ;
29228 void *argp1 = 0 ;
29229 int res1 = 0 ;
29230 void *argp2 = 0 ;
29231 int res2 = 0 ;
29232 PyObject * obj0 = 0 ;
29233 PyObject * obj1 = 0 ;
29234 char * kwnames[] = {
29235 (char *) "self",(char *) "diff", NULL
29236 };
29237
29238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29240 if (!SWIG_IsOK(res1)) {
29241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29242 }
29243 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29245 if (!SWIG_IsOK(res2)) {
29246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29247 }
29248 if (!argp2) {
29249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29250 }
29251 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29252 {
29253 PyThreadState* __tstate = wxPyBeginAllowThreads();
29254 {
29255 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29256 result = (wxTimeSpan *) &_result_ref;
29257 }
29258 wxPyEndAllowThreads(__tstate);
29259 if (PyErr_Occurred()) SWIG_fail;
29260 }
29261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29262 return resultobj;
29263 fail:
29264 return NULL;
29265 }
29266
29267
29268 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29269 PyObject *resultobj = 0;
29270 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29271 wxTimeSpan *arg2 = 0 ;
29272 wxTimeSpan *result = 0 ;
29273 void *argp1 = 0 ;
29274 int res1 = 0 ;
29275 void *argp2 = 0 ;
29276 int res2 = 0 ;
29277 PyObject * obj0 = 0 ;
29278 PyObject * obj1 = 0 ;
29279 char * kwnames[] = {
29280 (char *) "self",(char *) "diff", NULL
29281 };
29282
29283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29285 if (!SWIG_IsOK(res1)) {
29286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29287 }
29288 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29289 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29290 if (!SWIG_IsOK(res2)) {
29291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29292 }
29293 if (!argp2) {
29294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29295 }
29296 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29297 {
29298 PyThreadState* __tstate = wxPyBeginAllowThreads();
29299 {
29300 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29301 result = (wxTimeSpan *) &_result_ref;
29302 }
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29314 PyObject *resultobj = 0;
29315 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29316 int arg2 ;
29317 wxTimeSpan *result = 0 ;
29318 void *argp1 = 0 ;
29319 int res1 = 0 ;
29320 int val2 ;
29321 int ecode2 = 0 ;
29322 PyObject * obj0 = 0 ;
29323 PyObject * obj1 = 0 ;
29324 char * kwnames[] = {
29325 (char *) "self",(char *) "n", NULL
29326 };
29327
29328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29330 if (!SWIG_IsOK(res1)) {
29331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29332 }
29333 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29334 ecode2 = SWIG_AsVal_int(obj1, &val2);
29335 if (!SWIG_IsOK(ecode2)) {
29336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29337 }
29338 arg2 = static_cast< int >(val2);
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 {
29342 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29343 result = (wxTimeSpan *) &_result_ref;
29344 }
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29356 PyObject *resultobj = 0;
29357 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29358 wxTimeSpan *result = 0 ;
29359 void *argp1 = 0 ;
29360 int res1 = 0 ;
29361 PyObject *swig_obj[1] ;
29362
29363 if (!args) SWIG_fail;
29364 swig_obj[0] = args;
29365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29366 if (!SWIG_IsOK(res1)) {
29367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29368 }
29369 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29370 {
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 {
29373 wxTimeSpan &_result_ref = (arg1)->operator -();
29374 result = (wxTimeSpan *) &_result_ref;
29375 }
29376 wxPyEndAllowThreads(__tstate);
29377 if (PyErr_Occurred()) SWIG_fail;
29378 }
29379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29387 PyObject *resultobj = 0;
29388 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29389 wxTimeSpan *arg2 = 0 ;
29390 wxTimeSpan result;
29391 void *argp1 = 0 ;
29392 int res1 = 0 ;
29393 void *argp2 = 0 ;
29394 int res2 = 0 ;
29395 PyObject * obj0 = 0 ;
29396 PyObject * obj1 = 0 ;
29397 char * kwnames[] = {
29398 (char *) "self",(char *) "other", NULL
29399 };
29400
29401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29403 if (!SWIG_IsOK(res1)) {
29404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29405 }
29406 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29407 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29408 if (!SWIG_IsOK(res2)) {
29409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29410 }
29411 if (!argp2) {
29412 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29413 }
29414 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29429 PyObject *resultobj = 0;
29430 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29431 wxTimeSpan *arg2 = 0 ;
29432 wxTimeSpan result;
29433 void *argp1 = 0 ;
29434 int res1 = 0 ;
29435 void *argp2 = 0 ;
29436 int res2 = 0 ;
29437 PyObject * obj0 = 0 ;
29438 PyObject * obj1 = 0 ;
29439 char * kwnames[] = {
29440 (char *) "self",(char *) "other", NULL
29441 };
29442
29443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29445 if (!SWIG_IsOK(res1)) {
29446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29447 }
29448 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29449 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29450 if (!SWIG_IsOK(res2)) {
29451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29452 }
29453 if (!argp2) {
29454 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29455 }
29456 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29457 {
29458 PyThreadState* __tstate = wxPyBeginAllowThreads();
29459 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29464 return resultobj;
29465 fail:
29466 return NULL;
29467 }
29468
29469
29470 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29471 PyObject *resultobj = 0;
29472 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29473 int arg2 ;
29474 wxTimeSpan result;
29475 void *argp1 = 0 ;
29476 int res1 = 0 ;
29477 int val2 ;
29478 int ecode2 = 0 ;
29479 PyObject * obj0 = 0 ;
29480 PyObject * obj1 = 0 ;
29481 char * kwnames[] = {
29482 (char *) "self",(char *) "n", NULL
29483 };
29484
29485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29487 if (!SWIG_IsOK(res1)) {
29488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29489 }
29490 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29491 ecode2 = SWIG_AsVal_int(obj1, &val2);
29492 if (!SWIG_IsOK(ecode2)) {
29493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29494 }
29495 arg2 = static_cast< int >(val2);
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 result = wxTimeSpan___mul__(arg1,arg2);
29499 wxPyEndAllowThreads(__tstate);
29500 if (PyErr_Occurred()) SWIG_fail;
29501 }
29502 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29510 PyObject *resultobj = 0;
29511 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29512 int arg2 ;
29513 wxTimeSpan result;
29514 void *argp1 = 0 ;
29515 int res1 = 0 ;
29516 int val2 ;
29517 int ecode2 = 0 ;
29518 PyObject * obj0 = 0 ;
29519 PyObject * obj1 = 0 ;
29520 char * kwnames[] = {
29521 (char *) "self",(char *) "n", NULL
29522 };
29523
29524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29526 if (!SWIG_IsOK(res1)) {
29527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29528 }
29529 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29530 ecode2 = SWIG_AsVal_int(obj1, &val2);
29531 if (!SWIG_IsOK(ecode2)) {
29532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29533 }
29534 arg2 = static_cast< int >(val2);
29535 {
29536 PyThreadState* __tstate = wxPyBeginAllowThreads();
29537 result = wxTimeSpan___rmul__(arg1,arg2);
29538 wxPyEndAllowThreads(__tstate);
29539 if (PyErr_Occurred()) SWIG_fail;
29540 }
29541 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29549 PyObject *resultobj = 0;
29550 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29551 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29552 bool result;
29553 void *argp1 = 0 ;
29554 int res1 = 0 ;
29555 void *argp2 = 0 ;
29556 int res2 = 0 ;
29557 PyObject * obj0 = 0 ;
29558 PyObject * obj1 = 0 ;
29559 char * kwnames[] = {
29560 (char *) "self",(char *) "other", NULL
29561 };
29562
29563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29565 if (!SWIG_IsOK(res1)) {
29566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29567 }
29568 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29570 if (!SWIG_IsOK(res2)) {
29571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29572 }
29573 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 {
29581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29582 }
29583 return resultobj;
29584 fail:
29585 return NULL;
29586 }
29587
29588
29589 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj = 0;
29591 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29592 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29593 bool result;
29594 void *argp1 = 0 ;
29595 int res1 = 0 ;
29596 void *argp2 = 0 ;
29597 int res2 = 0 ;
29598 PyObject * obj0 = 0 ;
29599 PyObject * obj1 = 0 ;
29600 char * kwnames[] = {
29601 (char *) "self",(char *) "other", NULL
29602 };
29603
29604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29606 if (!SWIG_IsOK(res1)) {
29607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29608 }
29609 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29611 if (!SWIG_IsOK(res2)) {
29612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29613 }
29614 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29618 wxPyEndAllowThreads(__tstate);
29619 if (PyErr_Occurred()) SWIG_fail;
29620 }
29621 {
29622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29623 }
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj = 0;
29632 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29633 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29634 bool result;
29635 void *argp1 = 0 ;
29636 int res1 = 0 ;
29637 void *argp2 = 0 ;
29638 int res2 = 0 ;
29639 PyObject * obj0 = 0 ;
29640 PyObject * obj1 = 0 ;
29641 char * kwnames[] = {
29642 (char *) "self",(char *) "other", NULL
29643 };
29644
29645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29647 if (!SWIG_IsOK(res1)) {
29648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29649 }
29650 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29652 if (!SWIG_IsOK(res2)) {
29653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29654 }
29655 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29656 {
29657 PyThreadState* __tstate = wxPyBeginAllowThreads();
29658 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29659 wxPyEndAllowThreads(__tstate);
29660 if (PyErr_Occurred()) SWIG_fail;
29661 }
29662 {
29663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29664 }
29665 return resultobj;
29666 fail:
29667 return NULL;
29668 }
29669
29670
29671 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29672 PyObject *resultobj = 0;
29673 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29674 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29675 bool result;
29676 void *argp1 = 0 ;
29677 int res1 = 0 ;
29678 void *argp2 = 0 ;
29679 int res2 = 0 ;
29680 PyObject * obj0 = 0 ;
29681 PyObject * obj1 = 0 ;
29682 char * kwnames[] = {
29683 (char *) "self",(char *) "other", NULL
29684 };
29685
29686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29688 if (!SWIG_IsOK(res1)) {
29689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29690 }
29691 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29692 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29693 if (!SWIG_IsOK(res2)) {
29694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29695 }
29696 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29697 {
29698 PyThreadState* __tstate = wxPyBeginAllowThreads();
29699 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 {
29704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29705 }
29706 return resultobj;
29707 fail:
29708 return NULL;
29709 }
29710
29711
29712 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29713 PyObject *resultobj = 0;
29714 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29715 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29716 bool result;
29717 void *argp1 = 0 ;
29718 int res1 = 0 ;
29719 void *argp2 = 0 ;
29720 int res2 = 0 ;
29721 PyObject * obj0 = 0 ;
29722 PyObject * obj1 = 0 ;
29723 char * kwnames[] = {
29724 (char *) "self",(char *) "other", NULL
29725 };
29726
29727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29729 if (!SWIG_IsOK(res1)) {
29730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29731 }
29732 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29734 if (!SWIG_IsOK(res2)) {
29735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29736 }
29737 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29738 {
29739 PyThreadState* __tstate = wxPyBeginAllowThreads();
29740 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29741 wxPyEndAllowThreads(__tstate);
29742 if (PyErr_Occurred()) SWIG_fail;
29743 }
29744 {
29745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29746 }
29747 return resultobj;
29748 fail:
29749 return NULL;
29750 }
29751
29752
29753 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29754 PyObject *resultobj = 0;
29755 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29756 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29757 bool result;
29758 void *argp1 = 0 ;
29759 int res1 = 0 ;
29760 void *argp2 = 0 ;
29761 int res2 = 0 ;
29762 PyObject * obj0 = 0 ;
29763 PyObject * obj1 = 0 ;
29764 char * kwnames[] = {
29765 (char *) "self",(char *) "other", NULL
29766 };
29767
29768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29770 if (!SWIG_IsOK(res1)) {
29771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29772 }
29773 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29775 if (!SWIG_IsOK(res2)) {
29776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29777 }
29778 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29779 {
29780 PyThreadState* __tstate = wxPyBeginAllowThreads();
29781 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29782 wxPyEndAllowThreads(__tstate);
29783 if (PyErr_Occurred()) SWIG_fail;
29784 }
29785 {
29786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29787 }
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29795 PyObject *resultobj = 0;
29796 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29797 bool result;
29798 void *argp1 = 0 ;
29799 int res1 = 0 ;
29800 PyObject *swig_obj[1] ;
29801
29802 if (!args) SWIG_fail;
29803 swig_obj[0] = args;
29804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29805 if (!SWIG_IsOK(res1)) {
29806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29807 }
29808 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29809 {
29810 PyThreadState* __tstate = wxPyBeginAllowThreads();
29811 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29812 wxPyEndAllowThreads(__tstate);
29813 if (PyErr_Occurred()) SWIG_fail;
29814 }
29815 {
29816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29817 }
29818 return resultobj;
29819 fail:
29820 return NULL;
29821 }
29822
29823
29824 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29825 PyObject *resultobj = 0;
29826 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29827 bool result;
29828 void *argp1 = 0 ;
29829 int res1 = 0 ;
29830 PyObject *swig_obj[1] ;
29831
29832 if (!args) SWIG_fail;
29833 swig_obj[0] = args;
29834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29835 if (!SWIG_IsOK(res1)) {
29836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29837 }
29838 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29842 wxPyEndAllowThreads(__tstate);
29843 if (PyErr_Occurred()) SWIG_fail;
29844 }
29845 {
29846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29847 }
29848 return resultobj;
29849 fail:
29850 return NULL;
29851 }
29852
29853
29854 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29855 PyObject *resultobj = 0;
29856 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29857 bool result;
29858 void *argp1 = 0 ;
29859 int res1 = 0 ;
29860 PyObject *swig_obj[1] ;
29861
29862 if (!args) SWIG_fail;
29863 swig_obj[0] = args;
29864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29865 if (!SWIG_IsOK(res1)) {
29866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29867 }
29868 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 {
29876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29877 }
29878 return resultobj;
29879 fail:
29880 return NULL;
29881 }
29882
29883
29884 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29885 PyObject *resultobj = 0;
29886 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29887 wxTimeSpan *arg2 = 0 ;
29888 bool result;
29889 void *argp1 = 0 ;
29890 int res1 = 0 ;
29891 void *argp2 = 0 ;
29892 int res2 = 0 ;
29893 PyObject * obj0 = 0 ;
29894 PyObject * obj1 = 0 ;
29895 char * kwnames[] = {
29896 (char *) "self",(char *) "ts", NULL
29897 };
29898
29899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29901 if (!SWIG_IsOK(res1)) {
29902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29903 }
29904 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29905 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29906 if (!SWIG_IsOK(res2)) {
29907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29908 }
29909 if (!argp2) {
29910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29911 }
29912 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29913 {
29914 PyThreadState* __tstate = wxPyBeginAllowThreads();
29915 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 {
29920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29921 }
29922 return resultobj;
29923 fail:
29924 return NULL;
29925 }
29926
29927
29928 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29929 PyObject *resultobj = 0;
29930 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29931 wxTimeSpan *arg2 = 0 ;
29932 bool result;
29933 void *argp1 = 0 ;
29934 int res1 = 0 ;
29935 void *argp2 = 0 ;
29936 int res2 = 0 ;
29937 PyObject * obj0 = 0 ;
29938 PyObject * obj1 = 0 ;
29939 char * kwnames[] = {
29940 (char *) "self",(char *) "ts", NULL
29941 };
29942
29943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29945 if (!SWIG_IsOK(res1)) {
29946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29947 }
29948 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29950 if (!SWIG_IsOK(res2)) {
29951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29952 }
29953 if (!argp2) {
29954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29955 }
29956 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29957 {
29958 PyThreadState* __tstate = wxPyBeginAllowThreads();
29959 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29960 wxPyEndAllowThreads(__tstate);
29961 if (PyErr_Occurred()) SWIG_fail;
29962 }
29963 {
29964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29965 }
29966 return resultobj;
29967 fail:
29968 return NULL;
29969 }
29970
29971
29972 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29973 PyObject *resultobj = 0;
29974 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29975 wxTimeSpan *arg2 = 0 ;
29976 bool result;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 void *argp2 = 0 ;
29980 int res2 = 0 ;
29981 PyObject * obj0 = 0 ;
29982 PyObject * obj1 = 0 ;
29983 char * kwnames[] = {
29984 (char *) "self",(char *) "t", NULL
29985 };
29986
29987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29989 if (!SWIG_IsOK(res1)) {
29990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29991 }
29992 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29994 if (!SWIG_IsOK(res2)) {
29995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29996 }
29997 if (!argp2) {
29998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29999 }
30000 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30001 {
30002 PyThreadState* __tstate = wxPyBeginAllowThreads();
30003 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30004 wxPyEndAllowThreads(__tstate);
30005 if (PyErr_Occurred()) SWIG_fail;
30006 }
30007 {
30008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30009 }
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30017 PyObject *resultobj = 0;
30018 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30019 int result;
30020 void *argp1 = 0 ;
30021 int res1 = 0 ;
30022 PyObject *swig_obj[1] ;
30023
30024 if (!args) SWIG_fail;
30025 swig_obj[0] = args;
30026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30027 if (!SWIG_IsOK(res1)) {
30028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30029 }
30030 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30031 {
30032 PyThreadState* __tstate = wxPyBeginAllowThreads();
30033 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30034 wxPyEndAllowThreads(__tstate);
30035 if (PyErr_Occurred()) SWIG_fail;
30036 }
30037 resultobj = SWIG_From_int(static_cast< int >(result));
30038 return resultobj;
30039 fail:
30040 return NULL;
30041 }
30042
30043
30044 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30045 PyObject *resultobj = 0;
30046 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30047 int result;
30048 void *argp1 = 0 ;
30049 int res1 = 0 ;
30050 PyObject *swig_obj[1] ;
30051
30052 if (!args) SWIG_fail;
30053 swig_obj[0] = args;
30054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30055 if (!SWIG_IsOK(res1)) {
30056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30057 }
30058 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30059 {
30060 PyThreadState* __tstate = wxPyBeginAllowThreads();
30061 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30062 wxPyEndAllowThreads(__tstate);
30063 if (PyErr_Occurred()) SWIG_fail;
30064 }
30065 resultobj = SWIG_From_int(static_cast< int >(result));
30066 return resultobj;
30067 fail:
30068 return NULL;
30069 }
30070
30071
30072 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30073 PyObject *resultobj = 0;
30074 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30075 int result;
30076 void *argp1 = 0 ;
30077 int res1 = 0 ;
30078 PyObject *swig_obj[1] ;
30079
30080 if (!args) SWIG_fail;
30081 swig_obj[0] = args;
30082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30083 if (!SWIG_IsOK(res1)) {
30084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30085 }
30086 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30087 {
30088 PyThreadState* __tstate = wxPyBeginAllowThreads();
30089 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30090 wxPyEndAllowThreads(__tstate);
30091 if (PyErr_Occurred()) SWIG_fail;
30092 }
30093 resultobj = SWIG_From_int(static_cast< int >(result));
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30101 PyObject *resultobj = 0;
30102 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30103 int result;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 PyObject *swig_obj[1] ;
30107
30108 if (!args) SWIG_fail;
30109 swig_obj[0] = args;
30110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30111 if (!SWIG_IsOK(res1)) {
30112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30113 }
30114 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30118 wxPyEndAllowThreads(__tstate);
30119 if (PyErr_Occurred()) SWIG_fail;
30120 }
30121 resultobj = SWIG_From_int(static_cast< int >(result));
30122 return resultobj;
30123 fail:
30124 return NULL;
30125 }
30126
30127
30128 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30129 PyObject *resultobj = 0;
30130 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30131 wxLongLong result;
30132 void *argp1 = 0 ;
30133 int res1 = 0 ;
30134 PyObject *swig_obj[1] ;
30135
30136 if (!args) SWIG_fail;
30137 swig_obj[0] = args;
30138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30139 if (!SWIG_IsOK(res1)) {
30140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30141 }
30142 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30143 {
30144 PyThreadState* __tstate = wxPyBeginAllowThreads();
30145 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30146 wxPyEndAllowThreads(__tstate);
30147 if (PyErr_Occurred()) SWIG_fail;
30148 }
30149 {
30150 PyObject *hi, *lo, *shifter, *shifted;
30151 hi = PyLong_FromLong( (&result)->GetHi() );
30152 lo = PyLong_FromLong( (&result)->GetLo() );
30153 shifter = PyLong_FromLong(32);
30154 shifted = PyNumber_Lshift(hi, shifter);
30155 resultobj = PyNumber_Or(shifted, lo);
30156 Py_DECREF(hi);
30157 Py_DECREF(lo);
30158 Py_DECREF(shifter);
30159 Py_DECREF(shifted);
30160 }
30161 return resultobj;
30162 fail:
30163 return NULL;
30164 }
30165
30166
30167 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30168 PyObject *resultobj = 0;
30169 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30170 wxLongLong 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_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30180 }
30181 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 {
30189 PyObject *hi, *lo, *shifter, *shifted;
30190 hi = PyLong_FromLong( (&result)->GetHi() );
30191 lo = PyLong_FromLong( (&result)->GetLo() );
30192 shifter = PyLong_FromLong(32);
30193 shifted = PyNumber_Lshift(hi, shifter);
30194 resultobj = PyNumber_Or(shifted, lo);
30195 Py_DECREF(hi);
30196 Py_DECREF(lo);
30197 Py_DECREF(shifter);
30198 Py_DECREF(shifted);
30199 }
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30207 PyObject *resultobj = 0;
30208 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30209 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30210 wxString *arg2 = (wxString *) &arg2_defvalue ;
30211 wxString result;
30212 void *argp1 = 0 ;
30213 int res1 = 0 ;
30214 bool temp2 = false ;
30215 PyObject * obj0 = 0 ;
30216 PyObject * obj1 = 0 ;
30217 char * kwnames[] = {
30218 (char *) "self",(char *) "format", NULL
30219 };
30220
30221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30223 if (!SWIG_IsOK(res1)) {
30224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30225 }
30226 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30227 if (obj1) {
30228 {
30229 arg2 = wxString_in_helper(obj1);
30230 if (arg2 == NULL) SWIG_fail;
30231 temp2 = true;
30232 }
30233 }
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 {
30241 #if wxUSE_UNICODE
30242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30243 #else
30244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30245 #endif
30246 }
30247 {
30248 if (temp2)
30249 delete arg2;
30250 }
30251 return resultobj;
30252 fail:
30253 {
30254 if (temp2)
30255 delete arg2;
30256 }
30257 return NULL;
30258 }
30259
30260
30261 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30262 PyObject *obj;
30263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30264 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30265 return SWIG_Py_Void();
30266 }
30267
30268 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30269 return SWIG_Python_InitShadowInstance(args);
30270 }
30271
30272 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30273 PyObject *resultobj = 0;
30274 int arg1 = (int) 0 ;
30275 int arg2 = (int) 0 ;
30276 int arg3 = (int) 0 ;
30277 int arg4 = (int) 0 ;
30278 wxDateSpan *result = 0 ;
30279 int val1 ;
30280 int ecode1 = 0 ;
30281 int val2 ;
30282 int ecode2 = 0 ;
30283 int val3 ;
30284 int ecode3 = 0 ;
30285 int val4 ;
30286 int ecode4 = 0 ;
30287 PyObject * obj0 = 0 ;
30288 PyObject * obj1 = 0 ;
30289 PyObject * obj2 = 0 ;
30290 PyObject * obj3 = 0 ;
30291 char * kwnames[] = {
30292 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30293 };
30294
30295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30296 if (obj0) {
30297 ecode1 = SWIG_AsVal_int(obj0, &val1);
30298 if (!SWIG_IsOK(ecode1)) {
30299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30300 }
30301 arg1 = static_cast< int >(val1);
30302 }
30303 if (obj1) {
30304 ecode2 = SWIG_AsVal_int(obj1, &val2);
30305 if (!SWIG_IsOK(ecode2)) {
30306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30307 }
30308 arg2 = static_cast< int >(val2);
30309 }
30310 if (obj2) {
30311 ecode3 = SWIG_AsVal_int(obj2, &val3);
30312 if (!SWIG_IsOK(ecode3)) {
30313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30314 }
30315 arg3 = static_cast< int >(val3);
30316 }
30317 if (obj3) {
30318 ecode4 = SWIG_AsVal_int(obj3, &val4);
30319 if (!SWIG_IsOK(ecode4)) {
30320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30321 }
30322 arg4 = static_cast< int >(val4);
30323 }
30324 {
30325 PyThreadState* __tstate = wxPyBeginAllowThreads();
30326 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30331 return resultobj;
30332 fail:
30333 return NULL;
30334 }
30335
30336
30337 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30338 PyObject *resultobj = 0;
30339 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30340 void *argp1 = 0 ;
30341 int res1 = 0 ;
30342 PyObject *swig_obj[1] ;
30343
30344 if (!args) SWIG_fail;
30345 swig_obj[0] = args;
30346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30347 if (!SWIG_IsOK(res1)) {
30348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30349 }
30350 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 delete arg1;
30354
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_Py_Void();
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30366 PyObject *resultobj = 0;
30367 int arg1 ;
30368 wxDateSpan result;
30369 int val1 ;
30370 int ecode1 = 0 ;
30371 PyObject * obj0 = 0 ;
30372 char * kwnames[] = {
30373 (char *) "days", NULL
30374 };
30375
30376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30377 ecode1 = SWIG_AsVal_int(obj0, &val1);
30378 if (!SWIG_IsOK(ecode1)) {
30379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30380 }
30381 arg1 = static_cast< int >(val1);
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 result = wxDateSpan::Days(arg1);
30385 wxPyEndAllowThreads(__tstate);
30386 if (PyErr_Occurred()) SWIG_fail;
30387 }
30388 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30396 PyObject *resultobj = 0;
30397 wxDateSpan result;
30398
30399 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30400 {
30401 PyThreadState* __tstate = wxPyBeginAllowThreads();
30402 result = wxDateSpan::Day();
30403 wxPyEndAllowThreads(__tstate);
30404 if (PyErr_Occurred()) SWIG_fail;
30405 }
30406 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30414 PyObject *resultobj = 0;
30415 int arg1 ;
30416 wxDateSpan result;
30417 int val1 ;
30418 int ecode1 = 0 ;
30419 PyObject * obj0 = 0 ;
30420 char * kwnames[] = {
30421 (char *) "weeks", NULL
30422 };
30423
30424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30425 ecode1 = SWIG_AsVal_int(obj0, &val1);
30426 if (!SWIG_IsOK(ecode1)) {
30427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30428 }
30429 arg1 = static_cast< int >(val1);
30430 {
30431 PyThreadState* __tstate = wxPyBeginAllowThreads();
30432 result = wxDateSpan::Weeks(arg1);
30433 wxPyEndAllowThreads(__tstate);
30434 if (PyErr_Occurred()) SWIG_fail;
30435 }
30436 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30437 return resultobj;
30438 fail:
30439 return NULL;
30440 }
30441
30442
30443 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30444 PyObject *resultobj = 0;
30445 wxDateSpan result;
30446
30447 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30448 {
30449 PyThreadState* __tstate = wxPyBeginAllowThreads();
30450 result = wxDateSpan::Week();
30451 wxPyEndAllowThreads(__tstate);
30452 if (PyErr_Occurred()) SWIG_fail;
30453 }
30454 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30462 PyObject *resultobj = 0;
30463 int arg1 ;
30464 wxDateSpan result;
30465 int val1 ;
30466 int ecode1 = 0 ;
30467 PyObject * obj0 = 0 ;
30468 char * kwnames[] = {
30469 (char *) "mon", NULL
30470 };
30471
30472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30473 ecode1 = SWIG_AsVal_int(obj0, &val1);
30474 if (!SWIG_IsOK(ecode1)) {
30475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30476 }
30477 arg1 = static_cast< int >(val1);
30478 {
30479 PyThreadState* __tstate = wxPyBeginAllowThreads();
30480 result = wxDateSpan::Months(arg1);
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30492 PyObject *resultobj = 0;
30493 wxDateSpan result;
30494
30495 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30496 {
30497 PyThreadState* __tstate = wxPyBeginAllowThreads();
30498 result = wxDateSpan::Month();
30499 wxPyEndAllowThreads(__tstate);
30500 if (PyErr_Occurred()) SWIG_fail;
30501 }
30502 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30503 return resultobj;
30504 fail:
30505 return NULL;
30506 }
30507
30508
30509 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30510 PyObject *resultobj = 0;
30511 int arg1 ;
30512 wxDateSpan result;
30513 int val1 ;
30514 int ecode1 = 0 ;
30515 PyObject * obj0 = 0 ;
30516 char * kwnames[] = {
30517 (char *) "years", NULL
30518 };
30519
30520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30521 ecode1 = SWIG_AsVal_int(obj0, &val1);
30522 if (!SWIG_IsOK(ecode1)) {
30523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30524 }
30525 arg1 = static_cast< int >(val1);
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 result = wxDateSpan::Years(arg1);
30529 wxPyEndAllowThreads(__tstate);
30530 if (PyErr_Occurred()) SWIG_fail;
30531 }
30532 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30540 PyObject *resultobj = 0;
30541 wxDateSpan result;
30542
30543 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30544 {
30545 PyThreadState* __tstate = wxPyBeginAllowThreads();
30546 result = wxDateSpan::Year();
30547 wxPyEndAllowThreads(__tstate);
30548 if (PyErr_Occurred()) SWIG_fail;
30549 }
30550 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30551 return resultobj;
30552 fail:
30553 return NULL;
30554 }
30555
30556
30557 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30558 PyObject *resultobj = 0;
30559 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30560 int arg2 ;
30561 wxDateSpan *result = 0 ;
30562 void *argp1 = 0 ;
30563 int res1 = 0 ;
30564 int val2 ;
30565 int ecode2 = 0 ;
30566 PyObject * obj0 = 0 ;
30567 PyObject * obj1 = 0 ;
30568 char * kwnames[] = {
30569 (char *) "self",(char *) "n", NULL
30570 };
30571
30572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30574 if (!SWIG_IsOK(res1)) {
30575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30576 }
30577 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30578 ecode2 = SWIG_AsVal_int(obj1, &val2);
30579 if (!SWIG_IsOK(ecode2)) {
30580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30581 }
30582 arg2 = static_cast< int >(val2);
30583 {
30584 PyThreadState* __tstate = wxPyBeginAllowThreads();
30585 {
30586 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30587 result = (wxDateSpan *) &_result_ref;
30588 }
30589 wxPyEndAllowThreads(__tstate);
30590 if (PyErr_Occurred()) SWIG_fail;
30591 }
30592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30593 return resultobj;
30594 fail:
30595 return NULL;
30596 }
30597
30598
30599 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30600 PyObject *resultobj = 0;
30601 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30602 int arg2 ;
30603 wxDateSpan *result = 0 ;
30604 void *argp1 = 0 ;
30605 int res1 = 0 ;
30606 int val2 ;
30607 int ecode2 = 0 ;
30608 PyObject * obj0 = 0 ;
30609 PyObject * obj1 = 0 ;
30610 char * kwnames[] = {
30611 (char *) "self",(char *) "n", NULL
30612 };
30613
30614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30616 if (!SWIG_IsOK(res1)) {
30617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30618 }
30619 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30620 ecode2 = SWIG_AsVal_int(obj1, &val2);
30621 if (!SWIG_IsOK(ecode2)) {
30622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30623 }
30624 arg2 = static_cast< int >(val2);
30625 {
30626 PyThreadState* __tstate = wxPyBeginAllowThreads();
30627 {
30628 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30629 result = (wxDateSpan *) &_result_ref;
30630 }
30631 wxPyEndAllowThreads(__tstate);
30632 if (PyErr_Occurred()) SWIG_fail;
30633 }
30634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30635 return resultobj;
30636 fail:
30637 return NULL;
30638 }
30639
30640
30641 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30642 PyObject *resultobj = 0;
30643 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30644 int arg2 ;
30645 wxDateSpan *result = 0 ;
30646 void *argp1 = 0 ;
30647 int res1 = 0 ;
30648 int val2 ;
30649 int ecode2 = 0 ;
30650 PyObject * obj0 = 0 ;
30651 PyObject * obj1 = 0 ;
30652 char * kwnames[] = {
30653 (char *) "self",(char *) "n", NULL
30654 };
30655
30656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30658 if (!SWIG_IsOK(res1)) {
30659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30660 }
30661 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30662 ecode2 = SWIG_AsVal_int(obj1, &val2);
30663 if (!SWIG_IsOK(ecode2)) {
30664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30665 }
30666 arg2 = static_cast< int >(val2);
30667 {
30668 PyThreadState* __tstate = wxPyBeginAllowThreads();
30669 {
30670 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30671 result = (wxDateSpan *) &_result_ref;
30672 }
30673 wxPyEndAllowThreads(__tstate);
30674 if (PyErr_Occurred()) SWIG_fail;
30675 }
30676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30677 return resultobj;
30678 fail:
30679 return NULL;
30680 }
30681
30682
30683 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30684 PyObject *resultobj = 0;
30685 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30686 int arg2 ;
30687 wxDateSpan *result = 0 ;
30688 void *argp1 = 0 ;
30689 int res1 = 0 ;
30690 int val2 ;
30691 int ecode2 = 0 ;
30692 PyObject * obj0 = 0 ;
30693 PyObject * obj1 = 0 ;
30694 char * kwnames[] = {
30695 (char *) "self",(char *) "n", NULL
30696 };
30697
30698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30700 if (!SWIG_IsOK(res1)) {
30701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30702 }
30703 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30704 ecode2 = SWIG_AsVal_int(obj1, &val2);
30705 if (!SWIG_IsOK(ecode2)) {
30706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30707 }
30708 arg2 = static_cast< int >(val2);
30709 {
30710 PyThreadState* __tstate = wxPyBeginAllowThreads();
30711 {
30712 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30713 result = (wxDateSpan *) &_result_ref;
30714 }
30715 wxPyEndAllowThreads(__tstate);
30716 if (PyErr_Occurred()) SWIG_fail;
30717 }
30718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30719 return resultobj;
30720 fail:
30721 return NULL;
30722 }
30723
30724
30725 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30726 PyObject *resultobj = 0;
30727 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30728 int result;
30729 void *argp1 = 0 ;
30730 int res1 = 0 ;
30731 PyObject *swig_obj[1] ;
30732
30733 if (!args) SWIG_fail;
30734 swig_obj[0] = args;
30735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30736 if (!SWIG_IsOK(res1)) {
30737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30738 }
30739 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30740 {
30741 PyThreadState* __tstate = wxPyBeginAllowThreads();
30742 result = (int)((wxDateSpan const *)arg1)->GetYears();
30743 wxPyEndAllowThreads(__tstate);
30744 if (PyErr_Occurred()) SWIG_fail;
30745 }
30746 resultobj = SWIG_From_int(static_cast< int >(result));
30747 return resultobj;
30748 fail:
30749 return NULL;
30750 }
30751
30752
30753 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30754 PyObject *resultobj = 0;
30755 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30756 int result;
30757 void *argp1 = 0 ;
30758 int res1 = 0 ;
30759 PyObject *swig_obj[1] ;
30760
30761 if (!args) SWIG_fail;
30762 swig_obj[0] = args;
30763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30764 if (!SWIG_IsOK(res1)) {
30765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30766 }
30767 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30768 {
30769 PyThreadState* __tstate = wxPyBeginAllowThreads();
30770 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 resultobj = SWIG_From_int(static_cast< int >(result));
30775 return resultobj;
30776 fail:
30777 return NULL;
30778 }
30779
30780
30781 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30782 PyObject *resultobj = 0;
30783 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30784 int result;
30785 void *argp1 = 0 ;
30786 int res1 = 0 ;
30787 PyObject *swig_obj[1] ;
30788
30789 if (!args) SWIG_fail;
30790 swig_obj[0] = args;
30791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30792 if (!SWIG_IsOK(res1)) {
30793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30794 }
30795 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30799 wxPyEndAllowThreads(__tstate);
30800 if (PyErr_Occurred()) SWIG_fail;
30801 }
30802 resultobj = SWIG_From_int(static_cast< int >(result));
30803 return resultobj;
30804 fail:
30805 return NULL;
30806 }
30807
30808
30809 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30810 PyObject *resultobj = 0;
30811 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30812 int result;
30813 void *argp1 = 0 ;
30814 int res1 = 0 ;
30815 PyObject *swig_obj[1] ;
30816
30817 if (!args) SWIG_fail;
30818 swig_obj[0] = args;
30819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30820 if (!SWIG_IsOK(res1)) {
30821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30822 }
30823 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 result = (int)((wxDateSpan const *)arg1)->GetDays();
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 resultobj = SWIG_From_int(static_cast< int >(result));
30831 return resultobj;
30832 fail:
30833 return NULL;
30834 }
30835
30836
30837 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30838 PyObject *resultobj = 0;
30839 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30840 int result;
30841 void *argp1 = 0 ;
30842 int res1 = 0 ;
30843 PyObject *swig_obj[1] ;
30844
30845 if (!args) SWIG_fail;
30846 swig_obj[0] = args;
30847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30848 if (!SWIG_IsOK(res1)) {
30849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30850 }
30851 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30852 {
30853 PyThreadState* __tstate = wxPyBeginAllowThreads();
30854 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 resultobj = SWIG_From_int(static_cast< int >(result));
30859 return resultobj;
30860 fail:
30861 return NULL;
30862 }
30863
30864
30865 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30866 PyObject *resultobj = 0;
30867 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30868 wxDateSpan *arg2 = 0 ;
30869 wxDateSpan *result = 0 ;
30870 void *argp1 = 0 ;
30871 int res1 = 0 ;
30872 void *argp2 = 0 ;
30873 int res2 = 0 ;
30874 PyObject * obj0 = 0 ;
30875 PyObject * obj1 = 0 ;
30876 char * kwnames[] = {
30877 (char *) "self",(char *) "other", NULL
30878 };
30879
30880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30882 if (!SWIG_IsOK(res1)) {
30883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30884 }
30885 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30886 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30887 if (!SWIG_IsOK(res2)) {
30888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30889 }
30890 if (!argp2) {
30891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30892 }
30893 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30894 {
30895 PyThreadState* __tstate = wxPyBeginAllowThreads();
30896 {
30897 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30898 result = (wxDateSpan *) &_result_ref;
30899 }
30900 wxPyEndAllowThreads(__tstate);
30901 if (PyErr_Occurred()) SWIG_fail;
30902 }
30903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30911 PyObject *resultobj = 0;
30912 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30913 wxDateSpan *arg2 = 0 ;
30914 wxDateSpan *result = 0 ;
30915 void *argp1 = 0 ;
30916 int res1 = 0 ;
30917 void *argp2 = 0 ;
30918 int res2 = 0 ;
30919 PyObject * obj0 = 0 ;
30920 PyObject * obj1 = 0 ;
30921 char * kwnames[] = {
30922 (char *) "self",(char *) "other", NULL
30923 };
30924
30925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30927 if (!SWIG_IsOK(res1)) {
30928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30929 }
30930 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30931 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30932 if (!SWIG_IsOK(res2)) {
30933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30934 }
30935 if (!argp2) {
30936 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30937 }
30938 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30939 {
30940 PyThreadState* __tstate = wxPyBeginAllowThreads();
30941 {
30942 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30943 result = (wxDateSpan *) &_result_ref;
30944 }
30945 wxPyEndAllowThreads(__tstate);
30946 if (PyErr_Occurred()) SWIG_fail;
30947 }
30948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30949 return resultobj;
30950 fail:
30951 return NULL;
30952 }
30953
30954
30955 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30956 PyObject *resultobj = 0;
30957 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30958 wxDateSpan *result = 0 ;
30959 void *argp1 = 0 ;
30960 int res1 = 0 ;
30961 PyObject *swig_obj[1] ;
30962
30963 if (!args) SWIG_fail;
30964 swig_obj[0] = args;
30965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30966 if (!SWIG_IsOK(res1)) {
30967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30968 }
30969 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30970 {
30971 PyThreadState* __tstate = wxPyBeginAllowThreads();
30972 {
30973 wxDateSpan &_result_ref = (arg1)->Neg();
30974 result = (wxDateSpan *) &_result_ref;
30975 }
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30987 PyObject *resultobj = 0;
30988 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30989 int arg2 ;
30990 wxDateSpan *result = 0 ;
30991 void *argp1 = 0 ;
30992 int res1 = 0 ;
30993 int val2 ;
30994 int ecode2 = 0 ;
30995 PyObject * obj0 = 0 ;
30996 PyObject * obj1 = 0 ;
30997 char * kwnames[] = {
30998 (char *) "self",(char *) "factor", NULL
30999 };
31000
31001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31003 if (!SWIG_IsOK(res1)) {
31004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31005 }
31006 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31007 ecode2 = SWIG_AsVal_int(obj1, &val2);
31008 if (!SWIG_IsOK(ecode2)) {
31009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31010 }
31011 arg2 = static_cast< int >(val2);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 {
31015 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31016 result = (wxDateSpan *) &_result_ref;
31017 }
31018 wxPyEndAllowThreads(__tstate);
31019 if (PyErr_Occurred()) SWIG_fail;
31020 }
31021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31022 return resultobj;
31023 fail:
31024 return NULL;
31025 }
31026
31027
31028 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31029 PyObject *resultobj = 0;
31030 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31031 wxDateSpan *arg2 = 0 ;
31032 wxDateSpan *result = 0 ;
31033 void *argp1 = 0 ;
31034 int res1 = 0 ;
31035 void *argp2 = 0 ;
31036 int res2 = 0 ;
31037 PyObject * obj0 = 0 ;
31038 PyObject * obj1 = 0 ;
31039 char * kwnames[] = {
31040 (char *) "self",(char *) "other", NULL
31041 };
31042
31043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31045 if (!SWIG_IsOK(res1)) {
31046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31047 }
31048 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31049 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31050 if (!SWIG_IsOK(res2)) {
31051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31052 }
31053 if (!argp2) {
31054 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31055 }
31056 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 {
31060 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31061 result = (wxDateSpan *) &_result_ref;
31062 }
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31067 return resultobj;
31068 fail:
31069 return NULL;
31070 }
31071
31072
31073 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31074 PyObject *resultobj = 0;
31075 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31076 wxDateSpan *arg2 = 0 ;
31077 wxDateSpan *result = 0 ;
31078 void *argp1 = 0 ;
31079 int res1 = 0 ;
31080 void *argp2 = 0 ;
31081 int res2 = 0 ;
31082 PyObject * obj0 = 0 ;
31083 PyObject * obj1 = 0 ;
31084 char * kwnames[] = {
31085 (char *) "self",(char *) "other", NULL
31086 };
31087
31088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31090 if (!SWIG_IsOK(res1)) {
31091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31092 }
31093 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31094 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31095 if (!SWIG_IsOK(res2)) {
31096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31097 }
31098 if (!argp2) {
31099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31100 }
31101 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 {
31105 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31106 result = (wxDateSpan *) &_result_ref;
31107 }
31108 wxPyEndAllowThreads(__tstate);
31109 if (PyErr_Occurred()) SWIG_fail;
31110 }
31111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31112 return resultobj;
31113 fail:
31114 return NULL;
31115 }
31116
31117
31118 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31119 PyObject *resultobj = 0;
31120 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31121 wxDateSpan *result = 0 ;
31122 void *argp1 = 0 ;
31123 int res1 = 0 ;
31124 PyObject *swig_obj[1] ;
31125
31126 if (!args) SWIG_fail;
31127 swig_obj[0] = args;
31128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31129 if (!SWIG_IsOK(res1)) {
31130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31131 }
31132 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31133 {
31134 PyThreadState* __tstate = wxPyBeginAllowThreads();
31135 {
31136 wxDateSpan &_result_ref = (arg1)->operator -();
31137 result = (wxDateSpan *) &_result_ref;
31138 }
31139 wxPyEndAllowThreads(__tstate);
31140 if (PyErr_Occurred()) SWIG_fail;
31141 }
31142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31143 return resultobj;
31144 fail:
31145 return NULL;
31146 }
31147
31148
31149 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31150 PyObject *resultobj = 0;
31151 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31152 int arg2 ;
31153 wxDateSpan *result = 0 ;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 int val2 ;
31157 int ecode2 = 0 ;
31158 PyObject * obj0 = 0 ;
31159 PyObject * obj1 = 0 ;
31160 char * kwnames[] = {
31161 (char *) "self",(char *) "factor", NULL
31162 };
31163
31164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31166 if (!SWIG_IsOK(res1)) {
31167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31168 }
31169 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31170 ecode2 = SWIG_AsVal_int(obj1, &val2);
31171 if (!SWIG_IsOK(ecode2)) {
31172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31173 }
31174 arg2 = static_cast< int >(val2);
31175 {
31176 PyThreadState* __tstate = wxPyBeginAllowThreads();
31177 {
31178 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31179 result = (wxDateSpan *) &_result_ref;
31180 }
31181 wxPyEndAllowThreads(__tstate);
31182 if (PyErr_Occurred()) SWIG_fail;
31183 }
31184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31185 return resultobj;
31186 fail:
31187 return NULL;
31188 }
31189
31190
31191 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31192 PyObject *resultobj = 0;
31193 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31194 wxDateSpan *arg2 = 0 ;
31195 wxDateSpan result;
31196 void *argp1 = 0 ;
31197 int res1 = 0 ;
31198 void *argp2 = 0 ;
31199 int res2 = 0 ;
31200 PyObject * obj0 = 0 ;
31201 PyObject * obj1 = 0 ;
31202 char * kwnames[] = {
31203 (char *) "self",(char *) "other", NULL
31204 };
31205
31206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31208 if (!SWIG_IsOK(res1)) {
31209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31210 }
31211 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31212 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31213 if (!SWIG_IsOK(res2)) {
31214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31215 }
31216 if (!argp2) {
31217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31218 }
31219 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31220 {
31221 PyThreadState* __tstate = wxPyBeginAllowThreads();
31222 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31227 return resultobj;
31228 fail:
31229 return NULL;
31230 }
31231
31232
31233 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31234 PyObject *resultobj = 0;
31235 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31236 wxDateSpan *arg2 = 0 ;
31237 wxDateSpan result;
31238 void *argp1 = 0 ;
31239 int res1 = 0 ;
31240 void *argp2 = 0 ;
31241 int res2 = 0 ;
31242 PyObject * obj0 = 0 ;
31243 PyObject * obj1 = 0 ;
31244 char * kwnames[] = {
31245 (char *) "self",(char *) "other", NULL
31246 };
31247
31248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31250 if (!SWIG_IsOK(res1)) {
31251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31252 }
31253 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31254 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31255 if (!SWIG_IsOK(res2)) {
31256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31257 }
31258 if (!argp2) {
31259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31260 }
31261 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31265 wxPyEndAllowThreads(__tstate);
31266 if (PyErr_Occurred()) SWIG_fail;
31267 }
31268 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31269 return resultobj;
31270 fail:
31271 return NULL;
31272 }
31273
31274
31275 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31276 PyObject *resultobj = 0;
31277 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31278 int arg2 ;
31279 wxDateSpan result;
31280 void *argp1 = 0 ;
31281 int res1 = 0 ;
31282 int val2 ;
31283 int ecode2 = 0 ;
31284 PyObject * obj0 = 0 ;
31285 PyObject * obj1 = 0 ;
31286 char * kwnames[] = {
31287 (char *) "self",(char *) "n", NULL
31288 };
31289
31290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31292 if (!SWIG_IsOK(res1)) {
31293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31294 }
31295 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31296 ecode2 = SWIG_AsVal_int(obj1, &val2);
31297 if (!SWIG_IsOK(ecode2)) {
31298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31299 }
31300 arg2 = static_cast< int >(val2);
31301 {
31302 PyThreadState* __tstate = wxPyBeginAllowThreads();
31303 result = wxDateSpan___mul__(arg1,arg2);
31304 wxPyEndAllowThreads(__tstate);
31305 if (PyErr_Occurred()) SWIG_fail;
31306 }
31307 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31308 return resultobj;
31309 fail:
31310 return NULL;
31311 }
31312
31313
31314 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31315 PyObject *resultobj = 0;
31316 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31317 int arg2 ;
31318 wxDateSpan result;
31319 void *argp1 = 0 ;
31320 int res1 = 0 ;
31321 int val2 ;
31322 int ecode2 = 0 ;
31323 PyObject * obj0 = 0 ;
31324 PyObject * obj1 = 0 ;
31325 char * kwnames[] = {
31326 (char *) "self",(char *) "n", NULL
31327 };
31328
31329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31331 if (!SWIG_IsOK(res1)) {
31332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31333 }
31334 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31335 ecode2 = SWIG_AsVal_int(obj1, &val2);
31336 if (!SWIG_IsOK(ecode2)) {
31337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31338 }
31339 arg2 = static_cast< int >(val2);
31340 {
31341 PyThreadState* __tstate = wxPyBeginAllowThreads();
31342 result = wxDateSpan___rmul__(arg1,arg2);
31343 wxPyEndAllowThreads(__tstate);
31344 if (PyErr_Occurred()) SWIG_fail;
31345 }
31346 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31347 return resultobj;
31348 fail:
31349 return NULL;
31350 }
31351
31352
31353 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31354 PyObject *resultobj = 0;
31355 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31356 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31357 bool result;
31358 void *argp1 = 0 ;
31359 int res1 = 0 ;
31360 void *argp2 = 0 ;
31361 int res2 = 0 ;
31362 PyObject * obj0 = 0 ;
31363 PyObject * obj1 = 0 ;
31364 char * kwnames[] = {
31365 (char *) "self",(char *) "other", NULL
31366 };
31367
31368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31370 if (!SWIG_IsOK(res1)) {
31371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31372 }
31373 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31374 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31375 if (!SWIG_IsOK(res2)) {
31376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31377 }
31378 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31379 {
31380 PyThreadState* __tstate = wxPyBeginAllowThreads();
31381 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31382 wxPyEndAllowThreads(__tstate);
31383 if (PyErr_Occurred()) SWIG_fail;
31384 }
31385 {
31386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31387 }
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31395 PyObject *resultobj = 0;
31396 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31397 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31398 bool result;
31399 void *argp1 = 0 ;
31400 int res1 = 0 ;
31401 void *argp2 = 0 ;
31402 int res2 = 0 ;
31403 PyObject * obj0 = 0 ;
31404 PyObject * obj1 = 0 ;
31405 char * kwnames[] = {
31406 (char *) "self",(char *) "other", NULL
31407 };
31408
31409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31411 if (!SWIG_IsOK(res1)) {
31412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31413 }
31414 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31416 if (!SWIG_IsOK(res2)) {
31417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31418 }
31419 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31420 {
31421 PyThreadState* __tstate = wxPyBeginAllowThreads();
31422 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31423 wxPyEndAllowThreads(__tstate);
31424 if (PyErr_Occurred()) SWIG_fail;
31425 }
31426 {
31427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31428 }
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 PyObject *obj;
31437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31438 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31439 return SWIG_Py_Void();
31440 }
31441
31442 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31443 return SWIG_Python_InitShadowInstance(args);
31444 }
31445
31446 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31447 PyObject *resultobj = 0;
31448 long result;
31449
31450 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31451 {
31452 PyThreadState* __tstate = wxPyBeginAllowThreads();
31453 result = (long)wxGetLocalTime();
31454 wxPyEndAllowThreads(__tstate);
31455 if (PyErr_Occurred()) SWIG_fail;
31456 }
31457 resultobj = SWIG_From_long(static_cast< long >(result));
31458 return resultobj;
31459 fail:
31460 return NULL;
31461 }
31462
31463
31464 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31465 PyObject *resultobj = 0;
31466 long result;
31467
31468 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31469 {
31470 PyThreadState* __tstate = wxPyBeginAllowThreads();
31471 result = (long)wxGetUTCTime();
31472 wxPyEndAllowThreads(__tstate);
31473 if (PyErr_Occurred()) SWIG_fail;
31474 }
31475 resultobj = SWIG_From_long(static_cast< long >(result));
31476 return resultobj;
31477 fail:
31478 return NULL;
31479 }
31480
31481
31482 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31483 PyObject *resultobj = 0;
31484 long result;
31485
31486 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31487 {
31488 PyThreadState* __tstate = wxPyBeginAllowThreads();
31489 result = (long)wxGetCurrentTime();
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 resultobj = SWIG_From_long(static_cast< long >(result));
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31501 PyObject *resultobj = 0;
31502 wxLongLong result;
31503
31504 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31505 {
31506 PyThreadState* __tstate = wxPyBeginAllowThreads();
31507 result = wxGetLocalTimeMillis();
31508 wxPyEndAllowThreads(__tstate);
31509 if (PyErr_Occurred()) SWIG_fail;
31510 }
31511 {
31512 PyObject *hi, *lo, *shifter, *shifted;
31513 hi = PyLong_FromLong( (&result)->GetHi() );
31514 lo = PyLong_FromLong( (&result)->GetLo() );
31515 shifter = PyLong_FromLong(32);
31516 shifted = PyNumber_Lshift(hi, shifter);
31517 resultobj = PyNumber_Or(shifted, lo);
31518 Py_DECREF(hi);
31519 Py_DECREF(lo);
31520 Py_DECREF(shifter);
31521 Py_DECREF(shifted);
31522 }
31523 return resultobj;
31524 fail:
31525 return NULL;
31526 }
31527
31528
31529 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31530 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31531 return 1;
31532 }
31533
31534
31535 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31536 PyObject *pyobj = 0;
31537
31538 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31539 return pyobj;
31540 }
31541
31542
31543 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31544 PyObject *resultobj = 0;
31545 wxDataFormatId arg1 ;
31546 wxDataFormat *result = 0 ;
31547 int val1 ;
31548 int ecode1 = 0 ;
31549 PyObject * obj0 = 0 ;
31550 char * kwnames[] = {
31551 (char *) "type", NULL
31552 };
31553
31554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31555 ecode1 = SWIG_AsVal_int(obj0, &val1);
31556 if (!SWIG_IsOK(ecode1)) {
31557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31558 }
31559 arg1 = static_cast< wxDataFormatId >(val1);
31560 {
31561 PyThreadState* __tstate = wxPyBeginAllowThreads();
31562 result = (wxDataFormat *)new wxDataFormat(arg1);
31563 wxPyEndAllowThreads(__tstate);
31564 if (PyErr_Occurred()) SWIG_fail;
31565 }
31566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31567 return resultobj;
31568 fail:
31569 return NULL;
31570 }
31571
31572
31573 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31574 PyObject *resultobj = 0;
31575 wxString *arg1 = 0 ;
31576 wxDataFormat *result = 0 ;
31577 bool temp1 = false ;
31578 PyObject * obj0 = 0 ;
31579 char * kwnames[] = {
31580 (char *) "format", NULL
31581 };
31582
31583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31584 {
31585 arg1 = wxString_in_helper(obj0);
31586 if (arg1 == NULL) SWIG_fail;
31587 temp1 = true;
31588 }
31589 {
31590 PyThreadState* __tstate = wxPyBeginAllowThreads();
31591 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31592 wxPyEndAllowThreads(__tstate);
31593 if (PyErr_Occurred()) SWIG_fail;
31594 }
31595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31596 {
31597 if (temp1)
31598 delete arg1;
31599 }
31600 return resultobj;
31601 fail:
31602 {
31603 if (temp1)
31604 delete arg1;
31605 }
31606 return NULL;
31607 }
31608
31609
31610 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31611 PyObject *resultobj = 0;
31612 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31613 void *argp1 = 0 ;
31614 int res1 = 0 ;
31615 PyObject *swig_obj[1] ;
31616
31617 if (!args) SWIG_fail;
31618 swig_obj[0] = args;
31619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31620 if (!SWIG_IsOK(res1)) {
31621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31622 }
31623 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31624 {
31625 PyThreadState* __tstate = wxPyBeginAllowThreads();
31626 delete arg1;
31627
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 resultobj = SWIG_Py_Void();
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31639 PyObject *resultobj = 0;
31640 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31641 wxDataFormatId arg2 ;
31642 bool result;
31643 void *argp1 = 0 ;
31644 int res1 = 0 ;
31645 int val2 ;
31646 int ecode2 = 0 ;
31647
31648 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31650 if (!SWIG_IsOK(res1)) {
31651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31652 }
31653 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31654 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31655 if (!SWIG_IsOK(ecode2)) {
31656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31657 }
31658 arg2 = static_cast< wxDataFormatId >(val2);
31659 {
31660 PyThreadState* __tstate = wxPyBeginAllowThreads();
31661 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31662 wxPyEndAllowThreads(__tstate);
31663 if (PyErr_Occurred()) SWIG_fail;
31664 }
31665 {
31666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31667 }
31668 return resultobj;
31669 fail:
31670 return NULL;
31671 }
31672
31673
31674 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31675 PyObject *resultobj = 0;
31676 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31677 wxDataFormatId arg2 ;
31678 bool result;
31679 void *argp1 = 0 ;
31680 int res1 = 0 ;
31681 int val2 ;
31682 int ecode2 = 0 ;
31683
31684 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31686 if (!SWIG_IsOK(res1)) {
31687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31688 }
31689 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31690 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31691 if (!SWIG_IsOK(ecode2)) {
31692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31693 }
31694 arg2 = static_cast< wxDataFormatId >(val2);
31695 {
31696 PyThreadState* __tstate = wxPyBeginAllowThreads();
31697 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31698 wxPyEndAllowThreads(__tstate);
31699 if (PyErr_Occurred()) SWIG_fail;
31700 }
31701 {
31702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31703 }
31704 return resultobj;
31705 fail:
31706 return NULL;
31707 }
31708
31709
31710 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31711 PyObject *resultobj = 0;
31712 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31713 wxDataFormat *arg2 = 0 ;
31714 bool result;
31715 void *argp1 = 0 ;
31716 int res1 = 0 ;
31717 void *argp2 = 0 ;
31718 int res2 = 0 ;
31719
31720 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31722 if (!SWIG_IsOK(res1)) {
31723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31724 }
31725 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31726 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31727 if (!SWIG_IsOK(res2)) {
31728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31729 }
31730 if (!argp2) {
31731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31732 }
31733 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31734 {
31735 PyThreadState* __tstate = wxPyBeginAllowThreads();
31736 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31737 wxPyEndAllowThreads(__tstate);
31738 if (PyErr_Occurred()) SWIG_fail;
31739 }
31740 {
31741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31742 }
31743 return resultobj;
31744 fail:
31745 return NULL;
31746 }
31747
31748
31749 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31750 int argc;
31751 PyObject *argv[3];
31752
31753 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31754 --argc;
31755 if (argc == 2) {
31756 int _v = 0;
31757 {
31758 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31759 _v = SWIG_CheckState(res);
31760 }
31761 if (!_v) goto check_1;
31762 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31763 }
31764 check_1:
31765
31766 if (argc == 2) {
31767 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31768 }
31769
31770 fail:
31771 Py_INCREF(Py_NotImplemented);
31772 return Py_NotImplemented;
31773 }
31774
31775
31776 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31777 PyObject *resultobj = 0;
31778 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31779 wxDataFormat *arg2 = 0 ;
31780 bool result;
31781 void *argp1 = 0 ;
31782 int res1 = 0 ;
31783 void *argp2 = 0 ;
31784 int res2 = 0 ;
31785
31786 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31788 if (!SWIG_IsOK(res1)) {
31789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31790 }
31791 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31792 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31793 if (!SWIG_IsOK(res2)) {
31794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31795 }
31796 if (!argp2) {
31797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31798 }
31799 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31800 {
31801 PyThreadState* __tstate = wxPyBeginAllowThreads();
31802 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31803 wxPyEndAllowThreads(__tstate);
31804 if (PyErr_Occurred()) SWIG_fail;
31805 }
31806 {
31807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31808 }
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31816 int argc;
31817 PyObject *argv[3];
31818
31819 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31820 --argc;
31821 if (argc == 2) {
31822 int _v = 0;
31823 {
31824 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31825 _v = SWIG_CheckState(res);
31826 }
31827 if (!_v) goto check_1;
31828 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31829 }
31830 check_1:
31831
31832 if (argc == 2) {
31833 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31834 }
31835
31836 fail:
31837 Py_INCREF(Py_NotImplemented);
31838 return Py_NotImplemented;
31839 }
31840
31841
31842 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31843 PyObject *resultobj = 0;
31844 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31845 wxDataFormatId arg2 ;
31846 void *argp1 = 0 ;
31847 int res1 = 0 ;
31848 int val2 ;
31849 int ecode2 = 0 ;
31850 PyObject * obj0 = 0 ;
31851 PyObject * obj1 = 0 ;
31852 char * kwnames[] = {
31853 (char *) "self",(char *) "format", NULL
31854 };
31855
31856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31858 if (!SWIG_IsOK(res1)) {
31859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31860 }
31861 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31862 ecode2 = SWIG_AsVal_int(obj1, &val2);
31863 if (!SWIG_IsOK(ecode2)) {
31864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31865 }
31866 arg2 = static_cast< wxDataFormatId >(val2);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 (arg1)->SetType(arg2);
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_Py_Void();
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881 PyObject *resultobj = 0;
31882 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31883 wxDataFormatId result;
31884 void *argp1 = 0 ;
31885 int res1 = 0 ;
31886 PyObject *swig_obj[1] ;
31887
31888 if (!args) SWIG_fail;
31889 swig_obj[0] = args;
31890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31891 if (!SWIG_IsOK(res1)) {
31892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31893 }
31894 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31895 {
31896 PyThreadState* __tstate = wxPyBeginAllowThreads();
31897 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31898 wxPyEndAllowThreads(__tstate);
31899 if (PyErr_Occurred()) SWIG_fail;
31900 }
31901 resultobj = SWIG_From_int(static_cast< int >(result));
31902 return resultobj;
31903 fail:
31904 return NULL;
31905 }
31906
31907
31908 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31909 PyObject *resultobj = 0;
31910 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31911 wxString result;
31912 void *argp1 = 0 ;
31913 int res1 = 0 ;
31914 PyObject *swig_obj[1] ;
31915
31916 if (!args) SWIG_fail;
31917 swig_obj[0] = args;
31918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31919 if (!SWIG_IsOK(res1)) {
31920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31921 }
31922 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31923 {
31924 PyThreadState* __tstate = wxPyBeginAllowThreads();
31925 result = ((wxDataFormat const *)arg1)->GetId();
31926 wxPyEndAllowThreads(__tstate);
31927 if (PyErr_Occurred()) SWIG_fail;
31928 }
31929 {
31930 #if wxUSE_UNICODE
31931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31932 #else
31933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31934 #endif
31935 }
31936 return resultobj;
31937 fail:
31938 return NULL;
31939 }
31940
31941
31942 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31943 PyObject *resultobj = 0;
31944 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31945 wxString *arg2 = 0 ;
31946 void *argp1 = 0 ;
31947 int res1 = 0 ;
31948 bool temp2 = false ;
31949 PyObject * obj0 = 0 ;
31950 PyObject * obj1 = 0 ;
31951 char * kwnames[] = {
31952 (char *) "self",(char *) "format", NULL
31953 };
31954
31955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31957 if (!SWIG_IsOK(res1)) {
31958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31959 }
31960 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31961 {
31962 arg2 = wxString_in_helper(obj1);
31963 if (arg2 == NULL) SWIG_fail;
31964 temp2 = true;
31965 }
31966 {
31967 PyThreadState* __tstate = wxPyBeginAllowThreads();
31968 (arg1)->SetId((wxString const &)*arg2);
31969 wxPyEndAllowThreads(__tstate);
31970 if (PyErr_Occurred()) SWIG_fail;
31971 }
31972 resultobj = SWIG_Py_Void();
31973 {
31974 if (temp2)
31975 delete arg2;
31976 }
31977 return resultobj;
31978 fail:
31979 {
31980 if (temp2)
31981 delete arg2;
31982 }
31983 return NULL;
31984 }
31985
31986
31987 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31988 PyObject *obj;
31989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31990 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31991 return SWIG_Py_Void();
31992 }
31993
31994 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31995 return SWIG_Python_InitShadowInstance(args);
31996 }
31997
31998 SWIGINTERN int FormatInvalid_set(PyObject *) {
31999 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32000 return 1;
32001 }
32002
32003
32004 SWIGINTERN PyObject *FormatInvalid_get(void) {
32005 PyObject *pyobj = 0;
32006
32007 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32008 return pyobj;
32009 }
32010
32011
32012 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32013 PyObject *resultobj = 0;
32014 wxDataObject *arg1 = (wxDataObject *) 0 ;
32015 void *argp1 = 0 ;
32016 int res1 = 0 ;
32017 PyObject *swig_obj[1] ;
32018
32019 if (!args) SWIG_fail;
32020 swig_obj[0] = args;
32021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32022 if (!SWIG_IsOK(res1)) {
32023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32024 }
32025 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32026 {
32027 PyThreadState* __tstate = wxPyBeginAllowThreads();
32028 delete arg1;
32029
32030 wxPyEndAllowThreads(__tstate);
32031 if (PyErr_Occurred()) SWIG_fail;
32032 }
32033 resultobj = SWIG_Py_Void();
32034 return resultobj;
32035 fail:
32036 return NULL;
32037 }
32038
32039
32040 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32041 PyObject *resultobj = 0;
32042 wxDataObject *arg1 = (wxDataObject *) 0 ;
32043 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32044 SwigValueWrapper<wxDataFormat > result;
32045 void *argp1 = 0 ;
32046 int res1 = 0 ;
32047 int val2 ;
32048 int ecode2 = 0 ;
32049 PyObject * obj0 = 0 ;
32050 PyObject * obj1 = 0 ;
32051 char * kwnames[] = {
32052 (char *) "self",(char *) "dir", NULL
32053 };
32054
32055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32057 if (!SWIG_IsOK(res1)) {
32058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32059 }
32060 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32061 if (obj1) {
32062 ecode2 = SWIG_AsVal_int(obj1, &val2);
32063 if (!SWIG_IsOK(ecode2)) {
32064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32065 }
32066 arg2 = static_cast< wxDataObject::Direction >(val2);
32067 }
32068 {
32069 PyThreadState* __tstate = wxPyBeginAllowThreads();
32070 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32075 return resultobj;
32076 fail:
32077 return NULL;
32078 }
32079
32080
32081 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32082 PyObject *resultobj = 0;
32083 wxDataObject *arg1 = (wxDataObject *) 0 ;
32084 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32085 size_t result;
32086 void *argp1 = 0 ;
32087 int res1 = 0 ;
32088 int val2 ;
32089 int ecode2 = 0 ;
32090 PyObject * obj0 = 0 ;
32091 PyObject * obj1 = 0 ;
32092 char * kwnames[] = {
32093 (char *) "self",(char *) "dir", NULL
32094 };
32095
32096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32098 if (!SWIG_IsOK(res1)) {
32099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32100 }
32101 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32102 if (obj1) {
32103 ecode2 = SWIG_AsVal_int(obj1, &val2);
32104 if (!SWIG_IsOK(ecode2)) {
32105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32106 }
32107 arg2 = static_cast< wxDataObject::Direction >(val2);
32108 }
32109 {
32110 PyThreadState* __tstate = wxPyBeginAllowThreads();
32111 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32123 PyObject *resultobj = 0;
32124 wxDataObject *arg1 = (wxDataObject *) 0 ;
32125 wxDataFormat *arg2 = 0 ;
32126 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32127 bool result;
32128 void *argp1 = 0 ;
32129 int res1 = 0 ;
32130 void *argp2 = 0 ;
32131 int res2 = 0 ;
32132 int val3 ;
32133 int ecode3 = 0 ;
32134 PyObject * obj0 = 0 ;
32135 PyObject * obj1 = 0 ;
32136 PyObject * obj2 = 0 ;
32137 char * kwnames[] = {
32138 (char *) "self",(char *) "format",(char *) "dir", NULL
32139 };
32140
32141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32145 }
32146 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32148 if (!SWIG_IsOK(res2)) {
32149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32150 }
32151 if (!argp2) {
32152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32153 }
32154 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32155 if (obj2) {
32156 ecode3 = SWIG_AsVal_int(obj2, &val3);
32157 if (!SWIG_IsOK(ecode3)) {
32158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32159 }
32160 arg3 = static_cast< wxDataObject::Direction >(val3);
32161 }
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 {
32169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32170 }
32171 return resultobj;
32172 fail:
32173 return NULL;
32174 }
32175
32176
32177 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32178 PyObject *resultobj = 0;
32179 wxDataObject *arg1 = (wxDataObject *) 0 ;
32180 wxDataFormat *arg2 = 0 ;
32181 size_t result;
32182 void *argp1 = 0 ;
32183 int res1 = 0 ;
32184 void *argp2 = 0 ;
32185 int res2 = 0 ;
32186 PyObject * obj0 = 0 ;
32187 PyObject * obj1 = 0 ;
32188 char * kwnames[] = {
32189 (char *) "self",(char *) "format", NULL
32190 };
32191
32192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32194 if (!SWIG_IsOK(res1)) {
32195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32196 }
32197 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32198 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32199 if (!SWIG_IsOK(res2)) {
32200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32201 }
32202 if (!argp2) {
32203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32204 }
32205 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32206 {
32207 PyThreadState* __tstate = wxPyBeginAllowThreads();
32208 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32209 wxPyEndAllowThreads(__tstate);
32210 if (PyErr_Occurred()) SWIG_fail;
32211 }
32212 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32220 PyObject *resultobj = 0;
32221 wxDataObject *arg1 = (wxDataObject *) 0 ;
32222 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32223 PyObject *result = 0 ;
32224 void *argp1 = 0 ;
32225 int res1 = 0 ;
32226 int val2 ;
32227 int ecode2 = 0 ;
32228 PyObject * obj0 = 0 ;
32229 PyObject * obj1 = 0 ;
32230 char * kwnames[] = {
32231 (char *) "self",(char *) "dir", NULL
32232 };
32233
32234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32236 if (!SWIG_IsOK(res1)) {
32237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32238 }
32239 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32240 if (obj1) {
32241 ecode2 = SWIG_AsVal_int(obj1, &val2);
32242 if (!SWIG_IsOK(ecode2)) {
32243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32244 }
32245 arg2 = static_cast< wxDataObject::Direction >(val2);
32246 }
32247 {
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32250 wxPyEndAllowThreads(__tstate);
32251 if (PyErr_Occurred()) SWIG_fail;
32252 }
32253 resultobj = result;
32254 return resultobj;
32255 fail:
32256 return NULL;
32257 }
32258
32259
32260 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32261 PyObject *resultobj = 0;
32262 wxDataObject *arg1 = (wxDataObject *) 0 ;
32263 wxDataFormat *arg2 = 0 ;
32264 PyObject *result = 0 ;
32265 void *argp1 = 0 ;
32266 int res1 = 0 ;
32267 void *argp2 = 0 ;
32268 int res2 = 0 ;
32269 PyObject * obj0 = 0 ;
32270 PyObject * obj1 = 0 ;
32271 char * kwnames[] = {
32272 (char *) "self",(char *) "format", NULL
32273 };
32274
32275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32277 if (!SWIG_IsOK(res1)) {
32278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32279 }
32280 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32281 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32282 if (!SWIG_IsOK(res2)) {
32283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32284 }
32285 if (!argp2) {
32286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32287 }
32288 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 resultobj = result;
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32303 PyObject *resultobj = 0;
32304 wxDataObject *arg1 = (wxDataObject *) 0 ;
32305 wxDataFormat *arg2 = 0 ;
32306 PyObject *arg3 = (PyObject *) 0 ;
32307 bool result;
32308 void *argp1 = 0 ;
32309 int res1 = 0 ;
32310 void *argp2 = 0 ;
32311 int res2 = 0 ;
32312 PyObject * obj0 = 0 ;
32313 PyObject * obj1 = 0 ;
32314 PyObject * obj2 = 0 ;
32315 char * kwnames[] = {
32316 (char *) "self",(char *) "format",(char *) "data", NULL
32317 };
32318
32319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32321 if (!SWIG_IsOK(res1)) {
32322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32323 }
32324 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32326 if (!SWIG_IsOK(res2)) {
32327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32328 }
32329 if (!argp2) {
32330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32331 }
32332 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32333 arg3 = obj2;
32334 {
32335 PyThreadState* __tstate = wxPyBeginAllowThreads();
32336 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32337 wxPyEndAllowThreads(__tstate);
32338 if (PyErr_Occurred()) SWIG_fail;
32339 }
32340 {
32341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32342 }
32343 return resultobj;
32344 fail:
32345 return NULL;
32346 }
32347
32348
32349 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32350 PyObject *obj;
32351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32352 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32353 return SWIG_Py_Void();
32354 }
32355
32356 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj = 0;
32358 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32359 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32360 wxDataObjectSimple *result = 0 ;
32361 void *argp1 = 0 ;
32362 int res1 = 0 ;
32363 PyObject * obj0 = 0 ;
32364 char * kwnames[] = {
32365 (char *) "format", NULL
32366 };
32367
32368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32369 if (obj0) {
32370 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32371 if (!SWIG_IsOK(res1)) {
32372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32373 }
32374 if (!argp1) {
32375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32376 }
32377 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32378 }
32379 {
32380 PyThreadState* __tstate = wxPyBeginAllowThreads();
32381 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32382 wxPyEndAllowThreads(__tstate);
32383 if (PyErr_Occurred()) SWIG_fail;
32384 }
32385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32386 return resultobj;
32387 fail:
32388 return NULL;
32389 }
32390
32391
32392 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32393 PyObject *resultobj = 0;
32394 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32395 wxDataFormat *result = 0 ;
32396 void *argp1 = 0 ;
32397 int res1 = 0 ;
32398 PyObject *swig_obj[1] ;
32399
32400 if (!args) SWIG_fail;
32401 swig_obj[0] = args;
32402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32403 if (!SWIG_IsOK(res1)) {
32404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32405 }
32406 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32407 {
32408 PyThreadState* __tstate = wxPyBeginAllowThreads();
32409 {
32410 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32411 result = (wxDataFormat *) &_result_ref;
32412 }
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32417 return resultobj;
32418 fail:
32419 return NULL;
32420 }
32421
32422
32423 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32424 PyObject *resultobj = 0;
32425 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32426 wxDataFormat *arg2 = 0 ;
32427 void *argp1 = 0 ;
32428 int res1 = 0 ;
32429 void *argp2 = 0 ;
32430 int res2 = 0 ;
32431 PyObject * obj0 = 0 ;
32432 PyObject * obj1 = 0 ;
32433 char * kwnames[] = {
32434 (char *) "self",(char *) "format", NULL
32435 };
32436
32437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32439 if (!SWIG_IsOK(res1)) {
32440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32441 }
32442 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32443 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32444 if (!SWIG_IsOK(res2)) {
32445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32446 }
32447 if (!argp2) {
32448 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32449 }
32450 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32451 {
32452 PyThreadState* __tstate = wxPyBeginAllowThreads();
32453 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32454 wxPyEndAllowThreads(__tstate);
32455 if (PyErr_Occurred()) SWIG_fail;
32456 }
32457 resultobj = SWIG_Py_Void();
32458 return resultobj;
32459 fail:
32460 return NULL;
32461 }
32462
32463
32464 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32465 PyObject *resultobj = 0;
32466 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32467 size_t result;
32468 void *argp1 = 0 ;
32469 int res1 = 0 ;
32470 PyObject *swig_obj[1] ;
32471
32472 if (!args) SWIG_fail;
32473 swig_obj[0] = args;
32474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32475 if (!SWIG_IsOK(res1)) {
32476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32477 }
32478 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32479 {
32480 PyThreadState* __tstate = wxPyBeginAllowThreads();
32481 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32482 wxPyEndAllowThreads(__tstate);
32483 if (PyErr_Occurred()) SWIG_fail;
32484 }
32485 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32486 return resultobj;
32487 fail:
32488 return NULL;
32489 }
32490
32491
32492 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32493 PyObject *resultobj = 0;
32494 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32495 PyObject *result = 0 ;
32496 void *argp1 = 0 ;
32497 int res1 = 0 ;
32498 PyObject *swig_obj[1] ;
32499
32500 if (!args) SWIG_fail;
32501 swig_obj[0] = args;
32502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32503 if (!SWIG_IsOK(res1)) {
32504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32505 }
32506 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32507 {
32508 PyThreadState* __tstate = wxPyBeginAllowThreads();
32509 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32510 wxPyEndAllowThreads(__tstate);
32511 if (PyErr_Occurred()) SWIG_fail;
32512 }
32513 resultobj = result;
32514 return resultobj;
32515 fail:
32516 return NULL;
32517 }
32518
32519
32520 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32521 PyObject *resultobj = 0;
32522 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32523 PyObject *arg2 = (PyObject *) 0 ;
32524 bool result;
32525 void *argp1 = 0 ;
32526 int res1 = 0 ;
32527 PyObject * obj0 = 0 ;
32528 PyObject * obj1 = 0 ;
32529 char * kwnames[] = {
32530 (char *) "self",(char *) "data", NULL
32531 };
32532
32533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32535 if (!SWIG_IsOK(res1)) {
32536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32537 }
32538 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32539 arg2 = obj1;
32540 {
32541 PyThreadState* __tstate = wxPyBeginAllowThreads();
32542 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32543 wxPyEndAllowThreads(__tstate);
32544 if (PyErr_Occurred()) SWIG_fail;
32545 }
32546 {
32547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32548 }
32549 return resultobj;
32550 fail:
32551 return NULL;
32552 }
32553
32554
32555 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32556 PyObject *obj;
32557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32558 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32559 return SWIG_Py_Void();
32560 }
32561
32562 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32563 return SWIG_Python_InitShadowInstance(args);
32564 }
32565
32566 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32567 PyObject *resultobj = 0;
32568 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32569 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32570 wxPyDataObjectSimple *result = 0 ;
32571 void *argp1 = 0 ;
32572 int res1 = 0 ;
32573 PyObject * obj0 = 0 ;
32574 char * kwnames[] = {
32575 (char *) "format", NULL
32576 };
32577
32578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32579 if (obj0) {
32580 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32581 if (!SWIG_IsOK(res1)) {
32582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32583 }
32584 if (!argp1) {
32585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32586 }
32587 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32588 }
32589 {
32590 PyThreadState* __tstate = wxPyBeginAllowThreads();
32591 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32603 PyObject *resultobj = 0;
32604 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32605 PyObject *arg2 = (PyObject *) 0 ;
32606 PyObject *arg3 = (PyObject *) 0 ;
32607 void *argp1 = 0 ;
32608 int res1 = 0 ;
32609 PyObject * obj0 = 0 ;
32610 PyObject * obj1 = 0 ;
32611 PyObject * obj2 = 0 ;
32612 char * kwnames[] = {
32613 (char *) "self",(char *) "self",(char *) "_class", NULL
32614 };
32615
32616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32618 if (!SWIG_IsOK(res1)) {
32619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32620 }
32621 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32622 arg2 = obj1;
32623 arg3 = obj2;
32624 {
32625 PyThreadState* __tstate = wxPyBeginAllowThreads();
32626 (arg1)->_setCallbackInfo(arg2,arg3);
32627 wxPyEndAllowThreads(__tstate);
32628 if (PyErr_Occurred()) SWIG_fail;
32629 }
32630 resultobj = SWIG_Py_Void();
32631 return resultobj;
32632 fail:
32633 return NULL;
32634 }
32635
32636
32637 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32638 PyObject *obj;
32639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32640 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32641 return SWIG_Py_Void();
32642 }
32643
32644 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32645 return SWIG_Python_InitShadowInstance(args);
32646 }
32647
32648 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32649 PyObject *resultobj = 0;
32650 wxDataObjectComposite *result = 0 ;
32651
32652 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32653 {
32654 PyThreadState* __tstate = wxPyBeginAllowThreads();
32655 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32656 wxPyEndAllowThreads(__tstate);
32657 if (PyErr_Occurred()) SWIG_fail;
32658 }
32659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32660 return resultobj;
32661 fail:
32662 return NULL;
32663 }
32664
32665
32666 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32667 PyObject *resultobj = 0;
32668 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32669 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32670 bool arg3 = (bool) false ;
32671 void *argp1 = 0 ;
32672 int res1 = 0 ;
32673 int res2 = 0 ;
32674 bool val3 ;
32675 int ecode3 = 0 ;
32676 PyObject * obj0 = 0 ;
32677 PyObject * obj1 = 0 ;
32678 PyObject * obj2 = 0 ;
32679 char * kwnames[] = {
32680 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32681 };
32682
32683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32685 if (!SWIG_IsOK(res1)) {
32686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32687 }
32688 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32689 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32690 if (!SWIG_IsOK(res2)) {
32691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32692 }
32693 if (obj2) {
32694 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32695 if (!SWIG_IsOK(ecode3)) {
32696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32697 }
32698 arg3 = static_cast< bool >(val3);
32699 }
32700 {
32701 PyThreadState* __tstate = wxPyBeginAllowThreads();
32702 (arg1)->Add(arg2,arg3);
32703 wxPyEndAllowThreads(__tstate);
32704 if (PyErr_Occurred()) SWIG_fail;
32705 }
32706 resultobj = SWIG_Py_Void();
32707 return resultobj;
32708 fail:
32709 return NULL;
32710 }
32711
32712
32713 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32714 PyObject *resultobj = 0;
32715 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32716 SwigValueWrapper<wxDataFormat > result;
32717 void *argp1 = 0 ;
32718 int res1 = 0 ;
32719 PyObject *swig_obj[1] ;
32720
32721 if (!args) SWIG_fail;
32722 swig_obj[0] = args;
32723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32724 if (!SWIG_IsOK(res1)) {
32725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32726 }
32727 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32728 {
32729 PyThreadState* __tstate = wxPyBeginAllowThreads();
32730 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32731 wxPyEndAllowThreads(__tstate);
32732 if (PyErr_Occurred()) SWIG_fail;
32733 }
32734 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32735 return resultobj;
32736 fail:
32737 return NULL;
32738 }
32739
32740
32741 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32742 PyObject *obj;
32743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32744 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32745 return SWIG_Py_Void();
32746 }
32747
32748 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32749 return SWIG_Python_InitShadowInstance(args);
32750 }
32751
32752 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32753 PyObject *resultobj = 0;
32754 wxString const &arg1_defvalue = wxPyEmptyString ;
32755 wxString *arg1 = (wxString *) &arg1_defvalue ;
32756 wxTextDataObject *result = 0 ;
32757 bool temp1 = false ;
32758 PyObject * obj0 = 0 ;
32759 char * kwnames[] = {
32760 (char *) "text", NULL
32761 };
32762
32763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32764 if (obj0) {
32765 {
32766 arg1 = wxString_in_helper(obj0);
32767 if (arg1 == NULL) SWIG_fail;
32768 temp1 = true;
32769 }
32770 }
32771 {
32772 PyThreadState* __tstate = wxPyBeginAllowThreads();
32773 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32774 wxPyEndAllowThreads(__tstate);
32775 if (PyErr_Occurred()) SWIG_fail;
32776 }
32777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32778 {
32779 if (temp1)
32780 delete arg1;
32781 }
32782 return resultobj;
32783 fail:
32784 {
32785 if (temp1)
32786 delete arg1;
32787 }
32788 return NULL;
32789 }
32790
32791
32792 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32793 PyObject *resultobj = 0;
32794 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32795 size_t result;
32796 void *argp1 = 0 ;
32797 int res1 = 0 ;
32798 PyObject *swig_obj[1] ;
32799
32800 if (!args) SWIG_fail;
32801 swig_obj[0] = args;
32802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32803 if (!SWIG_IsOK(res1)) {
32804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32805 }
32806 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32807 {
32808 PyThreadState* __tstate = wxPyBeginAllowThreads();
32809 result = (size_t)(arg1)->GetTextLength();
32810 wxPyEndAllowThreads(__tstate);
32811 if (PyErr_Occurred()) SWIG_fail;
32812 }
32813 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32814 return resultobj;
32815 fail:
32816 return NULL;
32817 }
32818
32819
32820 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32821 PyObject *resultobj = 0;
32822 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32823 wxString result;
32824 void *argp1 = 0 ;
32825 int res1 = 0 ;
32826 PyObject *swig_obj[1] ;
32827
32828 if (!args) SWIG_fail;
32829 swig_obj[0] = args;
32830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32831 if (!SWIG_IsOK(res1)) {
32832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32833 }
32834 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32835 {
32836 PyThreadState* __tstate = wxPyBeginAllowThreads();
32837 result = (arg1)->GetText();
32838 wxPyEndAllowThreads(__tstate);
32839 if (PyErr_Occurred()) SWIG_fail;
32840 }
32841 {
32842 #if wxUSE_UNICODE
32843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32844 #else
32845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32846 #endif
32847 }
32848 return resultobj;
32849 fail:
32850 return NULL;
32851 }
32852
32853
32854 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32855 PyObject *resultobj = 0;
32856 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32857 wxString *arg2 = 0 ;
32858 void *argp1 = 0 ;
32859 int res1 = 0 ;
32860 bool temp2 = false ;
32861 PyObject * obj0 = 0 ;
32862 PyObject * obj1 = 0 ;
32863 char * kwnames[] = {
32864 (char *) "self",(char *) "text", NULL
32865 };
32866
32867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32869 if (!SWIG_IsOK(res1)) {
32870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32871 }
32872 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32873 {
32874 arg2 = wxString_in_helper(obj1);
32875 if (arg2 == NULL) SWIG_fail;
32876 temp2 = true;
32877 }
32878 {
32879 PyThreadState* __tstate = wxPyBeginAllowThreads();
32880 (arg1)->SetText((wxString const &)*arg2);
32881 wxPyEndAllowThreads(__tstate);
32882 if (PyErr_Occurred()) SWIG_fail;
32883 }
32884 resultobj = SWIG_Py_Void();
32885 {
32886 if (temp2)
32887 delete arg2;
32888 }
32889 return resultobj;
32890 fail:
32891 {
32892 if (temp2)
32893 delete arg2;
32894 }
32895 return NULL;
32896 }
32897
32898
32899 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32900 PyObject *obj;
32901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32902 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32903 return SWIG_Py_Void();
32904 }
32905
32906 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32907 return SWIG_Python_InitShadowInstance(args);
32908 }
32909
32910 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32911 PyObject *resultobj = 0;
32912 wxString const &arg1_defvalue = wxPyEmptyString ;
32913 wxString *arg1 = (wxString *) &arg1_defvalue ;
32914 wxPyTextDataObject *result = 0 ;
32915 bool temp1 = false ;
32916 PyObject * obj0 = 0 ;
32917 char * kwnames[] = {
32918 (char *) "text", NULL
32919 };
32920
32921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32922 if (obj0) {
32923 {
32924 arg1 = wxString_in_helper(obj0);
32925 if (arg1 == NULL) SWIG_fail;
32926 temp1 = true;
32927 }
32928 }
32929 {
32930 PyThreadState* __tstate = wxPyBeginAllowThreads();
32931 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32932 wxPyEndAllowThreads(__tstate);
32933 if (PyErr_Occurred()) SWIG_fail;
32934 }
32935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32936 {
32937 if (temp1)
32938 delete arg1;
32939 }
32940 return resultobj;
32941 fail:
32942 {
32943 if (temp1)
32944 delete arg1;
32945 }
32946 return NULL;
32947 }
32948
32949
32950 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32951 PyObject *resultobj = 0;
32952 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32953 PyObject *arg2 = (PyObject *) 0 ;
32954 PyObject *arg3 = (PyObject *) 0 ;
32955 void *argp1 = 0 ;
32956 int res1 = 0 ;
32957 PyObject * obj0 = 0 ;
32958 PyObject * obj1 = 0 ;
32959 PyObject * obj2 = 0 ;
32960 char * kwnames[] = {
32961 (char *) "self",(char *) "self",(char *) "_class", NULL
32962 };
32963
32964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32966 if (!SWIG_IsOK(res1)) {
32967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32968 }
32969 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32970 arg2 = obj1;
32971 arg3 = obj2;
32972 {
32973 PyThreadState* __tstate = wxPyBeginAllowThreads();
32974 (arg1)->_setCallbackInfo(arg2,arg3);
32975 wxPyEndAllowThreads(__tstate);
32976 if (PyErr_Occurred()) SWIG_fail;
32977 }
32978 resultobj = SWIG_Py_Void();
32979 return resultobj;
32980 fail:
32981 return NULL;
32982 }
32983
32984
32985 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32986 PyObject *obj;
32987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32989 return SWIG_Py_Void();
32990 }
32991
32992 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32993 return SWIG_Python_InitShadowInstance(args);
32994 }
32995
32996 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32999 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33000 wxBitmapDataObject *result = 0 ;
33001 void *argp1 = 0 ;
33002 int res1 = 0 ;
33003 PyObject * obj0 = 0 ;
33004 char * kwnames[] = {
33005 (char *) "bitmap", NULL
33006 };
33007
33008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33009 if (obj0) {
33010 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33011 if (!SWIG_IsOK(res1)) {
33012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33013 }
33014 if (!argp1) {
33015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33016 }
33017 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33018 }
33019 {
33020 PyThreadState* __tstate = wxPyBeginAllowThreads();
33021 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33022 wxPyEndAllowThreads(__tstate);
33023 if (PyErr_Occurred()) SWIG_fail;
33024 }
33025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33033 PyObject *resultobj = 0;
33034 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33035 wxBitmap result;
33036 void *argp1 = 0 ;
33037 int res1 = 0 ;
33038 PyObject *swig_obj[1] ;
33039
33040 if (!args) SWIG_fail;
33041 swig_obj[0] = args;
33042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33043 if (!SWIG_IsOK(res1)) {
33044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33045 }
33046 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33047 {
33048 PyThreadState* __tstate = wxPyBeginAllowThreads();
33049 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33050 wxPyEndAllowThreads(__tstate);
33051 if (PyErr_Occurred()) SWIG_fail;
33052 }
33053 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33054 return resultobj;
33055 fail:
33056 return NULL;
33057 }
33058
33059
33060 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33061 PyObject *resultobj = 0;
33062 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33063 wxBitmap *arg2 = 0 ;
33064 void *argp1 = 0 ;
33065 int res1 = 0 ;
33066 void *argp2 = 0 ;
33067 int res2 = 0 ;
33068 PyObject * obj0 = 0 ;
33069 PyObject * obj1 = 0 ;
33070 char * kwnames[] = {
33071 (char *) "self",(char *) "bitmap", NULL
33072 };
33073
33074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33076 if (!SWIG_IsOK(res1)) {
33077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33078 }
33079 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33080 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33081 if (!SWIG_IsOK(res2)) {
33082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33083 }
33084 if (!argp2) {
33085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33086 }
33087 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33088 {
33089 PyThreadState* __tstate = wxPyBeginAllowThreads();
33090 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33091 wxPyEndAllowThreads(__tstate);
33092 if (PyErr_Occurred()) SWIG_fail;
33093 }
33094 resultobj = SWIG_Py_Void();
33095 return resultobj;
33096 fail:
33097 return NULL;
33098 }
33099
33100
33101 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33102 PyObject *obj;
33103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33104 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33105 return SWIG_Py_Void();
33106 }
33107
33108 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33109 return SWIG_Python_InitShadowInstance(args);
33110 }
33111
33112 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33113 PyObject *resultobj = 0;
33114 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33115 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33116 wxPyBitmapDataObject *result = 0 ;
33117 void *argp1 = 0 ;
33118 int res1 = 0 ;
33119 PyObject * obj0 = 0 ;
33120 char * kwnames[] = {
33121 (char *) "bitmap", NULL
33122 };
33123
33124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33125 if (obj0) {
33126 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33127 if (!SWIG_IsOK(res1)) {
33128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33129 }
33130 if (!argp1) {
33131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33132 }
33133 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33134 }
33135 {
33136 PyThreadState* __tstate = wxPyBeginAllowThreads();
33137 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33138 wxPyEndAllowThreads(__tstate);
33139 if (PyErr_Occurred()) SWIG_fail;
33140 }
33141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33142 return resultobj;
33143 fail:
33144 return NULL;
33145 }
33146
33147
33148 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33149 PyObject *resultobj = 0;
33150 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33151 PyObject *arg2 = (PyObject *) 0 ;
33152 PyObject *arg3 = (PyObject *) 0 ;
33153 void *argp1 = 0 ;
33154 int res1 = 0 ;
33155 PyObject * obj0 = 0 ;
33156 PyObject * obj1 = 0 ;
33157 PyObject * obj2 = 0 ;
33158 char * kwnames[] = {
33159 (char *) "self",(char *) "self",(char *) "_class", NULL
33160 };
33161
33162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33164 if (!SWIG_IsOK(res1)) {
33165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33166 }
33167 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33168 arg2 = obj1;
33169 arg3 = obj2;
33170 {
33171 PyThreadState* __tstate = wxPyBeginAllowThreads();
33172 (arg1)->_setCallbackInfo(arg2,arg3);
33173 wxPyEndAllowThreads(__tstate);
33174 if (PyErr_Occurred()) SWIG_fail;
33175 }
33176 resultobj = SWIG_Py_Void();
33177 return resultobj;
33178 fail:
33179 return NULL;
33180 }
33181
33182
33183 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33184 PyObject *obj;
33185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33186 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33187 return SWIG_Py_Void();
33188 }
33189
33190 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33191 return SWIG_Python_InitShadowInstance(args);
33192 }
33193
33194 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33195 PyObject *resultobj = 0;
33196 wxFileDataObject *result = 0 ;
33197
33198 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 result = (wxFileDataObject *)new wxFileDataObject();
33202 wxPyEndAllowThreads(__tstate);
33203 if (PyErr_Occurred()) SWIG_fail;
33204 }
33205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33213 PyObject *resultobj = 0;
33214 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33215 wxArrayString *result = 0 ;
33216 void *argp1 = 0 ;
33217 int res1 = 0 ;
33218 PyObject *swig_obj[1] ;
33219
33220 if (!args) SWIG_fail;
33221 swig_obj[0] = args;
33222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33223 if (!SWIG_IsOK(res1)) {
33224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33225 }
33226 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33227 {
33228 PyThreadState* __tstate = wxPyBeginAllowThreads();
33229 {
33230 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33231 result = (wxArrayString *) &_result_ref;
33232 }
33233 wxPyEndAllowThreads(__tstate);
33234 if (PyErr_Occurred()) SWIG_fail;
33235 }
33236 {
33237 resultobj = wxArrayString2PyList_helper(*result);
33238 }
33239 return resultobj;
33240 fail:
33241 return NULL;
33242 }
33243
33244
33245 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33246 PyObject *resultobj = 0;
33247 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33248 wxString *arg2 = 0 ;
33249 void *argp1 = 0 ;
33250 int res1 = 0 ;
33251 bool temp2 = false ;
33252 PyObject * obj0 = 0 ;
33253 PyObject * obj1 = 0 ;
33254 char * kwnames[] = {
33255 (char *) "self",(char *) "filename", NULL
33256 };
33257
33258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33260 if (!SWIG_IsOK(res1)) {
33261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33262 }
33263 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33264 {
33265 arg2 = wxString_in_helper(obj1);
33266 if (arg2 == NULL) SWIG_fail;
33267 temp2 = true;
33268 }
33269 {
33270 PyThreadState* __tstate = wxPyBeginAllowThreads();
33271 (arg1)->AddFile((wxString const &)*arg2);
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 resultobj = SWIG_Py_Void();
33276 {
33277 if (temp2)
33278 delete arg2;
33279 }
33280 return resultobj;
33281 fail:
33282 {
33283 if (temp2)
33284 delete arg2;
33285 }
33286 return NULL;
33287 }
33288
33289
33290 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33291 PyObject *obj;
33292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33293 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33294 return SWIG_Py_Void();
33295 }
33296
33297 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33298 return SWIG_Python_InitShadowInstance(args);
33299 }
33300
33301 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33302 PyObject *resultobj = 0;
33303 wxDataFormat *arg1 = 0 ;
33304 wxCustomDataObject *result = 0 ;
33305 void *argp1 = 0 ;
33306 int res1 = 0 ;
33307
33308 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33310 if (!SWIG_IsOK(res1)) {
33311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33312 }
33313 if (!argp1) {
33314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33315 }
33316 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33317 {
33318 PyThreadState* __tstate = wxPyBeginAllowThreads();
33319 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33320 wxPyEndAllowThreads(__tstate);
33321 if (PyErr_Occurred()) SWIG_fail;
33322 }
33323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33324 return resultobj;
33325 fail:
33326 return NULL;
33327 }
33328
33329
33330 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33331 PyObject *resultobj = 0;
33332 wxString *arg1 = 0 ;
33333 wxCustomDataObject *result = 0 ;
33334 bool temp1 = false ;
33335
33336 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33337 {
33338 arg1 = wxString_in_helper(swig_obj[0]);
33339 if (arg1 == NULL) SWIG_fail;
33340 temp1 = true;
33341 }
33342 {
33343 PyThreadState* __tstate = wxPyBeginAllowThreads();
33344 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33345 wxPyEndAllowThreads(__tstate);
33346 if (PyErr_Occurred()) SWIG_fail;
33347 }
33348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33349 {
33350 if (temp1)
33351 delete arg1;
33352 }
33353 return resultobj;
33354 fail:
33355 {
33356 if (temp1)
33357 delete arg1;
33358 }
33359 return NULL;
33360 }
33361
33362
33363 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33364 PyObject *resultobj = 0;
33365 wxCustomDataObject *result = 0 ;
33366
33367 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33368 {
33369 PyThreadState* __tstate = wxPyBeginAllowThreads();
33370 result = (wxCustomDataObject *)new wxCustomDataObject();
33371 wxPyEndAllowThreads(__tstate);
33372 if (PyErr_Occurred()) SWIG_fail;
33373 }
33374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33382 int argc;
33383 PyObject *argv[2];
33384
33385 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33386 --argc;
33387 if (argc == 0) {
33388 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33389 }
33390 if (argc == 1) {
33391 int _v = 0;
33392 {
33393 {
33394 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33395 }
33396 }
33397 if (!_v) goto check_2;
33398 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33399 }
33400 check_2:
33401
33402 if (argc == 1) {
33403 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33404 }
33405
33406 fail:
33407 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33408 return NULL;
33409 }
33410
33411
33412 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33413 PyObject *resultobj = 0;
33414 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33415 PyObject *arg2 = (PyObject *) 0 ;
33416 bool result;
33417 void *argp1 = 0 ;
33418 int res1 = 0 ;
33419 PyObject * obj0 = 0 ;
33420 PyObject * obj1 = 0 ;
33421 char * kwnames[] = {
33422 (char *) "self",(char *) "data", NULL
33423 };
33424
33425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33427 if (!SWIG_IsOK(res1)) {
33428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33429 }
33430 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33431 arg2 = obj1;
33432 {
33433 PyThreadState* __tstate = wxPyBeginAllowThreads();
33434 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33435 wxPyEndAllowThreads(__tstate);
33436 if (PyErr_Occurred()) SWIG_fail;
33437 }
33438 {
33439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33440 }
33441 return resultobj;
33442 fail:
33443 return NULL;
33444 }
33445
33446
33447 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33448 PyObject *resultobj = 0;
33449 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33450 size_t result;
33451 void *argp1 = 0 ;
33452 int res1 = 0 ;
33453 PyObject *swig_obj[1] ;
33454
33455 if (!args) SWIG_fail;
33456 swig_obj[0] = args;
33457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33458 if (!SWIG_IsOK(res1)) {
33459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33460 }
33461 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33462 {
33463 PyThreadState* __tstate = wxPyBeginAllowThreads();
33464 result = (size_t)(arg1)->GetSize();
33465 wxPyEndAllowThreads(__tstate);
33466 if (PyErr_Occurred()) SWIG_fail;
33467 }
33468 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33469 return resultobj;
33470 fail:
33471 return NULL;
33472 }
33473
33474
33475 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33476 PyObject *resultobj = 0;
33477 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33478 PyObject *result = 0 ;
33479 void *argp1 = 0 ;
33480 int res1 = 0 ;
33481 PyObject *swig_obj[1] ;
33482
33483 if (!args) SWIG_fail;
33484 swig_obj[0] = args;
33485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33486 if (!SWIG_IsOK(res1)) {
33487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33488 }
33489 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33490 {
33491 PyThreadState* __tstate = wxPyBeginAllowThreads();
33492 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33493 wxPyEndAllowThreads(__tstate);
33494 if (PyErr_Occurred()) SWIG_fail;
33495 }
33496 resultobj = result;
33497 return resultobj;
33498 fail:
33499 return NULL;
33500 }
33501
33502
33503 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33504 PyObject *obj;
33505 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33506 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33507 return SWIG_Py_Void();
33508 }
33509
33510 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33511 return SWIG_Python_InitShadowInstance(args);
33512 }
33513
33514 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33515 PyObject *resultobj = 0;
33516 wxString const &arg1_defvalue = wxPyEmptyString ;
33517 wxString *arg1 = (wxString *) &arg1_defvalue ;
33518 wxURLDataObject *result = 0 ;
33519 bool temp1 = false ;
33520 PyObject * obj0 = 0 ;
33521 char * kwnames[] = {
33522 (char *) "url", NULL
33523 };
33524
33525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33526 if (obj0) {
33527 {
33528 arg1 = wxString_in_helper(obj0);
33529 if (arg1 == NULL) SWIG_fail;
33530 temp1 = true;
33531 }
33532 }
33533 {
33534 PyThreadState* __tstate = wxPyBeginAllowThreads();
33535 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33536 wxPyEndAllowThreads(__tstate);
33537 if (PyErr_Occurred()) SWIG_fail;
33538 }
33539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33540 {
33541 if (temp1)
33542 delete arg1;
33543 }
33544 return resultobj;
33545 fail:
33546 {
33547 if (temp1)
33548 delete arg1;
33549 }
33550 return NULL;
33551 }
33552
33553
33554 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33555 PyObject *resultobj = 0;
33556 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33557 wxString result;
33558 void *argp1 = 0 ;
33559 int res1 = 0 ;
33560 PyObject *swig_obj[1] ;
33561
33562 if (!args) SWIG_fail;
33563 swig_obj[0] = args;
33564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33565 if (!SWIG_IsOK(res1)) {
33566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33567 }
33568 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33569 {
33570 PyThreadState* __tstate = wxPyBeginAllowThreads();
33571 result = (arg1)->GetURL();
33572 wxPyEndAllowThreads(__tstate);
33573 if (PyErr_Occurred()) SWIG_fail;
33574 }
33575 {
33576 #if wxUSE_UNICODE
33577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33578 #else
33579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33580 #endif
33581 }
33582 return resultobj;
33583 fail:
33584 return NULL;
33585 }
33586
33587
33588 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33589 PyObject *resultobj = 0;
33590 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33591 wxString *arg2 = 0 ;
33592 void *argp1 = 0 ;
33593 int res1 = 0 ;
33594 bool temp2 = false ;
33595 PyObject * obj0 = 0 ;
33596 PyObject * obj1 = 0 ;
33597 char * kwnames[] = {
33598 (char *) "self",(char *) "url", NULL
33599 };
33600
33601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33603 if (!SWIG_IsOK(res1)) {
33604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33605 }
33606 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33607 {
33608 arg2 = wxString_in_helper(obj1);
33609 if (arg2 == NULL) SWIG_fail;
33610 temp2 = true;
33611 }
33612 {
33613 PyThreadState* __tstate = wxPyBeginAllowThreads();
33614 (arg1)->SetURL((wxString const &)*arg2);
33615 wxPyEndAllowThreads(__tstate);
33616 if (PyErr_Occurred()) SWIG_fail;
33617 }
33618 resultobj = SWIG_Py_Void();
33619 {
33620 if (temp2)
33621 delete arg2;
33622 }
33623 return resultobj;
33624 fail:
33625 {
33626 if (temp2)
33627 delete arg2;
33628 }
33629 return NULL;
33630 }
33631
33632
33633 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33634 PyObject *obj;
33635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33636 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33637 return SWIG_Py_Void();
33638 }
33639
33640 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33641 return SWIG_Python_InitShadowInstance(args);
33642 }
33643
33644 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33645 PyObject *resultobj = 0;
33646 wxMetafileDataObject *result = 0 ;
33647
33648 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33649 {
33650 PyThreadState* __tstate = wxPyBeginAllowThreads();
33651 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33652 wxPyEndAllowThreads(__tstate);
33653 if (PyErr_Occurred()) SWIG_fail;
33654 }
33655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33656 return resultobj;
33657 fail:
33658 return NULL;
33659 }
33660
33661
33662 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33663 PyObject *obj;
33664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33665 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33666 return SWIG_Py_Void();
33667 }
33668
33669 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33670 return SWIG_Python_InitShadowInstance(args);
33671 }
33672
33673 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33674 PyObject *resultobj = 0;
33675 wxDragResult arg1 ;
33676 bool result;
33677 int val1 ;
33678 int ecode1 = 0 ;
33679 PyObject * obj0 = 0 ;
33680 char * kwnames[] = {
33681 (char *) "res", NULL
33682 };
33683
33684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33685 ecode1 = SWIG_AsVal_int(obj0, &val1);
33686 if (!SWIG_IsOK(ecode1)) {
33687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33688 }
33689 arg1 = static_cast< wxDragResult >(val1);
33690 {
33691 PyThreadState* __tstate = wxPyBeginAllowThreads();
33692 result = (bool)wxIsDragResultOk(arg1);
33693 wxPyEndAllowThreads(__tstate);
33694 if (PyErr_Occurred()) SWIG_fail;
33695 }
33696 {
33697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33698 }
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33706 PyObject *resultobj = 0;
33707 wxWindow *arg1 = (wxWindow *) 0 ;
33708 wxIcon const &arg2_defvalue = wxNullIcon ;
33709 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33710 wxIcon const &arg3_defvalue = wxNullIcon ;
33711 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33712 wxIcon const &arg4_defvalue = wxNullIcon ;
33713 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33714 wxPyDropSource *result = 0 ;
33715 void *argp1 = 0 ;
33716 int res1 = 0 ;
33717 void *argp2 = 0 ;
33718 int res2 = 0 ;
33719 void *argp3 = 0 ;
33720 int res3 = 0 ;
33721 void *argp4 = 0 ;
33722 int res4 = 0 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 PyObject * obj2 = 0 ;
33726 PyObject * obj3 = 0 ;
33727 char * kwnames[] = {
33728 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33729 };
33730
33731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33733 if (!SWIG_IsOK(res1)) {
33734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33735 }
33736 arg1 = reinterpret_cast< wxWindow * >(argp1);
33737 if (obj1) {
33738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33739 if (!SWIG_IsOK(res2)) {
33740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33741 }
33742 if (!argp2) {
33743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33744 }
33745 arg2 = reinterpret_cast< wxIcon * >(argp2);
33746 }
33747 if (obj2) {
33748 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33749 if (!SWIG_IsOK(res3)) {
33750 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33751 }
33752 if (!argp3) {
33753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33754 }
33755 arg3 = reinterpret_cast< wxIcon * >(argp3);
33756 }
33757 if (obj3) {
33758 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33759 if (!SWIG_IsOK(res4)) {
33760 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33761 }
33762 if (!argp4) {
33763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33764 }
33765 arg4 = reinterpret_cast< wxIcon * >(argp4);
33766 }
33767 {
33768 PyThreadState* __tstate = wxPyBeginAllowThreads();
33769 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33770 wxPyEndAllowThreads(__tstate);
33771 if (PyErr_Occurred()) SWIG_fail;
33772 }
33773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33774 return resultobj;
33775 fail:
33776 return NULL;
33777 }
33778
33779
33780 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33781 PyObject *resultobj = 0;
33782 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33783 PyObject *arg2 = (PyObject *) 0 ;
33784 PyObject *arg3 = (PyObject *) 0 ;
33785 int arg4 ;
33786 void *argp1 = 0 ;
33787 int res1 = 0 ;
33788 int val4 ;
33789 int ecode4 = 0 ;
33790 PyObject * obj0 = 0 ;
33791 PyObject * obj1 = 0 ;
33792 PyObject * obj2 = 0 ;
33793 PyObject * obj3 = 0 ;
33794 char * kwnames[] = {
33795 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33796 };
33797
33798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33802 }
33803 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33804 arg2 = obj1;
33805 arg3 = obj2;
33806 ecode4 = SWIG_AsVal_int(obj3, &val4);
33807 if (!SWIG_IsOK(ecode4)) {
33808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33809 }
33810 arg4 = static_cast< int >(val4);
33811 {
33812 PyThreadState* __tstate = wxPyBeginAllowThreads();
33813 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33814 wxPyEndAllowThreads(__tstate);
33815 if (PyErr_Occurred()) SWIG_fail;
33816 }
33817 resultobj = SWIG_Py_Void();
33818 return resultobj;
33819 fail:
33820 return NULL;
33821 }
33822
33823
33824 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33825 PyObject *resultobj = 0;
33826 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33827 void *argp1 = 0 ;
33828 int res1 = 0 ;
33829 PyObject *swig_obj[1] ;
33830
33831 if (!args) SWIG_fail;
33832 swig_obj[0] = args;
33833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33836 }
33837 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33838 {
33839 PyThreadState* __tstate = wxPyBeginAllowThreads();
33840 delete arg1;
33841
33842 wxPyEndAllowThreads(__tstate);
33843 if (PyErr_Occurred()) SWIG_fail;
33844 }
33845 resultobj = SWIG_Py_Void();
33846 return resultobj;
33847 fail:
33848 return NULL;
33849 }
33850
33851
33852 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33853 PyObject *resultobj = 0;
33854 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33855 wxDataObject *arg2 = 0 ;
33856 void *argp1 = 0 ;
33857 int res1 = 0 ;
33858 void *argp2 = 0 ;
33859 int res2 = 0 ;
33860 PyObject * obj0 = 0 ;
33861 PyObject * obj1 = 0 ;
33862 char * kwnames[] = {
33863 (char *) "self",(char *) "data", NULL
33864 };
33865
33866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33868 if (!SWIG_IsOK(res1)) {
33869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33870 }
33871 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33873 if (!SWIG_IsOK(res2)) {
33874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33875 }
33876 if (!argp2) {
33877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33878 }
33879 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33880 {
33881 PyThreadState* __tstate = wxPyBeginAllowThreads();
33882 (arg1)->SetData(*arg2);
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_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33894 PyObject *resultobj = 0;
33895 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33896 wxDataObject *result = 0 ;
33897 void *argp1 = 0 ;
33898 int res1 = 0 ;
33899 PyObject *swig_obj[1] ;
33900
33901 if (!args) SWIG_fail;
33902 swig_obj[0] = args;
33903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33904 if (!SWIG_IsOK(res1)) {
33905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33906 }
33907 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33908 {
33909 PyThreadState* __tstate = wxPyBeginAllowThreads();
33910 result = (wxDataObject *)(arg1)->GetDataObject();
33911 wxPyEndAllowThreads(__tstate);
33912 if (PyErr_Occurred()) SWIG_fail;
33913 }
33914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33915 return resultobj;
33916 fail:
33917 return NULL;
33918 }
33919
33920
33921 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33922 PyObject *resultobj = 0;
33923 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33924 wxDragResult arg2 ;
33925 wxCursor *arg3 = 0 ;
33926 void *argp1 = 0 ;
33927 int res1 = 0 ;
33928 int val2 ;
33929 int ecode2 = 0 ;
33930 void *argp3 = 0 ;
33931 int res3 = 0 ;
33932 PyObject * obj0 = 0 ;
33933 PyObject * obj1 = 0 ;
33934 PyObject * obj2 = 0 ;
33935 char * kwnames[] = {
33936 (char *) "self",(char *) "res",(char *) "cursor", NULL
33937 };
33938
33939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33941 if (!SWIG_IsOK(res1)) {
33942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33943 }
33944 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33945 ecode2 = SWIG_AsVal_int(obj1, &val2);
33946 if (!SWIG_IsOK(ecode2)) {
33947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33948 }
33949 arg2 = static_cast< wxDragResult >(val2);
33950 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33951 if (!SWIG_IsOK(res3)) {
33952 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33953 }
33954 if (!argp3) {
33955 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33956 }
33957 arg3 = reinterpret_cast< wxCursor * >(argp3);
33958 {
33959 PyThreadState* __tstate = wxPyBeginAllowThreads();
33960 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33961 wxPyEndAllowThreads(__tstate);
33962 if (PyErr_Occurred()) SWIG_fail;
33963 }
33964 resultobj = SWIG_Py_Void();
33965 return resultobj;
33966 fail:
33967 return NULL;
33968 }
33969
33970
33971 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33972 PyObject *resultobj = 0;
33973 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33974 int arg2 = (int) wxDrag_CopyOnly ;
33975 wxDragResult result;
33976 void *argp1 = 0 ;
33977 int res1 = 0 ;
33978 int val2 ;
33979 int ecode2 = 0 ;
33980 PyObject * obj0 = 0 ;
33981 PyObject * obj1 = 0 ;
33982 char * kwnames[] = {
33983 (char *) "self",(char *) "flags", NULL
33984 };
33985
33986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33988 if (!SWIG_IsOK(res1)) {
33989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33990 }
33991 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33992 if (obj1) {
33993 ecode2 = SWIG_AsVal_int(obj1, &val2);
33994 if (!SWIG_IsOK(ecode2)) {
33995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33996 }
33997 arg2 = static_cast< int >(val2);
33998 }
33999 {
34000 PyThreadState* __tstate = wxPyBeginAllowThreads();
34001 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34002 wxPyEndAllowThreads(__tstate);
34003 if (PyErr_Occurred()) SWIG_fail;
34004 }
34005 resultobj = SWIG_From_int(static_cast< int >(result));
34006 return resultobj;
34007 fail:
34008 return NULL;
34009 }
34010
34011
34012 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34013 PyObject *resultobj = 0;
34014 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34015 wxDragResult arg2 ;
34016 bool result;
34017 void *argp1 = 0 ;
34018 int res1 = 0 ;
34019 int val2 ;
34020 int ecode2 = 0 ;
34021 PyObject * obj0 = 0 ;
34022 PyObject * obj1 = 0 ;
34023 char * kwnames[] = {
34024 (char *) "self",(char *) "effect", NULL
34025 };
34026
34027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34029 if (!SWIG_IsOK(res1)) {
34030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34031 }
34032 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34033 ecode2 = SWIG_AsVal_int(obj1, &val2);
34034 if (!SWIG_IsOK(ecode2)) {
34035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34036 }
34037 arg2 = static_cast< wxDragResult >(val2);
34038 {
34039 PyThreadState* __tstate = wxPyBeginAllowThreads();
34040 result = (bool)(arg1)->GiveFeedback(arg2);
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 {
34045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34046 }
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34054 PyObject *obj;
34055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34056 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34057 return SWIG_Py_Void();
34058 }
34059
34060 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34061 return SWIG_Python_InitShadowInstance(args);
34062 }
34063
34064 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34065 PyObject *resultobj = 0;
34066 wxDataObject *arg1 = (wxDataObject *) NULL ;
34067 wxPyDropTarget *result = 0 ;
34068 int res1 = 0 ;
34069 PyObject * obj0 = 0 ;
34070 char * kwnames[] = {
34071 (char *) "dataObject", NULL
34072 };
34073
34074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34075 if (obj0) {
34076 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34077 if (!SWIG_IsOK(res1)) {
34078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34079 }
34080 }
34081 {
34082 PyThreadState* __tstate = wxPyBeginAllowThreads();
34083 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34084 wxPyEndAllowThreads(__tstate);
34085 if (PyErr_Occurred()) SWIG_fail;
34086 }
34087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34088 return resultobj;
34089 fail:
34090 return NULL;
34091 }
34092
34093
34094 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34095 PyObject *resultobj = 0;
34096 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34097 PyObject *arg2 = (PyObject *) 0 ;
34098 PyObject *arg3 = (PyObject *) 0 ;
34099 void *argp1 = 0 ;
34100 int res1 = 0 ;
34101 PyObject * obj0 = 0 ;
34102 PyObject * obj1 = 0 ;
34103 PyObject * obj2 = 0 ;
34104 char * kwnames[] = {
34105 (char *) "self",(char *) "self",(char *) "_class", NULL
34106 };
34107
34108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34110 if (!SWIG_IsOK(res1)) {
34111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34112 }
34113 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34114 arg2 = obj1;
34115 arg3 = obj2;
34116 {
34117 PyThreadState* __tstate = wxPyBeginAllowThreads();
34118 (arg1)->_setCallbackInfo(arg2,arg3);
34119 wxPyEndAllowThreads(__tstate);
34120 if (PyErr_Occurred()) SWIG_fail;
34121 }
34122 resultobj = SWIG_Py_Void();
34123 return resultobj;
34124 fail:
34125 return NULL;
34126 }
34127
34128
34129 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34130 PyObject *resultobj = 0;
34131 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34132 void *argp1 = 0 ;
34133 int res1 = 0 ;
34134 PyObject *swig_obj[1] ;
34135
34136 if (!args) SWIG_fail;
34137 swig_obj[0] = args;
34138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34139 if (!SWIG_IsOK(res1)) {
34140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34141 }
34142 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34143 {
34144 PyThreadState* __tstate = wxPyBeginAllowThreads();
34145 delete arg1;
34146
34147 wxPyEndAllowThreads(__tstate);
34148 if (PyErr_Occurred()) SWIG_fail;
34149 }
34150 resultobj = SWIG_Py_Void();
34151 return resultobj;
34152 fail:
34153 return NULL;
34154 }
34155
34156
34157 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34158 PyObject *resultobj = 0;
34159 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34160 wxDataObject *result = 0 ;
34161 void *argp1 = 0 ;
34162 int res1 = 0 ;
34163 PyObject *swig_obj[1] ;
34164
34165 if (!args) SWIG_fail;
34166 swig_obj[0] = args;
34167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34168 if (!SWIG_IsOK(res1)) {
34169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34170 }
34171 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34172 {
34173 PyThreadState* __tstate = wxPyBeginAllowThreads();
34174 result = (wxDataObject *)(arg1)->GetDataObject();
34175 wxPyEndAllowThreads(__tstate);
34176 if (PyErr_Occurred()) SWIG_fail;
34177 }
34178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34179 return resultobj;
34180 fail:
34181 return NULL;
34182 }
34183
34184
34185 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34186 PyObject *resultobj = 0;
34187 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34188 wxDataObject *arg2 = (wxDataObject *) 0 ;
34189 void *argp1 = 0 ;
34190 int res1 = 0 ;
34191 int res2 = 0 ;
34192 PyObject * obj0 = 0 ;
34193 PyObject * obj1 = 0 ;
34194 char * kwnames[] = {
34195 (char *) "self",(char *) "dataObject", NULL
34196 };
34197
34198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34200 if (!SWIG_IsOK(res1)) {
34201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34202 }
34203 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34204 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34205 if (!SWIG_IsOK(res2)) {
34206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34207 }
34208 {
34209 PyThreadState* __tstate = wxPyBeginAllowThreads();
34210 (arg1)->SetDataObject(arg2);
34211 wxPyEndAllowThreads(__tstate);
34212 if (PyErr_Occurred()) SWIG_fail;
34213 }
34214 resultobj = SWIG_Py_Void();
34215 return resultobj;
34216 fail:
34217 return NULL;
34218 }
34219
34220
34221 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34222 PyObject *resultobj = 0;
34223 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34224 int arg2 ;
34225 int arg3 ;
34226 wxDragResult arg4 ;
34227 wxDragResult result;
34228 void *argp1 = 0 ;
34229 int res1 = 0 ;
34230 int val2 ;
34231 int ecode2 = 0 ;
34232 int val3 ;
34233 int ecode3 = 0 ;
34234 int val4 ;
34235 int ecode4 = 0 ;
34236 PyObject * obj0 = 0 ;
34237 PyObject * obj1 = 0 ;
34238 PyObject * obj2 = 0 ;
34239 PyObject * obj3 = 0 ;
34240 char * kwnames[] = {
34241 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34242 };
34243
34244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34246 if (!SWIG_IsOK(res1)) {
34247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34248 }
34249 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34250 ecode2 = SWIG_AsVal_int(obj1, &val2);
34251 if (!SWIG_IsOK(ecode2)) {
34252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34253 }
34254 arg2 = static_cast< int >(val2);
34255 ecode3 = SWIG_AsVal_int(obj2, &val3);
34256 if (!SWIG_IsOK(ecode3)) {
34257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34258 }
34259 arg3 = static_cast< int >(val3);
34260 ecode4 = SWIG_AsVal_int(obj3, &val4);
34261 if (!SWIG_IsOK(ecode4)) {
34262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34263 }
34264 arg4 = static_cast< wxDragResult >(val4);
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34268 wxPyEndAllowThreads(__tstate);
34269 if (PyErr_Occurred()) SWIG_fail;
34270 }
34271 resultobj = SWIG_From_int(static_cast< int >(result));
34272 return resultobj;
34273 fail:
34274 return NULL;
34275 }
34276
34277
34278 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34279 PyObject *resultobj = 0;
34280 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34281 int arg2 ;
34282 int arg3 ;
34283 wxDragResult arg4 ;
34284 wxDragResult result;
34285 void *argp1 = 0 ;
34286 int res1 = 0 ;
34287 int val2 ;
34288 int ecode2 = 0 ;
34289 int val3 ;
34290 int ecode3 = 0 ;
34291 int val4 ;
34292 int ecode4 = 0 ;
34293 PyObject * obj0 = 0 ;
34294 PyObject * obj1 = 0 ;
34295 PyObject * obj2 = 0 ;
34296 PyObject * obj3 = 0 ;
34297 char * kwnames[] = {
34298 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34299 };
34300
34301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34303 if (!SWIG_IsOK(res1)) {
34304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34305 }
34306 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34307 ecode2 = SWIG_AsVal_int(obj1, &val2);
34308 if (!SWIG_IsOK(ecode2)) {
34309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34310 }
34311 arg2 = static_cast< int >(val2);
34312 ecode3 = SWIG_AsVal_int(obj2, &val3);
34313 if (!SWIG_IsOK(ecode3)) {
34314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34315 }
34316 arg3 = static_cast< int >(val3);
34317 ecode4 = SWIG_AsVal_int(obj3, &val4);
34318 if (!SWIG_IsOK(ecode4)) {
34319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34320 }
34321 arg4 = static_cast< wxDragResult >(val4);
34322 {
34323 PyThreadState* __tstate = wxPyBeginAllowThreads();
34324 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34325 wxPyEndAllowThreads(__tstate);
34326 if (PyErr_Occurred()) SWIG_fail;
34327 }
34328 resultobj = SWIG_From_int(static_cast< int >(result));
34329 return resultobj;
34330 fail:
34331 return NULL;
34332 }
34333
34334
34335 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34336 PyObject *resultobj = 0;
34337 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34338 void *argp1 = 0 ;
34339 int res1 = 0 ;
34340 PyObject *swig_obj[1] ;
34341
34342 if (!args) SWIG_fail;
34343 swig_obj[0] = args;
34344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34345 if (!SWIG_IsOK(res1)) {
34346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34347 }
34348 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34349 {
34350 PyThreadState* __tstate = wxPyBeginAllowThreads();
34351 (arg1)->OnLeave();
34352 wxPyEndAllowThreads(__tstate);
34353 if (PyErr_Occurred()) SWIG_fail;
34354 }
34355 resultobj = SWIG_Py_Void();
34356 return resultobj;
34357 fail:
34358 return NULL;
34359 }
34360
34361
34362 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34363 PyObject *resultobj = 0;
34364 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34365 int arg2 ;
34366 int arg3 ;
34367 bool result;
34368 void *argp1 = 0 ;
34369 int res1 = 0 ;
34370 int val2 ;
34371 int ecode2 = 0 ;
34372 int val3 ;
34373 int ecode3 = 0 ;
34374 PyObject * obj0 = 0 ;
34375 PyObject * obj1 = 0 ;
34376 PyObject * obj2 = 0 ;
34377 char * kwnames[] = {
34378 (char *) "self",(char *) "x",(char *) "y", NULL
34379 };
34380
34381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34383 if (!SWIG_IsOK(res1)) {
34384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34385 }
34386 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34387 ecode2 = SWIG_AsVal_int(obj1, &val2);
34388 if (!SWIG_IsOK(ecode2)) {
34389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34390 }
34391 arg2 = static_cast< int >(val2);
34392 ecode3 = SWIG_AsVal_int(obj2, &val3);
34393 if (!SWIG_IsOK(ecode3)) {
34394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34395 }
34396 arg3 = static_cast< int >(val3);
34397 {
34398 PyThreadState* __tstate = wxPyBeginAllowThreads();
34399 result = (bool)(arg1)->OnDrop(arg2,arg3);
34400 wxPyEndAllowThreads(__tstate);
34401 if (PyErr_Occurred()) SWIG_fail;
34402 }
34403 {
34404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34405 }
34406 return resultobj;
34407 fail:
34408 return NULL;
34409 }
34410
34411
34412 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34413 PyObject *resultobj = 0;
34414 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34415 bool result;
34416 void *argp1 = 0 ;
34417 int res1 = 0 ;
34418 PyObject *swig_obj[1] ;
34419
34420 if (!args) SWIG_fail;
34421 swig_obj[0] = args;
34422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34423 if (!SWIG_IsOK(res1)) {
34424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34425 }
34426 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34427 {
34428 PyThreadState* __tstate = wxPyBeginAllowThreads();
34429 result = (bool)(arg1)->GetData();
34430 wxPyEndAllowThreads(__tstate);
34431 if (PyErr_Occurred()) SWIG_fail;
34432 }
34433 {
34434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34435 }
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34443 PyObject *resultobj = 0;
34444 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34445 wxDragResult arg2 ;
34446 void *argp1 = 0 ;
34447 int res1 = 0 ;
34448 int val2 ;
34449 int ecode2 = 0 ;
34450 PyObject * obj0 = 0 ;
34451 PyObject * obj1 = 0 ;
34452 char * kwnames[] = {
34453 (char *) "self",(char *) "action", NULL
34454 };
34455
34456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34458 if (!SWIG_IsOK(res1)) {
34459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34460 }
34461 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34462 ecode2 = SWIG_AsVal_int(obj1, &val2);
34463 if (!SWIG_IsOK(ecode2)) {
34464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34465 }
34466 arg2 = static_cast< wxDragResult >(val2);
34467 {
34468 PyThreadState* __tstate = wxPyBeginAllowThreads();
34469 (arg1)->SetDefaultAction(arg2);
34470 wxPyEndAllowThreads(__tstate);
34471 if (PyErr_Occurred()) SWIG_fail;
34472 }
34473 resultobj = SWIG_Py_Void();
34474 return resultobj;
34475 fail:
34476 return NULL;
34477 }
34478
34479
34480 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34481 PyObject *resultobj = 0;
34482 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34483 wxDragResult result;
34484 void *argp1 = 0 ;
34485 int res1 = 0 ;
34486 PyObject *swig_obj[1] ;
34487
34488 if (!args) SWIG_fail;
34489 swig_obj[0] = args;
34490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34491 if (!SWIG_IsOK(res1)) {
34492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34493 }
34494 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34495 {
34496 PyThreadState* __tstate = wxPyBeginAllowThreads();
34497 result = (wxDragResult)(arg1)->GetDefaultAction();
34498 wxPyEndAllowThreads(__tstate);
34499 if (PyErr_Occurred()) SWIG_fail;
34500 }
34501 resultobj = SWIG_From_int(static_cast< int >(result));
34502 return resultobj;
34503 fail:
34504 return NULL;
34505 }
34506
34507
34508 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34509 PyObject *obj;
34510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34511 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34512 return SWIG_Py_Void();
34513 }
34514
34515 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34516 return SWIG_Python_InitShadowInstance(args);
34517 }
34518
34519 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34520 PyObject *resultobj = 0;
34521 wxPyTextDropTarget *result = 0 ;
34522
34523 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34524 {
34525 PyThreadState* __tstate = wxPyBeginAllowThreads();
34526 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34527 wxPyEndAllowThreads(__tstate);
34528 if (PyErr_Occurred()) SWIG_fail;
34529 }
34530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34531 return resultobj;
34532 fail:
34533 return NULL;
34534 }
34535
34536
34537 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34538 PyObject *resultobj = 0;
34539 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34540 PyObject *arg2 = (PyObject *) 0 ;
34541 PyObject *arg3 = (PyObject *) 0 ;
34542 void *argp1 = 0 ;
34543 int res1 = 0 ;
34544 PyObject * obj0 = 0 ;
34545 PyObject * obj1 = 0 ;
34546 PyObject * obj2 = 0 ;
34547 char * kwnames[] = {
34548 (char *) "self",(char *) "self",(char *) "_class", NULL
34549 };
34550
34551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34553 if (!SWIG_IsOK(res1)) {
34554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34555 }
34556 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34557 arg2 = obj1;
34558 arg3 = obj2;
34559 {
34560 PyThreadState* __tstate = wxPyBeginAllowThreads();
34561 (arg1)->_setCallbackInfo(arg2,arg3);
34562 wxPyEndAllowThreads(__tstate);
34563 if (PyErr_Occurred()) SWIG_fail;
34564 }
34565 resultobj = SWIG_Py_Void();
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34573 PyObject *resultobj = 0;
34574 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34575 int arg2 ;
34576 int arg3 ;
34577 wxString *arg4 = 0 ;
34578 bool result;
34579 void *argp1 = 0 ;
34580 int res1 = 0 ;
34581 int val2 ;
34582 int ecode2 = 0 ;
34583 int val3 ;
34584 int ecode3 = 0 ;
34585 bool temp4 = false ;
34586 PyObject * obj0 = 0 ;
34587 PyObject * obj1 = 0 ;
34588 PyObject * obj2 = 0 ;
34589 PyObject * obj3 = 0 ;
34590 char * kwnames[] = {
34591 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34592 };
34593
34594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34596 if (!SWIG_IsOK(res1)) {
34597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34598 }
34599 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34600 ecode2 = SWIG_AsVal_int(obj1, &val2);
34601 if (!SWIG_IsOK(ecode2)) {
34602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34603 }
34604 arg2 = static_cast< int >(val2);
34605 ecode3 = SWIG_AsVal_int(obj2, &val3);
34606 if (!SWIG_IsOK(ecode3)) {
34607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34608 }
34609 arg3 = static_cast< int >(val3);
34610 {
34611 arg4 = wxString_in_helper(obj3);
34612 if (arg4 == NULL) SWIG_fail;
34613 temp4 = true;
34614 }
34615 {
34616 PyThreadState* __tstate = wxPyBeginAllowThreads();
34617 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34618 wxPyEndAllowThreads(__tstate);
34619 if (PyErr_Occurred()) SWIG_fail;
34620 }
34621 {
34622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34623 }
34624 {
34625 if (temp4)
34626 delete arg4;
34627 }
34628 return resultobj;
34629 fail:
34630 {
34631 if (temp4)
34632 delete arg4;
34633 }
34634 return NULL;
34635 }
34636
34637
34638 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34639 PyObject *resultobj = 0;
34640 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34641 int arg2 ;
34642 int arg3 ;
34643 wxDragResult arg4 ;
34644 wxDragResult result;
34645 void *argp1 = 0 ;
34646 int res1 = 0 ;
34647 int val2 ;
34648 int ecode2 = 0 ;
34649 int val3 ;
34650 int ecode3 = 0 ;
34651 int val4 ;
34652 int ecode4 = 0 ;
34653 PyObject * obj0 = 0 ;
34654 PyObject * obj1 = 0 ;
34655 PyObject * obj2 = 0 ;
34656 PyObject * obj3 = 0 ;
34657 char * kwnames[] = {
34658 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34659 };
34660
34661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34663 if (!SWIG_IsOK(res1)) {
34664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34665 }
34666 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34667 ecode2 = SWIG_AsVal_int(obj1, &val2);
34668 if (!SWIG_IsOK(ecode2)) {
34669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34670 }
34671 arg2 = static_cast< int >(val2);
34672 ecode3 = SWIG_AsVal_int(obj2, &val3);
34673 if (!SWIG_IsOK(ecode3)) {
34674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34675 }
34676 arg3 = static_cast< int >(val3);
34677 ecode4 = SWIG_AsVal_int(obj3, &val4);
34678 if (!SWIG_IsOK(ecode4)) {
34679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34680 }
34681 arg4 = static_cast< wxDragResult >(val4);
34682 {
34683 PyThreadState* __tstate = wxPyBeginAllowThreads();
34684 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34685 wxPyEndAllowThreads(__tstate);
34686 if (PyErr_Occurred()) SWIG_fail;
34687 }
34688 resultobj = SWIG_From_int(static_cast< int >(result));
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj = 0;
34697 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34698 int arg2 ;
34699 int arg3 ;
34700 wxDragResult arg4 ;
34701 wxDragResult result;
34702 void *argp1 = 0 ;
34703 int res1 = 0 ;
34704 int val2 ;
34705 int ecode2 = 0 ;
34706 int val3 ;
34707 int ecode3 = 0 ;
34708 int val4 ;
34709 int ecode4 = 0 ;
34710 PyObject * obj0 = 0 ;
34711 PyObject * obj1 = 0 ;
34712 PyObject * obj2 = 0 ;
34713 PyObject * obj3 = 0 ;
34714 char * kwnames[] = {
34715 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34716 };
34717
34718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34720 if (!SWIG_IsOK(res1)) {
34721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34722 }
34723 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34724 ecode2 = SWIG_AsVal_int(obj1, &val2);
34725 if (!SWIG_IsOK(ecode2)) {
34726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34727 }
34728 arg2 = static_cast< int >(val2);
34729 ecode3 = SWIG_AsVal_int(obj2, &val3);
34730 if (!SWIG_IsOK(ecode3)) {
34731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34732 }
34733 arg3 = static_cast< int >(val3);
34734 ecode4 = SWIG_AsVal_int(obj3, &val4);
34735 if (!SWIG_IsOK(ecode4)) {
34736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34737 }
34738 arg4 = static_cast< wxDragResult >(val4);
34739 {
34740 PyThreadState* __tstate = wxPyBeginAllowThreads();
34741 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 resultobj = SWIG_From_int(static_cast< int >(result));
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34753 PyObject *resultobj = 0;
34754 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 PyObject *swig_obj[1] ;
34758
34759 if (!args) SWIG_fail;
34760 swig_obj[0] = args;
34761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34762 if (!SWIG_IsOK(res1)) {
34763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34764 }
34765 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34766 {
34767 PyThreadState* __tstate = wxPyBeginAllowThreads();
34768 (arg1)->OnLeave();
34769 wxPyEndAllowThreads(__tstate);
34770 if (PyErr_Occurred()) SWIG_fail;
34771 }
34772 resultobj = SWIG_Py_Void();
34773 return resultobj;
34774 fail:
34775 return NULL;
34776 }
34777
34778
34779 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34780 PyObject *resultobj = 0;
34781 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34782 int arg2 ;
34783 int arg3 ;
34784 bool result;
34785 void *argp1 = 0 ;
34786 int res1 = 0 ;
34787 int val2 ;
34788 int ecode2 = 0 ;
34789 int val3 ;
34790 int ecode3 = 0 ;
34791 PyObject * obj0 = 0 ;
34792 PyObject * obj1 = 0 ;
34793 PyObject * obj2 = 0 ;
34794 char * kwnames[] = {
34795 (char *) "self",(char *) "x",(char *) "y", NULL
34796 };
34797
34798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34800 if (!SWIG_IsOK(res1)) {
34801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34802 }
34803 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34804 ecode2 = SWIG_AsVal_int(obj1, &val2);
34805 if (!SWIG_IsOK(ecode2)) {
34806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34807 }
34808 arg2 = static_cast< int >(val2);
34809 ecode3 = SWIG_AsVal_int(obj2, &val3);
34810 if (!SWIG_IsOK(ecode3)) {
34811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34812 }
34813 arg3 = static_cast< int >(val3);
34814 {
34815 PyThreadState* __tstate = wxPyBeginAllowThreads();
34816 result = (bool)(arg1)->OnDrop(arg2,arg3);
34817 wxPyEndAllowThreads(__tstate);
34818 if (PyErr_Occurred()) SWIG_fail;
34819 }
34820 {
34821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34822 }
34823 return resultobj;
34824 fail:
34825 return NULL;
34826 }
34827
34828
34829 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34830 PyObject *resultobj = 0;
34831 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34832 int arg2 ;
34833 int arg3 ;
34834 wxDragResult arg4 ;
34835 wxDragResult result;
34836 void *argp1 = 0 ;
34837 int res1 = 0 ;
34838 int val2 ;
34839 int ecode2 = 0 ;
34840 int val3 ;
34841 int ecode3 = 0 ;
34842 int val4 ;
34843 int ecode4 = 0 ;
34844 PyObject * obj0 = 0 ;
34845 PyObject * obj1 = 0 ;
34846 PyObject * obj2 = 0 ;
34847 PyObject * obj3 = 0 ;
34848 char * kwnames[] = {
34849 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34850 };
34851
34852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34854 if (!SWIG_IsOK(res1)) {
34855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34856 }
34857 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34858 ecode2 = SWIG_AsVal_int(obj1, &val2);
34859 if (!SWIG_IsOK(ecode2)) {
34860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34861 }
34862 arg2 = static_cast< int >(val2);
34863 ecode3 = SWIG_AsVal_int(obj2, &val3);
34864 if (!SWIG_IsOK(ecode3)) {
34865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34866 }
34867 arg3 = static_cast< int >(val3);
34868 ecode4 = SWIG_AsVal_int(obj3, &val4);
34869 if (!SWIG_IsOK(ecode4)) {
34870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34871 }
34872 arg4 = static_cast< wxDragResult >(val4);
34873 {
34874 PyThreadState* __tstate = wxPyBeginAllowThreads();
34875 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34876 wxPyEndAllowThreads(__tstate);
34877 if (PyErr_Occurred()) SWIG_fail;
34878 }
34879 resultobj = SWIG_From_int(static_cast< int >(result));
34880 return resultobj;
34881 fail:
34882 return NULL;
34883 }
34884
34885
34886 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34887 PyObject *obj;
34888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34889 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34890 return SWIG_Py_Void();
34891 }
34892
34893 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34894 return SWIG_Python_InitShadowInstance(args);
34895 }
34896
34897 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34898 PyObject *resultobj = 0;
34899 wxPyFileDropTarget *result = 0 ;
34900
34901 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34902 {
34903 PyThreadState* __tstate = wxPyBeginAllowThreads();
34904 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34905 wxPyEndAllowThreads(__tstate);
34906 if (PyErr_Occurred()) SWIG_fail;
34907 }
34908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34909 return resultobj;
34910 fail:
34911 return NULL;
34912 }
34913
34914
34915 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34916 PyObject *resultobj = 0;
34917 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34918 PyObject *arg2 = (PyObject *) 0 ;
34919 PyObject *arg3 = (PyObject *) 0 ;
34920 void *argp1 = 0 ;
34921 int res1 = 0 ;
34922 PyObject * obj0 = 0 ;
34923 PyObject * obj1 = 0 ;
34924 PyObject * obj2 = 0 ;
34925 char * kwnames[] = {
34926 (char *) "self",(char *) "self",(char *) "_class", NULL
34927 };
34928
34929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34931 if (!SWIG_IsOK(res1)) {
34932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34933 }
34934 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34935 arg2 = obj1;
34936 arg3 = obj2;
34937 {
34938 PyThreadState* __tstate = wxPyBeginAllowThreads();
34939 (arg1)->_setCallbackInfo(arg2,arg3);
34940 wxPyEndAllowThreads(__tstate);
34941 if (PyErr_Occurred()) SWIG_fail;
34942 }
34943 resultobj = SWIG_Py_Void();
34944 return resultobj;
34945 fail:
34946 return NULL;
34947 }
34948
34949
34950 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34951 PyObject *resultobj = 0;
34952 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34953 int arg2 ;
34954 int arg3 ;
34955 wxArrayString *arg4 = 0 ;
34956 bool result;
34957 void *argp1 = 0 ;
34958 int res1 = 0 ;
34959 int val2 ;
34960 int ecode2 = 0 ;
34961 int val3 ;
34962 int ecode3 = 0 ;
34963 bool temp4 = false ;
34964 PyObject * obj0 = 0 ;
34965 PyObject * obj1 = 0 ;
34966 PyObject * obj2 = 0 ;
34967 PyObject * obj3 = 0 ;
34968 char * kwnames[] = {
34969 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34970 };
34971
34972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34974 if (!SWIG_IsOK(res1)) {
34975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34976 }
34977 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34978 ecode2 = SWIG_AsVal_int(obj1, &val2);
34979 if (!SWIG_IsOK(ecode2)) {
34980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34981 }
34982 arg2 = static_cast< int >(val2);
34983 ecode3 = SWIG_AsVal_int(obj2, &val3);
34984 if (!SWIG_IsOK(ecode3)) {
34985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34986 }
34987 arg3 = static_cast< int >(val3);
34988 {
34989 if (! PySequence_Check(obj3)) {
34990 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34991 SWIG_fail;
34992 }
34993 arg4 = new wxArrayString;
34994 temp4 = true;
34995 int i, len=PySequence_Length(obj3);
34996 for (i=0; i<len; i++) {
34997 PyObject* item = PySequence_GetItem(obj3, i);
34998 wxString* s = wxString_in_helper(item);
34999 if (PyErr_Occurred()) SWIG_fail;
35000 arg4->Add(*s);
35001 delete s;
35002 Py_DECREF(item);
35003 }
35004 }
35005 {
35006 PyThreadState* __tstate = wxPyBeginAllowThreads();
35007 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35008 wxPyEndAllowThreads(__tstate);
35009 if (PyErr_Occurred()) SWIG_fail;
35010 }
35011 {
35012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35013 }
35014 {
35015 if (temp4) delete arg4;
35016 }
35017 return resultobj;
35018 fail:
35019 {
35020 if (temp4) delete arg4;
35021 }
35022 return NULL;
35023 }
35024
35025
35026 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35027 PyObject *resultobj = 0;
35028 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35029 int arg2 ;
35030 int arg3 ;
35031 wxDragResult arg4 ;
35032 wxDragResult result;
35033 void *argp1 = 0 ;
35034 int res1 = 0 ;
35035 int val2 ;
35036 int ecode2 = 0 ;
35037 int val3 ;
35038 int ecode3 = 0 ;
35039 int val4 ;
35040 int ecode4 = 0 ;
35041 PyObject * obj0 = 0 ;
35042 PyObject * obj1 = 0 ;
35043 PyObject * obj2 = 0 ;
35044 PyObject * obj3 = 0 ;
35045 char * kwnames[] = {
35046 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35047 };
35048
35049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35051 if (!SWIG_IsOK(res1)) {
35052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35053 }
35054 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35055 ecode2 = SWIG_AsVal_int(obj1, &val2);
35056 if (!SWIG_IsOK(ecode2)) {
35057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35058 }
35059 arg2 = static_cast< int >(val2);
35060 ecode3 = SWIG_AsVal_int(obj2, &val3);
35061 if (!SWIG_IsOK(ecode3)) {
35062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35063 }
35064 arg3 = static_cast< int >(val3);
35065 ecode4 = SWIG_AsVal_int(obj3, &val4);
35066 if (!SWIG_IsOK(ecode4)) {
35067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35068 }
35069 arg4 = static_cast< wxDragResult >(val4);
35070 {
35071 PyThreadState* __tstate = wxPyBeginAllowThreads();
35072 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 resultobj = SWIG_From_int(static_cast< int >(result));
35077 return resultobj;
35078 fail:
35079 return NULL;
35080 }
35081
35082
35083 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35084 PyObject *resultobj = 0;
35085 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35086 int arg2 ;
35087 int arg3 ;
35088 wxDragResult arg4 ;
35089 wxDragResult result;
35090 void *argp1 = 0 ;
35091 int res1 = 0 ;
35092 int val2 ;
35093 int ecode2 = 0 ;
35094 int val3 ;
35095 int ecode3 = 0 ;
35096 int val4 ;
35097 int ecode4 = 0 ;
35098 PyObject * obj0 = 0 ;
35099 PyObject * obj1 = 0 ;
35100 PyObject * obj2 = 0 ;
35101 PyObject * obj3 = 0 ;
35102 char * kwnames[] = {
35103 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35104 };
35105
35106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35108 if (!SWIG_IsOK(res1)) {
35109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35110 }
35111 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35112 ecode2 = SWIG_AsVal_int(obj1, &val2);
35113 if (!SWIG_IsOK(ecode2)) {
35114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35115 }
35116 arg2 = static_cast< int >(val2);
35117 ecode3 = SWIG_AsVal_int(obj2, &val3);
35118 if (!SWIG_IsOK(ecode3)) {
35119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35120 }
35121 arg3 = static_cast< int >(val3);
35122 ecode4 = SWIG_AsVal_int(obj3, &val4);
35123 if (!SWIG_IsOK(ecode4)) {
35124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35125 }
35126 arg4 = static_cast< wxDragResult >(val4);
35127 {
35128 PyThreadState* __tstate = wxPyBeginAllowThreads();
35129 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35130 wxPyEndAllowThreads(__tstate);
35131 if (PyErr_Occurred()) SWIG_fail;
35132 }
35133 resultobj = SWIG_From_int(static_cast< int >(result));
35134 return resultobj;
35135 fail:
35136 return NULL;
35137 }
35138
35139
35140 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35141 PyObject *resultobj = 0;
35142 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35143 void *argp1 = 0 ;
35144 int res1 = 0 ;
35145 PyObject *swig_obj[1] ;
35146
35147 if (!args) SWIG_fail;
35148 swig_obj[0] = args;
35149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35150 if (!SWIG_IsOK(res1)) {
35151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35152 }
35153 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35154 {
35155 PyThreadState* __tstate = wxPyBeginAllowThreads();
35156 (arg1)->OnLeave();
35157 wxPyEndAllowThreads(__tstate);
35158 if (PyErr_Occurred()) SWIG_fail;
35159 }
35160 resultobj = SWIG_Py_Void();
35161 return resultobj;
35162 fail:
35163 return NULL;
35164 }
35165
35166
35167 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35168 PyObject *resultobj = 0;
35169 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35170 int arg2 ;
35171 int arg3 ;
35172 bool result;
35173 void *argp1 = 0 ;
35174 int res1 = 0 ;
35175 int val2 ;
35176 int ecode2 = 0 ;
35177 int val3 ;
35178 int ecode3 = 0 ;
35179 PyObject * obj0 = 0 ;
35180 PyObject * obj1 = 0 ;
35181 PyObject * obj2 = 0 ;
35182 char * kwnames[] = {
35183 (char *) "self",(char *) "x",(char *) "y", NULL
35184 };
35185
35186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35188 if (!SWIG_IsOK(res1)) {
35189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35190 }
35191 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35192 ecode2 = SWIG_AsVal_int(obj1, &val2);
35193 if (!SWIG_IsOK(ecode2)) {
35194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35195 }
35196 arg2 = static_cast< int >(val2);
35197 ecode3 = SWIG_AsVal_int(obj2, &val3);
35198 if (!SWIG_IsOK(ecode3)) {
35199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35200 }
35201 arg3 = static_cast< int >(val3);
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 result = (bool)(arg1)->OnDrop(arg2,arg3);
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 {
35209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35210 }
35211 return resultobj;
35212 fail:
35213 return NULL;
35214 }
35215
35216
35217 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35218 PyObject *resultobj = 0;
35219 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35220 int arg2 ;
35221 int arg3 ;
35222 wxDragResult arg4 ;
35223 wxDragResult result;
35224 void *argp1 = 0 ;
35225 int res1 = 0 ;
35226 int val2 ;
35227 int ecode2 = 0 ;
35228 int val3 ;
35229 int ecode3 = 0 ;
35230 int val4 ;
35231 int ecode4 = 0 ;
35232 PyObject * obj0 = 0 ;
35233 PyObject * obj1 = 0 ;
35234 PyObject * obj2 = 0 ;
35235 PyObject * obj3 = 0 ;
35236 char * kwnames[] = {
35237 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35238 };
35239
35240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35242 if (!SWIG_IsOK(res1)) {
35243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35244 }
35245 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35246 ecode2 = SWIG_AsVal_int(obj1, &val2);
35247 if (!SWIG_IsOK(ecode2)) {
35248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35249 }
35250 arg2 = static_cast< int >(val2);
35251 ecode3 = SWIG_AsVal_int(obj2, &val3);
35252 if (!SWIG_IsOK(ecode3)) {
35253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35254 }
35255 arg3 = static_cast< int >(val3);
35256 ecode4 = SWIG_AsVal_int(obj3, &val4);
35257 if (!SWIG_IsOK(ecode4)) {
35258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35259 }
35260 arg4 = static_cast< wxDragResult >(val4);
35261 {
35262 PyThreadState* __tstate = wxPyBeginAllowThreads();
35263 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35264 wxPyEndAllowThreads(__tstate);
35265 if (PyErr_Occurred()) SWIG_fail;
35266 }
35267 resultobj = SWIG_From_int(static_cast< int >(result));
35268 return resultobj;
35269 fail:
35270 return NULL;
35271 }
35272
35273
35274 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35275 PyObject *obj;
35276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35277 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35278 return SWIG_Py_Void();
35279 }
35280
35281 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35282 return SWIG_Python_InitShadowInstance(args);
35283 }
35284
35285 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35286 PyObject *resultobj = 0;
35287 wxClipboard *result = 0 ;
35288
35289 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35290 {
35291 PyThreadState* __tstate = wxPyBeginAllowThreads();
35292 result = (wxClipboard *)new wxClipboard();
35293 wxPyEndAllowThreads(__tstate);
35294 if (PyErr_Occurred()) SWIG_fail;
35295 }
35296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35297 return resultobj;
35298 fail:
35299 return NULL;
35300 }
35301
35302
35303 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35304 PyObject *resultobj = 0;
35305 wxClipboard *arg1 = (wxClipboard *) 0 ;
35306 void *argp1 = 0 ;
35307 int res1 = 0 ;
35308 PyObject *swig_obj[1] ;
35309
35310 if (!args) SWIG_fail;
35311 swig_obj[0] = args;
35312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35313 if (!SWIG_IsOK(res1)) {
35314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35315 }
35316 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35317 {
35318 PyThreadState* __tstate = wxPyBeginAllowThreads();
35319 delete arg1;
35320
35321 wxPyEndAllowThreads(__tstate);
35322 if (PyErr_Occurred()) SWIG_fail;
35323 }
35324 resultobj = SWIG_Py_Void();
35325 return resultobj;
35326 fail:
35327 return NULL;
35328 }
35329
35330
35331 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35332 PyObject *resultobj = 0;
35333 wxClipboard *arg1 = (wxClipboard *) 0 ;
35334 bool result;
35335 void *argp1 = 0 ;
35336 int res1 = 0 ;
35337 PyObject *swig_obj[1] ;
35338
35339 if (!args) SWIG_fail;
35340 swig_obj[0] = args;
35341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35342 if (!SWIG_IsOK(res1)) {
35343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35344 }
35345 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35346 {
35347 PyThreadState* __tstate = wxPyBeginAllowThreads();
35348 result = (bool)(arg1)->Open();
35349 wxPyEndAllowThreads(__tstate);
35350 if (PyErr_Occurred()) SWIG_fail;
35351 }
35352 {
35353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35354 }
35355 return resultobj;
35356 fail:
35357 return NULL;
35358 }
35359
35360
35361 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35362 PyObject *resultobj = 0;
35363 wxClipboard *arg1 = (wxClipboard *) 0 ;
35364 void *argp1 = 0 ;
35365 int res1 = 0 ;
35366 PyObject *swig_obj[1] ;
35367
35368 if (!args) SWIG_fail;
35369 swig_obj[0] = args;
35370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35371 if (!SWIG_IsOK(res1)) {
35372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35373 }
35374 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 (arg1)->Close();
35378 wxPyEndAllowThreads(__tstate);
35379 if (PyErr_Occurred()) SWIG_fail;
35380 }
35381 resultobj = SWIG_Py_Void();
35382 return resultobj;
35383 fail:
35384 return NULL;
35385 }
35386
35387
35388 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35389 PyObject *resultobj = 0;
35390 wxClipboard *arg1 = (wxClipboard *) 0 ;
35391 bool result;
35392 void *argp1 = 0 ;
35393 int res1 = 0 ;
35394 PyObject *swig_obj[1] ;
35395
35396 if (!args) SWIG_fail;
35397 swig_obj[0] = args;
35398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35399 if (!SWIG_IsOK(res1)) {
35400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35401 }
35402 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35403 {
35404 PyThreadState* __tstate = wxPyBeginAllowThreads();
35405 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35406 wxPyEndAllowThreads(__tstate);
35407 if (PyErr_Occurred()) SWIG_fail;
35408 }
35409 {
35410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35411 }
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35419 PyObject *resultobj = 0;
35420 wxClipboard *arg1 = (wxClipboard *) 0 ;
35421 wxDataObject *arg2 = (wxDataObject *) 0 ;
35422 bool result;
35423 void *argp1 = 0 ;
35424 int res1 = 0 ;
35425 int res2 = 0 ;
35426 PyObject * obj0 = 0 ;
35427 PyObject * obj1 = 0 ;
35428 char * kwnames[] = {
35429 (char *) "self",(char *) "data", NULL
35430 };
35431
35432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35434 if (!SWIG_IsOK(res1)) {
35435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35436 }
35437 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35438 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35439 if (!SWIG_IsOK(res2)) {
35440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35441 }
35442 {
35443 PyThreadState* __tstate = wxPyBeginAllowThreads();
35444 result = (bool)(arg1)->AddData(arg2);
35445 wxPyEndAllowThreads(__tstate);
35446 if (PyErr_Occurred()) SWIG_fail;
35447 }
35448 {
35449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35450 }
35451 return resultobj;
35452 fail:
35453 return NULL;
35454 }
35455
35456
35457 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35458 PyObject *resultobj = 0;
35459 wxClipboard *arg1 = (wxClipboard *) 0 ;
35460 wxDataObject *arg2 = (wxDataObject *) 0 ;
35461 bool result;
35462 void *argp1 = 0 ;
35463 int res1 = 0 ;
35464 int res2 = 0 ;
35465 PyObject * obj0 = 0 ;
35466 PyObject * obj1 = 0 ;
35467 char * kwnames[] = {
35468 (char *) "self",(char *) "data", NULL
35469 };
35470
35471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35473 if (!SWIG_IsOK(res1)) {
35474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35475 }
35476 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35477 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35478 if (!SWIG_IsOK(res2)) {
35479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35480 }
35481 {
35482 PyThreadState* __tstate = wxPyBeginAllowThreads();
35483 result = (bool)(arg1)->SetData(arg2);
35484 wxPyEndAllowThreads(__tstate);
35485 if (PyErr_Occurred()) SWIG_fail;
35486 }
35487 {
35488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35489 }
35490 return resultobj;
35491 fail:
35492 return NULL;
35493 }
35494
35495
35496 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35497 PyObject *resultobj = 0;
35498 wxClipboard *arg1 = (wxClipboard *) 0 ;
35499 wxDataFormat *arg2 = 0 ;
35500 bool result;
35501 void *argp1 = 0 ;
35502 int res1 = 0 ;
35503 void *argp2 = 0 ;
35504 int res2 = 0 ;
35505 PyObject * obj0 = 0 ;
35506 PyObject * obj1 = 0 ;
35507 char * kwnames[] = {
35508 (char *) "self",(char *) "format", NULL
35509 };
35510
35511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35513 if (!SWIG_IsOK(res1)) {
35514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35515 }
35516 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35517 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35518 if (!SWIG_IsOK(res2)) {
35519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35520 }
35521 if (!argp2) {
35522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35523 }
35524 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35525 {
35526 PyThreadState* __tstate = wxPyBeginAllowThreads();
35527 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35528 wxPyEndAllowThreads(__tstate);
35529 if (PyErr_Occurred()) SWIG_fail;
35530 }
35531 {
35532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35533 }
35534 return resultobj;
35535 fail:
35536 return NULL;
35537 }
35538
35539
35540 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35541 PyObject *resultobj = 0;
35542 wxClipboard *arg1 = (wxClipboard *) 0 ;
35543 wxDataObject *arg2 = 0 ;
35544 bool result;
35545 void *argp1 = 0 ;
35546 int res1 = 0 ;
35547 void *argp2 = 0 ;
35548 int res2 = 0 ;
35549 PyObject * obj0 = 0 ;
35550 PyObject * obj1 = 0 ;
35551 char * kwnames[] = {
35552 (char *) "self",(char *) "data", NULL
35553 };
35554
35555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35557 if (!SWIG_IsOK(res1)) {
35558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35559 }
35560 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35562 if (!SWIG_IsOK(res2)) {
35563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35564 }
35565 if (!argp2) {
35566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35567 }
35568 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35569 {
35570 PyThreadState* __tstate = wxPyBeginAllowThreads();
35571 result = (bool)(arg1)->GetData(*arg2);
35572 wxPyEndAllowThreads(__tstate);
35573 if (PyErr_Occurred()) SWIG_fail;
35574 }
35575 {
35576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35577 }
35578 return resultobj;
35579 fail:
35580 return NULL;
35581 }
35582
35583
35584 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35585 PyObject *resultobj = 0;
35586 wxClipboard *arg1 = (wxClipboard *) 0 ;
35587 void *argp1 = 0 ;
35588 int res1 = 0 ;
35589 PyObject *swig_obj[1] ;
35590
35591 if (!args) SWIG_fail;
35592 swig_obj[0] = args;
35593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35594 if (!SWIG_IsOK(res1)) {
35595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35596 }
35597 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35598 {
35599 PyThreadState* __tstate = wxPyBeginAllowThreads();
35600 (arg1)->Clear();
35601 wxPyEndAllowThreads(__tstate);
35602 if (PyErr_Occurred()) SWIG_fail;
35603 }
35604 resultobj = SWIG_Py_Void();
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35612 PyObject *resultobj = 0;
35613 wxClipboard *arg1 = (wxClipboard *) 0 ;
35614 bool result;
35615 void *argp1 = 0 ;
35616 int res1 = 0 ;
35617 PyObject *swig_obj[1] ;
35618
35619 if (!args) SWIG_fail;
35620 swig_obj[0] = args;
35621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35622 if (!SWIG_IsOK(res1)) {
35623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35624 }
35625 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35626 {
35627 PyThreadState* __tstate = wxPyBeginAllowThreads();
35628 result = (bool)(arg1)->Flush();
35629 wxPyEndAllowThreads(__tstate);
35630 if (PyErr_Occurred()) SWIG_fail;
35631 }
35632 {
35633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35634 }
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35642 PyObject *resultobj = 0;
35643 wxClipboard *arg1 = (wxClipboard *) 0 ;
35644 bool arg2 = (bool) true ;
35645 void *argp1 = 0 ;
35646 int res1 = 0 ;
35647 bool val2 ;
35648 int ecode2 = 0 ;
35649 PyObject * obj0 = 0 ;
35650 PyObject * obj1 = 0 ;
35651 char * kwnames[] = {
35652 (char *) "self",(char *) "primary", NULL
35653 };
35654
35655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35659 }
35660 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35661 if (obj1) {
35662 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35663 if (!SWIG_IsOK(ecode2)) {
35664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35665 }
35666 arg2 = static_cast< bool >(val2);
35667 }
35668 {
35669 PyThreadState* __tstate = wxPyBeginAllowThreads();
35670 (arg1)->UsePrimarySelection(arg2);
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 resultobj = SWIG_Py_Void();
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35682 PyObject *resultobj = 0;
35683 wxClipboard *result = 0 ;
35684
35685 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35686 {
35687 PyThreadState* __tstate = wxPyBeginAllowThreads();
35688 result = (wxClipboard *)wxClipboard::Get();
35689 wxPyEndAllowThreads(__tstate);
35690 if (PyErr_Occurred()) SWIG_fail;
35691 }
35692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35693 return resultobj;
35694 fail:
35695 return NULL;
35696 }
35697
35698
35699 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35700 PyObject *obj;
35701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35702 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35703 return SWIG_Py_Void();
35704 }
35705
35706 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35707 return SWIG_Python_InitShadowInstance(args);
35708 }
35709
35710 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35711 PyObject *resultobj = 0;
35712 wxClipboard *arg1 = (wxClipboard *) NULL ;
35713 wxClipboardLocker *result = 0 ;
35714 void *argp1 = 0 ;
35715 int res1 = 0 ;
35716 PyObject * obj0 = 0 ;
35717 char * kwnames[] = {
35718 (char *) "clipboard", NULL
35719 };
35720
35721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35722 if (obj0) {
35723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35724 if (!SWIG_IsOK(res1)) {
35725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35726 }
35727 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35728 }
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35736 return resultobj;
35737 fail:
35738 return NULL;
35739 }
35740
35741
35742 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35743 PyObject *resultobj = 0;
35744 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35745 void *argp1 = 0 ;
35746 int res1 = 0 ;
35747 PyObject *swig_obj[1] ;
35748
35749 if (!args) SWIG_fail;
35750 swig_obj[0] = args;
35751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35752 if (!SWIG_IsOK(res1)) {
35753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35754 }
35755 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35756 {
35757 PyThreadState* __tstate = wxPyBeginAllowThreads();
35758 delete arg1;
35759
35760 wxPyEndAllowThreads(__tstate);
35761 if (PyErr_Occurred()) SWIG_fail;
35762 }
35763 resultobj = SWIG_Py_Void();
35764 return resultobj;
35765 fail:
35766 return NULL;
35767 }
35768
35769
35770 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35771 PyObject *resultobj = 0;
35772 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35773 bool result;
35774 void *argp1 = 0 ;
35775 int res1 = 0 ;
35776 PyObject *swig_obj[1] ;
35777
35778 if (!args) SWIG_fail;
35779 swig_obj[0] = args;
35780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35781 if (!SWIG_IsOK(res1)) {
35782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35783 }
35784 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = (bool)wxClipboardLocker___nonzero__(arg1);
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 {
35792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35793 }
35794 return resultobj;
35795 fail:
35796 return NULL;
35797 }
35798
35799
35800 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35801 PyObject *obj;
35802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35803 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35804 return SWIG_Py_Void();
35805 }
35806
35807 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35808 return SWIG_Python_InitShadowInstance(args);
35809 }
35810
35811 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35812 PyObject *resultobj = 0;
35813 int arg1 = (int) 0 ;
35814 int arg2 = (int) 0 ;
35815 int arg3 = (int) 0 ;
35816 int arg4 = (int) 0 ;
35817 wxVideoMode *result = 0 ;
35818 int val1 ;
35819 int ecode1 = 0 ;
35820 int val2 ;
35821 int ecode2 = 0 ;
35822 int val3 ;
35823 int ecode3 = 0 ;
35824 int val4 ;
35825 int ecode4 = 0 ;
35826 PyObject * obj0 = 0 ;
35827 PyObject * obj1 = 0 ;
35828 PyObject * obj2 = 0 ;
35829 PyObject * obj3 = 0 ;
35830 char * kwnames[] = {
35831 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35832 };
35833
35834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35835 if (obj0) {
35836 ecode1 = SWIG_AsVal_int(obj0, &val1);
35837 if (!SWIG_IsOK(ecode1)) {
35838 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35839 }
35840 arg1 = static_cast< int >(val1);
35841 }
35842 if (obj1) {
35843 ecode2 = SWIG_AsVal_int(obj1, &val2);
35844 if (!SWIG_IsOK(ecode2)) {
35845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35846 }
35847 arg2 = static_cast< int >(val2);
35848 }
35849 if (obj2) {
35850 ecode3 = SWIG_AsVal_int(obj2, &val3);
35851 if (!SWIG_IsOK(ecode3)) {
35852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35853 }
35854 arg3 = static_cast< int >(val3);
35855 }
35856 if (obj3) {
35857 ecode4 = SWIG_AsVal_int(obj3, &val4);
35858 if (!SWIG_IsOK(ecode4)) {
35859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35860 }
35861 arg4 = static_cast< int >(val4);
35862 }
35863 {
35864 PyThreadState* __tstate = wxPyBeginAllowThreads();
35865 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35866 wxPyEndAllowThreads(__tstate);
35867 if (PyErr_Occurred()) SWIG_fail;
35868 }
35869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35870 return resultobj;
35871 fail:
35872 return NULL;
35873 }
35874
35875
35876 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35877 PyObject *resultobj = 0;
35878 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35879 void *argp1 = 0 ;
35880 int res1 = 0 ;
35881 PyObject *swig_obj[1] ;
35882
35883 if (!args) SWIG_fail;
35884 swig_obj[0] = args;
35885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35886 if (!SWIG_IsOK(res1)) {
35887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35888 }
35889 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35890 {
35891 PyThreadState* __tstate = wxPyBeginAllowThreads();
35892 delete arg1;
35893
35894 wxPyEndAllowThreads(__tstate);
35895 if (PyErr_Occurred()) SWIG_fail;
35896 }
35897 resultobj = SWIG_Py_Void();
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj = 0;
35906 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35907 wxVideoMode *arg2 = 0 ;
35908 bool result;
35909 void *argp1 = 0 ;
35910 int res1 = 0 ;
35911 void *argp2 = 0 ;
35912 int res2 = 0 ;
35913 PyObject * obj0 = 0 ;
35914 PyObject * obj1 = 0 ;
35915 char * kwnames[] = {
35916 (char *) "self",(char *) "other", NULL
35917 };
35918
35919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35923 }
35924 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35925 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35926 if (!SWIG_IsOK(res2)) {
35927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35928 }
35929 if (!argp2) {
35930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35931 }
35932 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35933 {
35934 PyThreadState* __tstate = wxPyBeginAllowThreads();
35935 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35936 wxPyEndAllowThreads(__tstate);
35937 if (PyErr_Occurred()) SWIG_fail;
35938 }
35939 {
35940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35941 }
35942 return resultobj;
35943 fail:
35944 return NULL;
35945 }
35946
35947
35948 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35949 PyObject *resultobj = 0;
35950 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35951 int result;
35952 void *argp1 = 0 ;
35953 int res1 = 0 ;
35954 PyObject *swig_obj[1] ;
35955
35956 if (!args) SWIG_fail;
35957 swig_obj[0] = args;
35958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35959 if (!SWIG_IsOK(res1)) {
35960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35961 }
35962 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35963 {
35964 PyThreadState* __tstate = wxPyBeginAllowThreads();
35965 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35966 wxPyEndAllowThreads(__tstate);
35967 if (PyErr_Occurred()) SWIG_fail;
35968 }
35969 resultobj = SWIG_From_int(static_cast< int >(result));
35970 return resultobj;
35971 fail:
35972 return NULL;
35973 }
35974
35975
35976 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35977 PyObject *resultobj = 0;
35978 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35979 int result;
35980 void *argp1 = 0 ;
35981 int res1 = 0 ;
35982 PyObject *swig_obj[1] ;
35983
35984 if (!args) SWIG_fail;
35985 swig_obj[0] = args;
35986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35987 if (!SWIG_IsOK(res1)) {
35988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35989 }
35990 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35991 {
35992 PyThreadState* __tstate = wxPyBeginAllowThreads();
35993 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35994 wxPyEndAllowThreads(__tstate);
35995 if (PyErr_Occurred()) SWIG_fail;
35996 }
35997 resultobj = SWIG_From_int(static_cast< int >(result));
35998 return resultobj;
35999 fail:
36000 return NULL;
36001 }
36002
36003
36004 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36005 PyObject *resultobj = 0;
36006 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36007 int result;
36008 void *argp1 = 0 ;
36009 int res1 = 0 ;
36010 PyObject *swig_obj[1] ;
36011
36012 if (!args) SWIG_fail;
36013 swig_obj[0] = args;
36014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36015 if (!SWIG_IsOK(res1)) {
36016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36017 }
36018 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 resultobj = SWIG_From_int(static_cast< int >(result));
36026 return resultobj;
36027 fail:
36028 return NULL;
36029 }
36030
36031
36032 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36033 PyObject *resultobj = 0;
36034 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36035 bool result;
36036 void *argp1 = 0 ;
36037 int res1 = 0 ;
36038 PyObject *swig_obj[1] ;
36039
36040 if (!args) SWIG_fail;
36041 swig_obj[0] = args;
36042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36043 if (!SWIG_IsOK(res1)) {
36044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36045 }
36046 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36047 {
36048 PyThreadState* __tstate = wxPyBeginAllowThreads();
36049 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36050 wxPyEndAllowThreads(__tstate);
36051 if (PyErr_Occurred()) SWIG_fail;
36052 }
36053 {
36054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36055 }
36056 return resultobj;
36057 fail:
36058 return NULL;
36059 }
36060
36061
36062 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36063 PyObject *resultobj = 0;
36064 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36065 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36066 bool result;
36067 void *argp1 = 0 ;
36068 int res1 = 0 ;
36069 void *argp2 = 0 ;
36070 int res2 = 0 ;
36071 PyObject * obj0 = 0 ;
36072 PyObject * obj1 = 0 ;
36073 char * kwnames[] = {
36074 (char *) "self",(char *) "other", NULL
36075 };
36076
36077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36079 if (!SWIG_IsOK(res1)) {
36080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36081 }
36082 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36083 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36084 if (!SWIG_IsOK(res2)) {
36085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36086 }
36087 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36088 {
36089 PyThreadState* __tstate = wxPyBeginAllowThreads();
36090 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36091 wxPyEndAllowThreads(__tstate);
36092 if (PyErr_Occurred()) SWIG_fail;
36093 }
36094 {
36095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36096 }
36097 return resultobj;
36098 fail:
36099 return NULL;
36100 }
36101
36102
36103 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36104 PyObject *resultobj = 0;
36105 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36106 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36107 bool result;
36108 void *argp1 = 0 ;
36109 int res1 = 0 ;
36110 void *argp2 = 0 ;
36111 int res2 = 0 ;
36112 PyObject * obj0 = 0 ;
36113 PyObject * obj1 = 0 ;
36114 char * kwnames[] = {
36115 (char *) "self",(char *) "other", NULL
36116 };
36117
36118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36120 if (!SWIG_IsOK(res1)) {
36121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36122 }
36123 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36124 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36125 if (!SWIG_IsOK(res2)) {
36126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36127 }
36128 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36129 {
36130 PyThreadState* __tstate = wxPyBeginAllowThreads();
36131 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36132 wxPyEndAllowThreads(__tstate);
36133 if (PyErr_Occurred()) SWIG_fail;
36134 }
36135 {
36136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36137 }
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36145 PyObject *resultobj = 0;
36146 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36147 int arg2 ;
36148 void *argp1 = 0 ;
36149 int res1 = 0 ;
36150 int val2 ;
36151 int ecode2 = 0 ;
36152 PyObject *swig_obj[2] ;
36153
36154 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36156 if (!SWIG_IsOK(res1)) {
36157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36158 }
36159 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36160 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36161 if (!SWIG_IsOK(ecode2)) {
36162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36163 }
36164 arg2 = static_cast< int >(val2);
36165 if (arg1) (arg1)->w = arg2;
36166
36167 resultobj = SWIG_Py_Void();
36168 return resultobj;
36169 fail:
36170 return NULL;
36171 }
36172
36173
36174 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36175 PyObject *resultobj = 0;
36176 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36177 int result;
36178 void *argp1 = 0 ;
36179 int res1 = 0 ;
36180 PyObject *swig_obj[1] ;
36181
36182 if (!args) SWIG_fail;
36183 swig_obj[0] = args;
36184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36185 if (!SWIG_IsOK(res1)) {
36186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36187 }
36188 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36189 result = (int) ((arg1)->w);
36190 resultobj = SWIG_From_int(static_cast< int >(result));
36191 return resultobj;
36192 fail:
36193 return NULL;
36194 }
36195
36196
36197 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36198 PyObject *resultobj = 0;
36199 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36200 int arg2 ;
36201 void *argp1 = 0 ;
36202 int res1 = 0 ;
36203 int val2 ;
36204 int ecode2 = 0 ;
36205 PyObject *swig_obj[2] ;
36206
36207 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36209 if (!SWIG_IsOK(res1)) {
36210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36211 }
36212 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36213 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36214 if (!SWIG_IsOK(ecode2)) {
36215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36216 }
36217 arg2 = static_cast< int >(val2);
36218 if (arg1) (arg1)->h = arg2;
36219
36220 resultobj = SWIG_Py_Void();
36221 return resultobj;
36222 fail:
36223 return NULL;
36224 }
36225
36226
36227 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36228 PyObject *resultobj = 0;
36229 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36230 int result;
36231 void *argp1 = 0 ;
36232 int res1 = 0 ;
36233 PyObject *swig_obj[1] ;
36234
36235 if (!args) SWIG_fail;
36236 swig_obj[0] = args;
36237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36238 if (!SWIG_IsOK(res1)) {
36239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36240 }
36241 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36242 result = (int) ((arg1)->h);
36243 resultobj = SWIG_From_int(static_cast< int >(result));
36244 return resultobj;
36245 fail:
36246 return NULL;
36247 }
36248
36249
36250 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36251 PyObject *resultobj = 0;
36252 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36253 int arg2 ;
36254 void *argp1 = 0 ;
36255 int res1 = 0 ;
36256 int val2 ;
36257 int ecode2 = 0 ;
36258 PyObject *swig_obj[2] ;
36259
36260 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36262 if (!SWIG_IsOK(res1)) {
36263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36264 }
36265 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36266 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36267 if (!SWIG_IsOK(ecode2)) {
36268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36269 }
36270 arg2 = static_cast< int >(val2);
36271 if (arg1) (arg1)->bpp = arg2;
36272
36273 resultobj = SWIG_Py_Void();
36274 return resultobj;
36275 fail:
36276 return NULL;
36277 }
36278
36279
36280 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36281 PyObject *resultobj = 0;
36282 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36283 int result;
36284 void *argp1 = 0 ;
36285 int res1 = 0 ;
36286 PyObject *swig_obj[1] ;
36287
36288 if (!args) SWIG_fail;
36289 swig_obj[0] = args;
36290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36291 if (!SWIG_IsOK(res1)) {
36292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36293 }
36294 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36295 result = (int) ((arg1)->bpp);
36296 resultobj = SWIG_From_int(static_cast< int >(result));
36297 return resultobj;
36298 fail:
36299 return NULL;
36300 }
36301
36302
36303 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36304 PyObject *resultobj = 0;
36305 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36306 int arg2 ;
36307 void *argp1 = 0 ;
36308 int res1 = 0 ;
36309 int val2 ;
36310 int ecode2 = 0 ;
36311 PyObject *swig_obj[2] ;
36312
36313 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36315 if (!SWIG_IsOK(res1)) {
36316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36317 }
36318 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36319 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36320 if (!SWIG_IsOK(ecode2)) {
36321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36322 }
36323 arg2 = static_cast< int >(val2);
36324 if (arg1) (arg1)->refresh = arg2;
36325
36326 resultobj = SWIG_Py_Void();
36327 return resultobj;
36328 fail:
36329 return NULL;
36330 }
36331
36332
36333 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36334 PyObject *resultobj = 0;
36335 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36336 int result;
36337 void *argp1 = 0 ;
36338 int res1 = 0 ;
36339 PyObject *swig_obj[1] ;
36340
36341 if (!args) SWIG_fail;
36342 swig_obj[0] = args;
36343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36344 if (!SWIG_IsOK(res1)) {
36345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36346 }
36347 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36348 result = (int) ((arg1)->refresh);
36349 resultobj = SWIG_From_int(static_cast< int >(result));
36350 return resultobj;
36351 fail:
36352 return NULL;
36353 }
36354
36355
36356 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36357 PyObject *obj;
36358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36359 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36360 return SWIG_Py_Void();
36361 }
36362
36363 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36364 return SWIG_Python_InitShadowInstance(args);
36365 }
36366
36367 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36368 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36369 return 1;
36370 }
36371
36372
36373 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36374 PyObject *pyobj = 0;
36375
36376 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36377 return pyobj;
36378 }
36379
36380
36381 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36382 PyObject *resultobj = 0;
36383 unsigned int arg1 = (unsigned int) 0 ;
36384 wxDisplay *result = 0 ;
36385 unsigned int val1 ;
36386 int ecode1 = 0 ;
36387 PyObject * obj0 = 0 ;
36388 char * kwnames[] = {
36389 (char *) "index", NULL
36390 };
36391
36392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36393 if (obj0) {
36394 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36395 if (!SWIG_IsOK(ecode1)) {
36396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36397 }
36398 arg1 = static_cast< unsigned int >(val1);
36399 }
36400 {
36401 PyThreadState* __tstate = wxPyBeginAllowThreads();
36402 result = (wxDisplay *)new wxDisplay(arg1);
36403 wxPyEndAllowThreads(__tstate);
36404 if (PyErr_Occurred()) SWIG_fail;
36405 }
36406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36407 return resultobj;
36408 fail:
36409 return NULL;
36410 }
36411
36412
36413 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36414 PyObject *resultobj = 0;
36415 wxDisplay *arg1 = (wxDisplay *) 0 ;
36416 void *argp1 = 0 ;
36417 int res1 = 0 ;
36418 PyObject *swig_obj[1] ;
36419
36420 if (!args) SWIG_fail;
36421 swig_obj[0] = args;
36422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36423 if (!SWIG_IsOK(res1)) {
36424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36425 }
36426 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36427 {
36428 PyThreadState* __tstate = wxPyBeginAllowThreads();
36429 delete arg1;
36430
36431 wxPyEndAllowThreads(__tstate);
36432 if (PyErr_Occurred()) SWIG_fail;
36433 }
36434 resultobj = SWIG_Py_Void();
36435 return resultobj;
36436 fail:
36437 return NULL;
36438 }
36439
36440
36441 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36442 PyObject *resultobj = 0;
36443 unsigned int result;
36444
36445 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36446 {
36447 PyThreadState* __tstate = wxPyBeginAllowThreads();
36448 result = (unsigned int)wxDisplay::GetCount();
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj = 0;
36461 wxPoint *arg1 = 0 ;
36462 int result;
36463 wxPoint temp1 ;
36464 PyObject * obj0 = 0 ;
36465 char * kwnames[] = {
36466 (char *) "pt", NULL
36467 };
36468
36469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36470 {
36471 arg1 = &temp1;
36472 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36473 }
36474 {
36475 PyThreadState* __tstate = wxPyBeginAllowThreads();
36476 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36477 wxPyEndAllowThreads(__tstate);
36478 if (PyErr_Occurred()) SWIG_fail;
36479 }
36480 resultobj = SWIG_From_int(static_cast< int >(result));
36481 return resultobj;
36482 fail:
36483 return NULL;
36484 }
36485
36486
36487 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36488 PyObject *resultobj = 0;
36489 wxWindow *arg1 = (wxWindow *) 0 ;
36490 int result;
36491 void *argp1 = 0 ;
36492 int res1 = 0 ;
36493 PyObject * obj0 = 0 ;
36494 char * kwnames[] = {
36495 (char *) "window", NULL
36496 };
36497
36498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36500 if (!SWIG_IsOK(res1)) {
36501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36502 }
36503 arg1 = reinterpret_cast< wxWindow * >(argp1);
36504 {
36505 PyThreadState* __tstate = wxPyBeginAllowThreads();
36506 result = (int)wxDisplay::GetFromWindow(arg1);
36507 wxPyEndAllowThreads(__tstate);
36508 if (PyErr_Occurred()) SWIG_fail;
36509 }
36510 resultobj = SWIG_From_int(static_cast< int >(result));
36511 return resultobj;
36512 fail:
36513 return NULL;
36514 }
36515
36516
36517 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36518 PyObject *resultobj = 0;
36519 wxDisplay *arg1 = (wxDisplay *) 0 ;
36520 bool result;
36521 void *argp1 = 0 ;
36522 int res1 = 0 ;
36523 PyObject *swig_obj[1] ;
36524
36525 if (!args) SWIG_fail;
36526 swig_obj[0] = args;
36527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36528 if (!SWIG_IsOK(res1)) {
36529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36530 }
36531 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36532 {
36533 PyThreadState* __tstate = wxPyBeginAllowThreads();
36534 result = (bool)((wxDisplay const *)arg1)->IsOk();
36535 wxPyEndAllowThreads(__tstate);
36536 if (PyErr_Occurred()) SWIG_fail;
36537 }
36538 {
36539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36540 }
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36548 PyObject *resultobj = 0;
36549 wxDisplay *arg1 = (wxDisplay *) 0 ;
36550 wxRect result;
36551 void *argp1 = 0 ;
36552 int res1 = 0 ;
36553 PyObject *swig_obj[1] ;
36554
36555 if (!args) SWIG_fail;
36556 swig_obj[0] = args;
36557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36558 if (!SWIG_IsOK(res1)) {
36559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36560 }
36561 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 result = ((wxDisplay const *)arg1)->GetGeometry();
36565 wxPyEndAllowThreads(__tstate);
36566 if (PyErr_Occurred()) SWIG_fail;
36567 }
36568 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36569 return resultobj;
36570 fail:
36571 return NULL;
36572 }
36573
36574
36575 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36576 PyObject *resultobj = 0;
36577 wxDisplay *arg1 = (wxDisplay *) 0 ;
36578 wxRect result;
36579 void *argp1 = 0 ;
36580 int res1 = 0 ;
36581 PyObject *swig_obj[1] ;
36582
36583 if (!args) SWIG_fail;
36584 swig_obj[0] = args;
36585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36586 if (!SWIG_IsOK(res1)) {
36587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36588 }
36589 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36590 {
36591 PyThreadState* __tstate = wxPyBeginAllowThreads();
36592 result = ((wxDisplay const *)arg1)->GetClientArea();
36593 wxPyEndAllowThreads(__tstate);
36594 if (PyErr_Occurred()) SWIG_fail;
36595 }
36596 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36597 return resultobj;
36598 fail:
36599 return NULL;
36600 }
36601
36602
36603 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36604 PyObject *resultobj = 0;
36605 wxDisplay *arg1 = (wxDisplay *) 0 ;
36606 wxString result;
36607 void *argp1 = 0 ;
36608 int res1 = 0 ;
36609 PyObject *swig_obj[1] ;
36610
36611 if (!args) SWIG_fail;
36612 swig_obj[0] = args;
36613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36614 if (!SWIG_IsOK(res1)) {
36615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36616 }
36617 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36618 {
36619 PyThreadState* __tstate = wxPyBeginAllowThreads();
36620 result = ((wxDisplay const *)arg1)->GetName();
36621 wxPyEndAllowThreads(__tstate);
36622 if (PyErr_Occurred()) SWIG_fail;
36623 }
36624 {
36625 #if wxUSE_UNICODE
36626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36627 #else
36628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36629 #endif
36630 }
36631 return resultobj;
36632 fail:
36633 return NULL;
36634 }
36635
36636
36637 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36638 PyObject *resultobj = 0;
36639 wxDisplay *arg1 = (wxDisplay *) 0 ;
36640 bool result;
36641 void *argp1 = 0 ;
36642 int res1 = 0 ;
36643 PyObject *swig_obj[1] ;
36644
36645 if (!args) SWIG_fail;
36646 swig_obj[0] = args;
36647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36648 if (!SWIG_IsOK(res1)) {
36649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36650 }
36651 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36652 {
36653 PyThreadState* __tstate = wxPyBeginAllowThreads();
36654 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 {
36659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36660 }
36661 return resultobj;
36662 fail:
36663 return NULL;
36664 }
36665
36666
36667 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36668 PyObject *resultobj = 0;
36669 wxDisplay *arg1 = (wxDisplay *) 0 ;
36670 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36671 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36672 PyObject *result = 0 ;
36673 void *argp1 = 0 ;
36674 int res1 = 0 ;
36675 void *argp2 = 0 ;
36676 int res2 = 0 ;
36677 PyObject * obj0 = 0 ;
36678 PyObject * obj1 = 0 ;
36679 char * kwnames[] = {
36680 (char *) "self",(char *) "mode", NULL
36681 };
36682
36683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36685 if (!SWIG_IsOK(res1)) {
36686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36687 }
36688 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36689 if (obj1) {
36690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36691 if (!SWIG_IsOK(res2)) {
36692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36693 }
36694 if (!argp2) {
36695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36696 }
36697 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36698 }
36699 {
36700 PyThreadState* __tstate = wxPyBeginAllowThreads();
36701 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36702 wxPyEndAllowThreads(__tstate);
36703 if (PyErr_Occurred()) SWIG_fail;
36704 }
36705 resultobj = result;
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36713 PyObject *resultobj = 0;
36714 wxDisplay *arg1 = (wxDisplay *) 0 ;
36715 wxVideoMode result;
36716 void *argp1 = 0 ;
36717 int res1 = 0 ;
36718 PyObject *swig_obj[1] ;
36719
36720 if (!args) SWIG_fail;
36721 swig_obj[0] = args;
36722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36725 }
36726 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36727 {
36728 PyThreadState* __tstate = wxPyBeginAllowThreads();
36729 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36730 wxPyEndAllowThreads(__tstate);
36731 if (PyErr_Occurred()) SWIG_fail;
36732 }
36733 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36734 return resultobj;
36735 fail:
36736 return NULL;
36737 }
36738
36739
36740 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36741 PyObject *resultobj = 0;
36742 wxDisplay *arg1 = (wxDisplay *) 0 ;
36743 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36744 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36745 bool result;
36746 void *argp1 = 0 ;
36747 int res1 = 0 ;
36748 void *argp2 = 0 ;
36749 int res2 = 0 ;
36750 PyObject * obj0 = 0 ;
36751 PyObject * obj1 = 0 ;
36752 char * kwnames[] = {
36753 (char *) "self",(char *) "mode", NULL
36754 };
36755
36756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36758 if (!SWIG_IsOK(res1)) {
36759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36760 }
36761 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36762 if (obj1) {
36763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36764 if (!SWIG_IsOK(res2)) {
36765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36766 }
36767 if (!argp2) {
36768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36769 }
36770 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36771 }
36772 {
36773 PyThreadState* __tstate = wxPyBeginAllowThreads();
36774 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36775 wxPyEndAllowThreads(__tstate);
36776 if (PyErr_Occurred()) SWIG_fail;
36777 }
36778 {
36779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36780 }
36781 return resultobj;
36782 fail:
36783 return NULL;
36784 }
36785
36786
36787 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36788 PyObject *resultobj = 0;
36789 wxDisplay *arg1 = (wxDisplay *) 0 ;
36790 void *argp1 = 0 ;
36791 int res1 = 0 ;
36792 PyObject *swig_obj[1] ;
36793
36794 if (!args) SWIG_fail;
36795 swig_obj[0] = args;
36796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36797 if (!SWIG_IsOK(res1)) {
36798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36799 }
36800 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36801 {
36802 PyThreadState* __tstate = wxPyBeginAllowThreads();
36803 wxDisplay_ResetMode(arg1);
36804 wxPyEndAllowThreads(__tstate);
36805 if (PyErr_Occurred()) SWIG_fail;
36806 }
36807 resultobj = SWIG_Py_Void();
36808 return resultobj;
36809 fail:
36810 return NULL;
36811 }
36812
36813
36814 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36815 PyObject *obj;
36816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36817 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36818 return SWIG_Py_Void();
36819 }
36820
36821 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36822 return SWIG_Python_InitShadowInstance(args);
36823 }
36824
36825 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36826 PyObject *resultobj = 0;
36827 wxStandardPaths *result = 0 ;
36828
36829 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36830 {
36831 PyThreadState* __tstate = wxPyBeginAllowThreads();
36832 result = (wxStandardPaths *)wxStandardPaths_Get();
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36844 PyObject *resultobj = 0;
36845 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36846 wxString result;
36847 void *argp1 = 0 ;
36848 int res1 = 0 ;
36849 PyObject *swig_obj[1] ;
36850
36851 if (!args) SWIG_fail;
36852 swig_obj[0] = args;
36853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36854 if (!SWIG_IsOK(res1)) {
36855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36856 }
36857 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36858 {
36859 PyThreadState* __tstate = wxPyBeginAllowThreads();
36860 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36861 wxPyEndAllowThreads(__tstate);
36862 if (PyErr_Occurred()) SWIG_fail;
36863 }
36864 {
36865 #if wxUSE_UNICODE
36866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36867 #else
36868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36869 #endif
36870 }
36871 return resultobj;
36872 fail:
36873 return NULL;
36874 }
36875
36876
36877 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36878 PyObject *resultobj = 0;
36879 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36880 wxString result;
36881 void *argp1 = 0 ;
36882 int res1 = 0 ;
36883 PyObject *swig_obj[1] ;
36884
36885 if (!args) SWIG_fail;
36886 swig_obj[0] = args;
36887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36888 if (!SWIG_IsOK(res1)) {
36889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36890 }
36891 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36892 {
36893 PyThreadState* __tstate = wxPyBeginAllowThreads();
36894 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36895 wxPyEndAllowThreads(__tstate);
36896 if (PyErr_Occurred()) SWIG_fail;
36897 }
36898 {
36899 #if wxUSE_UNICODE
36900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36901 #else
36902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36903 #endif
36904 }
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36912 PyObject *resultobj = 0;
36913 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36914 wxString result;
36915 void *argp1 = 0 ;
36916 int res1 = 0 ;
36917 PyObject *swig_obj[1] ;
36918
36919 if (!args) SWIG_fail;
36920 swig_obj[0] = args;
36921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36922 if (!SWIG_IsOK(res1)) {
36923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36924 }
36925 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36926 {
36927 PyThreadState* __tstate = wxPyBeginAllowThreads();
36928 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36929 wxPyEndAllowThreads(__tstate);
36930 if (PyErr_Occurred()) SWIG_fail;
36931 }
36932 {
36933 #if wxUSE_UNICODE
36934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36935 #else
36936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36937 #endif
36938 }
36939 return resultobj;
36940 fail:
36941 return NULL;
36942 }
36943
36944
36945 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36946 PyObject *resultobj = 0;
36947 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36948 wxString result;
36949 void *argp1 = 0 ;
36950 int res1 = 0 ;
36951 PyObject *swig_obj[1] ;
36952
36953 if (!args) SWIG_fail;
36954 swig_obj[0] = args;
36955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36956 if (!SWIG_IsOK(res1)) {
36957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36958 }
36959 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36960 {
36961 PyThreadState* __tstate = wxPyBeginAllowThreads();
36962 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36963 wxPyEndAllowThreads(__tstate);
36964 if (PyErr_Occurred()) SWIG_fail;
36965 }
36966 {
36967 #if wxUSE_UNICODE
36968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36969 #else
36970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36971 #endif
36972 }
36973 return resultobj;
36974 fail:
36975 return NULL;
36976 }
36977
36978
36979 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36980 PyObject *resultobj = 0;
36981 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36982 wxString result;
36983 void *argp1 = 0 ;
36984 int res1 = 0 ;
36985 PyObject *swig_obj[1] ;
36986
36987 if (!args) SWIG_fail;
36988 swig_obj[0] = args;
36989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36990 if (!SWIG_IsOK(res1)) {
36991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36992 }
36993 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36994 {
36995 PyThreadState* __tstate = wxPyBeginAllowThreads();
36996 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36997 wxPyEndAllowThreads(__tstate);
36998 if (PyErr_Occurred()) SWIG_fail;
36999 }
37000 {
37001 #if wxUSE_UNICODE
37002 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37003 #else
37004 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37005 #endif
37006 }
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37014 PyObject *resultobj = 0;
37015 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37016 wxString result;
37017 void *argp1 = 0 ;
37018 int res1 = 0 ;
37019 PyObject *swig_obj[1] ;
37020
37021 if (!args) SWIG_fail;
37022 swig_obj[0] = args;
37023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37024 if (!SWIG_IsOK(res1)) {
37025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37026 }
37027 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37028 {
37029 PyThreadState* __tstate = wxPyBeginAllowThreads();
37030 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37031 wxPyEndAllowThreads(__tstate);
37032 if (PyErr_Occurred()) SWIG_fail;
37033 }
37034 {
37035 #if wxUSE_UNICODE
37036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37037 #else
37038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37039 #endif
37040 }
37041 return resultobj;
37042 fail:
37043 return NULL;
37044 }
37045
37046
37047 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37048 PyObject *resultobj = 0;
37049 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37050 wxString result;
37051 void *argp1 = 0 ;
37052 int res1 = 0 ;
37053 PyObject *swig_obj[1] ;
37054
37055 if (!args) SWIG_fail;
37056 swig_obj[0] = args;
37057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37058 if (!SWIG_IsOK(res1)) {
37059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37060 }
37061 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 {
37069 #if wxUSE_UNICODE
37070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37071 #else
37072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37073 #endif
37074 }
37075 return resultobj;
37076 fail:
37077 return NULL;
37078 }
37079
37080
37081 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37082 PyObject *resultobj = 0;
37083 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37084 wxString result;
37085 void *argp1 = 0 ;
37086 int res1 = 0 ;
37087 PyObject *swig_obj[1] ;
37088
37089 if (!args) SWIG_fail;
37090 swig_obj[0] = args;
37091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37092 if (!SWIG_IsOK(res1)) {
37093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37094 }
37095 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37096 {
37097 PyThreadState* __tstate = wxPyBeginAllowThreads();
37098 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 {
37103 #if wxUSE_UNICODE
37104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37105 #else
37106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37107 #endif
37108 }
37109 return resultobj;
37110 fail:
37111 return NULL;
37112 }
37113
37114
37115 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37116 PyObject *resultobj = 0;
37117 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37118 wxString *arg2 = 0 ;
37119 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37120 wxString result;
37121 void *argp1 = 0 ;
37122 int res1 = 0 ;
37123 bool temp2 = false ;
37124 int val3 ;
37125 int ecode3 = 0 ;
37126 PyObject * obj0 = 0 ;
37127 PyObject * obj1 = 0 ;
37128 PyObject * obj2 = 0 ;
37129 char * kwnames[] = {
37130 (char *) "self",(char *) "lang",(char *) "category", NULL
37131 };
37132
37133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37135 if (!SWIG_IsOK(res1)) {
37136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37137 }
37138 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37139 {
37140 arg2 = wxString_in_helper(obj1);
37141 if (arg2 == NULL) SWIG_fail;
37142 temp2 = true;
37143 }
37144 if (obj2) {
37145 ecode3 = SWIG_AsVal_int(obj2, &val3);
37146 if (!SWIG_IsOK(ecode3)) {
37147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37148 }
37149 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37150 }
37151 {
37152 PyThreadState* __tstate = wxPyBeginAllowThreads();
37153 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37154 wxPyEndAllowThreads(__tstate);
37155 if (PyErr_Occurred()) SWIG_fail;
37156 }
37157 {
37158 #if wxUSE_UNICODE
37159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37160 #else
37161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37162 #endif
37163 }
37164 {
37165 if (temp2)
37166 delete arg2;
37167 }
37168 return resultobj;
37169 fail:
37170 {
37171 if (temp2)
37172 delete arg2;
37173 }
37174 return NULL;
37175 }
37176
37177
37178 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37179 PyObject *resultobj = 0;
37180 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37181 wxString result;
37182 void *argp1 = 0 ;
37183 int res1 = 0 ;
37184 PyObject *swig_obj[1] ;
37185
37186 if (!args) SWIG_fail;
37187 swig_obj[0] = args;
37188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37189 if (!SWIG_IsOK(res1)) {
37190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37191 }
37192 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37193 {
37194 PyThreadState* __tstate = wxPyBeginAllowThreads();
37195 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37196 wxPyEndAllowThreads(__tstate);
37197 if (PyErr_Occurred()) SWIG_fail;
37198 }
37199 {
37200 #if wxUSE_UNICODE
37201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37202 #else
37203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37204 #endif
37205 }
37206 return resultobj;
37207 fail:
37208 return NULL;
37209 }
37210
37211
37212 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37213 PyObject *resultobj = 0;
37214 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37215 wxString result;
37216 void *argp1 = 0 ;
37217 int res1 = 0 ;
37218 PyObject *swig_obj[1] ;
37219
37220 if (!args) SWIG_fail;
37221 swig_obj[0] = args;
37222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37223 if (!SWIG_IsOK(res1)) {
37224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37225 }
37226 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37227 {
37228 PyThreadState* __tstate = wxPyBeginAllowThreads();
37229 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37230 wxPyEndAllowThreads(__tstate);
37231 if (PyErr_Occurred()) SWIG_fail;
37232 }
37233 {
37234 #if wxUSE_UNICODE
37235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37236 #else
37237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37238 #endif
37239 }
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj = 0;
37248 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37249 wxString *arg2 = 0 ;
37250 void *argp1 = 0 ;
37251 int res1 = 0 ;
37252 bool temp2 = false ;
37253 PyObject * obj0 = 0 ;
37254 PyObject * obj1 = 0 ;
37255 char * kwnames[] = {
37256 (char *) "self",(char *) "prefix", NULL
37257 };
37258
37259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37261 if (!SWIG_IsOK(res1)) {
37262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37263 }
37264 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37265 {
37266 arg2 = wxString_in_helper(obj1);
37267 if (arg2 == NULL) SWIG_fail;
37268 temp2 = true;
37269 }
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 resultobj = SWIG_Py_Void();
37277 {
37278 if (temp2)
37279 delete arg2;
37280 }
37281 return resultobj;
37282 fail:
37283 {
37284 if (temp2)
37285 delete arg2;
37286 }
37287 return NULL;
37288 }
37289
37290
37291 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37292 PyObject *resultobj = 0;
37293 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37294 wxString result;
37295 void *argp1 = 0 ;
37296 int res1 = 0 ;
37297 PyObject *swig_obj[1] ;
37298
37299 if (!args) SWIG_fail;
37300 swig_obj[0] = args;
37301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37302 if (!SWIG_IsOK(res1)) {
37303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37304 }
37305 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37306 {
37307 PyThreadState* __tstate = wxPyBeginAllowThreads();
37308 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37309 wxPyEndAllowThreads(__tstate);
37310 if (PyErr_Occurred()) SWIG_fail;
37311 }
37312 {
37313 #if wxUSE_UNICODE
37314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37315 #else
37316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37317 #endif
37318 }
37319 return resultobj;
37320 fail:
37321 return NULL;
37322 }
37323
37324
37325 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37326 PyObject *obj;
37327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37328 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37329 return SWIG_Py_Void();
37330 }
37331
37332 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37333 PyObject *resultobj = 0;
37334 wxEventType arg1 ;
37335 wxPowerEvent *result = 0 ;
37336 int val1 ;
37337 int ecode1 = 0 ;
37338 PyObject * obj0 = 0 ;
37339 char * kwnames[] = {
37340 (char *) "evtType", NULL
37341 };
37342
37343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37344 ecode1 = SWIG_AsVal_int(obj0, &val1);
37345 if (!SWIG_IsOK(ecode1)) {
37346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37347 }
37348 arg1 = static_cast< wxEventType >(val1);
37349 {
37350 PyThreadState* __tstate = wxPyBeginAllowThreads();
37351 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37352 wxPyEndAllowThreads(__tstate);
37353 if (PyErr_Occurred()) SWIG_fail;
37354 }
37355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37356 return resultobj;
37357 fail:
37358 return NULL;
37359 }
37360
37361
37362 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37363 PyObject *resultobj = 0;
37364 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37365 void *argp1 = 0 ;
37366 int res1 = 0 ;
37367 PyObject *swig_obj[1] ;
37368
37369 if (!args) SWIG_fail;
37370 swig_obj[0] = args;
37371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37372 if (!SWIG_IsOK(res1)) {
37373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37374 }
37375 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37376 {
37377 PyThreadState* __tstate = wxPyBeginAllowThreads();
37378 (arg1)->Veto();
37379 wxPyEndAllowThreads(__tstate);
37380 if (PyErr_Occurred()) SWIG_fail;
37381 }
37382 resultobj = SWIG_Py_Void();
37383 return resultobj;
37384 fail:
37385 return NULL;
37386 }
37387
37388
37389 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37390 PyObject *resultobj = 0;
37391 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37392 bool result;
37393 void *argp1 = 0 ;
37394 int res1 = 0 ;
37395 PyObject *swig_obj[1] ;
37396
37397 if (!args) SWIG_fail;
37398 swig_obj[0] = args;
37399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37400 if (!SWIG_IsOK(res1)) {
37401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37402 }
37403 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37404 {
37405 PyThreadState* __tstate = wxPyBeginAllowThreads();
37406 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37407 wxPyEndAllowThreads(__tstate);
37408 if (PyErr_Occurred()) SWIG_fail;
37409 }
37410 {
37411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37412 }
37413 return resultobj;
37414 fail:
37415 return NULL;
37416 }
37417
37418
37419 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37420 PyObject *obj;
37421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37422 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37423 return SWIG_Py_Void();
37424 }
37425
37426 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37427 return SWIG_Python_InitShadowInstance(args);
37428 }
37429
37430 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37431 PyObject *resultobj = 0;
37432 wxPowerType result;
37433
37434 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37435 {
37436 PyThreadState* __tstate = wxPyBeginAllowThreads();
37437 result = (wxPowerType)wxGetPowerType();
37438 wxPyEndAllowThreads(__tstate);
37439 if (PyErr_Occurred()) SWIG_fail;
37440 }
37441 resultobj = SWIG_From_int(static_cast< int >(result));
37442 return resultobj;
37443 fail:
37444 return NULL;
37445 }
37446
37447
37448 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37449 PyObject *resultobj = 0;
37450 wxBatteryState result;
37451
37452 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37453 {
37454 PyThreadState* __tstate = wxPyBeginAllowThreads();
37455 result = (wxBatteryState)wxGetBatteryState();
37456 wxPyEndAllowThreads(__tstate);
37457 if (PyErr_Occurred()) SWIG_fail;
37458 }
37459 resultobj = SWIG_From_int(static_cast< int >(result));
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37467 PyObject *resultobj = 0;
37468 wxAboutDialogInfo *result = 0 ;
37469
37470 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37471 {
37472 PyThreadState* __tstate = wxPyBeginAllowThreads();
37473 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37474 wxPyEndAllowThreads(__tstate);
37475 if (PyErr_Occurred()) SWIG_fail;
37476 }
37477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37478 return resultobj;
37479 fail:
37480 return NULL;
37481 }
37482
37483
37484 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37485 PyObject *resultobj = 0;
37486 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37487 void *argp1 = 0 ;
37488 int res1 = 0 ;
37489 PyObject *swig_obj[1] ;
37490
37491 if (!args) SWIG_fail;
37492 swig_obj[0] = args;
37493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37494 if (!SWIG_IsOK(res1)) {
37495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37496 }
37497 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37498 {
37499 PyThreadState* __tstate = wxPyBeginAllowThreads();
37500 delete arg1;
37501
37502 wxPyEndAllowThreads(__tstate);
37503 if (PyErr_Occurred()) SWIG_fail;
37504 }
37505 resultobj = SWIG_Py_Void();
37506 return resultobj;
37507 fail:
37508 return NULL;
37509 }
37510
37511
37512 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37513 PyObject *resultobj = 0;
37514 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37515 wxString *arg2 = 0 ;
37516 void *argp1 = 0 ;
37517 int res1 = 0 ;
37518 bool temp2 = false ;
37519 PyObject * obj0 = 0 ;
37520 PyObject * obj1 = 0 ;
37521 char * kwnames[] = {
37522 (char *) "self",(char *) "name", NULL
37523 };
37524
37525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37527 if (!SWIG_IsOK(res1)) {
37528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37529 }
37530 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37531 {
37532 arg2 = wxString_in_helper(obj1);
37533 if (arg2 == NULL) SWIG_fail;
37534 temp2 = true;
37535 }
37536 {
37537 PyThreadState* __tstate = wxPyBeginAllowThreads();
37538 (arg1)->SetName((wxString const &)*arg2);
37539 wxPyEndAllowThreads(__tstate);
37540 if (PyErr_Occurred()) SWIG_fail;
37541 }
37542 resultobj = SWIG_Py_Void();
37543 {
37544 if (temp2)
37545 delete arg2;
37546 }
37547 return resultobj;
37548 fail:
37549 {
37550 if (temp2)
37551 delete arg2;
37552 }
37553 return NULL;
37554 }
37555
37556
37557 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37558 PyObject *resultobj = 0;
37559 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37560 wxString result;
37561 void *argp1 = 0 ;
37562 int res1 = 0 ;
37563 PyObject *swig_obj[1] ;
37564
37565 if (!args) SWIG_fail;
37566 swig_obj[0] = args;
37567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37568 if (!SWIG_IsOK(res1)) {
37569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37570 }
37571 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37572 {
37573 PyThreadState* __tstate = wxPyBeginAllowThreads();
37574 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37575 wxPyEndAllowThreads(__tstate);
37576 if (PyErr_Occurred()) SWIG_fail;
37577 }
37578 {
37579 #if wxUSE_UNICODE
37580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37581 #else
37582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37583 #endif
37584 }
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37592 PyObject *resultobj = 0;
37593 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37594 wxString *arg2 = 0 ;
37595 void *argp1 = 0 ;
37596 int res1 = 0 ;
37597 bool temp2 = false ;
37598 PyObject * obj0 = 0 ;
37599 PyObject * obj1 = 0 ;
37600 char * kwnames[] = {
37601 (char *) "self",(char *) "version", NULL
37602 };
37603
37604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37606 if (!SWIG_IsOK(res1)) {
37607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37608 }
37609 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37610 {
37611 arg2 = wxString_in_helper(obj1);
37612 if (arg2 == NULL) SWIG_fail;
37613 temp2 = true;
37614 }
37615 {
37616 PyThreadState* __tstate = wxPyBeginAllowThreads();
37617 (arg1)->SetVersion((wxString const &)*arg2);
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 resultobj = SWIG_Py_Void();
37622 {
37623 if (temp2)
37624 delete arg2;
37625 }
37626 return resultobj;
37627 fail:
37628 {
37629 if (temp2)
37630 delete arg2;
37631 }
37632 return NULL;
37633 }
37634
37635
37636 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37637 PyObject *resultobj = 0;
37638 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37639 bool result;
37640 void *argp1 = 0 ;
37641 int res1 = 0 ;
37642 PyObject *swig_obj[1] ;
37643
37644 if (!args) SWIG_fail;
37645 swig_obj[0] = args;
37646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37647 if (!SWIG_IsOK(res1)) {
37648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37649 }
37650 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37651 {
37652 PyThreadState* __tstate = wxPyBeginAllowThreads();
37653 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37654 wxPyEndAllowThreads(__tstate);
37655 if (PyErr_Occurred()) SWIG_fail;
37656 }
37657 {
37658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37659 }
37660 return resultobj;
37661 fail:
37662 return NULL;
37663 }
37664
37665
37666 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37667 PyObject *resultobj = 0;
37668 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37669 wxString result;
37670 void *argp1 = 0 ;
37671 int res1 = 0 ;
37672 PyObject *swig_obj[1] ;
37673
37674 if (!args) SWIG_fail;
37675 swig_obj[0] = args;
37676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37677 if (!SWIG_IsOK(res1)) {
37678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37679 }
37680 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37681 {
37682 PyThreadState* __tstate = wxPyBeginAllowThreads();
37683 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37684 wxPyEndAllowThreads(__tstate);
37685 if (PyErr_Occurred()) SWIG_fail;
37686 }
37687 {
37688 #if wxUSE_UNICODE
37689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37690 #else
37691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37692 #endif
37693 }
37694 return resultobj;
37695 fail:
37696 return NULL;
37697 }
37698
37699
37700 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37701 PyObject *resultobj = 0;
37702 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37703 wxString *arg2 = 0 ;
37704 void *argp1 = 0 ;
37705 int res1 = 0 ;
37706 bool temp2 = false ;
37707 PyObject * obj0 = 0 ;
37708 PyObject * obj1 = 0 ;
37709 char * kwnames[] = {
37710 (char *) "self",(char *) "desc", NULL
37711 };
37712
37713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37715 if (!SWIG_IsOK(res1)) {
37716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37717 }
37718 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37719 {
37720 arg2 = wxString_in_helper(obj1);
37721 if (arg2 == NULL) SWIG_fail;
37722 temp2 = true;
37723 }
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 (arg1)->SetDescription((wxString const &)*arg2);
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 resultobj = SWIG_Py_Void();
37731 {
37732 if (temp2)
37733 delete arg2;
37734 }
37735 return resultobj;
37736 fail:
37737 {
37738 if (temp2)
37739 delete arg2;
37740 }
37741 return NULL;
37742 }
37743
37744
37745 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37746 PyObject *resultobj = 0;
37747 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37748 bool result;
37749 void *argp1 = 0 ;
37750 int res1 = 0 ;
37751 PyObject *swig_obj[1] ;
37752
37753 if (!args) SWIG_fail;
37754 swig_obj[0] = args;
37755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37756 if (!SWIG_IsOK(res1)) {
37757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37758 }
37759 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37760 {
37761 PyThreadState* __tstate = wxPyBeginAllowThreads();
37762 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37763 wxPyEndAllowThreads(__tstate);
37764 if (PyErr_Occurred()) SWIG_fail;
37765 }
37766 {
37767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37768 }
37769 return resultobj;
37770 fail:
37771 return NULL;
37772 }
37773
37774
37775 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37776 PyObject *resultobj = 0;
37777 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37778 wxString result;
37779 void *argp1 = 0 ;
37780 int res1 = 0 ;
37781 PyObject *swig_obj[1] ;
37782
37783 if (!args) SWIG_fail;
37784 swig_obj[0] = args;
37785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37786 if (!SWIG_IsOK(res1)) {
37787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37788 }
37789 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37790 {
37791 PyThreadState* __tstate = wxPyBeginAllowThreads();
37792 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37793 wxPyEndAllowThreads(__tstate);
37794 if (PyErr_Occurred()) SWIG_fail;
37795 }
37796 {
37797 #if wxUSE_UNICODE
37798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37799 #else
37800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37801 #endif
37802 }
37803 return resultobj;
37804 fail:
37805 return NULL;
37806 }
37807
37808
37809 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37810 PyObject *resultobj = 0;
37811 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37812 wxString *arg2 = 0 ;
37813 void *argp1 = 0 ;
37814 int res1 = 0 ;
37815 bool temp2 = false ;
37816 PyObject * obj0 = 0 ;
37817 PyObject * obj1 = 0 ;
37818 char * kwnames[] = {
37819 (char *) "self",(char *) "copyright", NULL
37820 };
37821
37822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37824 if (!SWIG_IsOK(res1)) {
37825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37826 }
37827 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37828 {
37829 arg2 = wxString_in_helper(obj1);
37830 if (arg2 == NULL) SWIG_fail;
37831 temp2 = true;
37832 }
37833 {
37834 PyThreadState* __tstate = wxPyBeginAllowThreads();
37835 (arg1)->SetCopyright((wxString const &)*arg2);
37836 wxPyEndAllowThreads(__tstate);
37837 if (PyErr_Occurred()) SWIG_fail;
37838 }
37839 resultobj = SWIG_Py_Void();
37840 {
37841 if (temp2)
37842 delete arg2;
37843 }
37844 return resultobj;
37845 fail:
37846 {
37847 if (temp2)
37848 delete arg2;
37849 }
37850 return NULL;
37851 }
37852
37853
37854 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37855 PyObject *resultobj = 0;
37856 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37857 bool result;
37858 void *argp1 = 0 ;
37859 int res1 = 0 ;
37860 PyObject *swig_obj[1] ;
37861
37862 if (!args) SWIG_fail;
37863 swig_obj[0] = args;
37864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37865 if (!SWIG_IsOK(res1)) {
37866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37867 }
37868 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37869 {
37870 PyThreadState* __tstate = wxPyBeginAllowThreads();
37871 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37872 wxPyEndAllowThreads(__tstate);
37873 if (PyErr_Occurred()) SWIG_fail;
37874 }
37875 {
37876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37877 }
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37885 PyObject *resultobj = 0;
37886 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37887 wxString result;
37888 void *argp1 = 0 ;
37889 int res1 = 0 ;
37890 PyObject *swig_obj[1] ;
37891
37892 if (!args) SWIG_fail;
37893 swig_obj[0] = args;
37894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37895 if (!SWIG_IsOK(res1)) {
37896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37897 }
37898 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37899 {
37900 PyThreadState* __tstate = wxPyBeginAllowThreads();
37901 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37902 wxPyEndAllowThreads(__tstate);
37903 if (PyErr_Occurred()) SWIG_fail;
37904 }
37905 {
37906 #if wxUSE_UNICODE
37907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37908 #else
37909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37910 #endif
37911 }
37912 return resultobj;
37913 fail:
37914 return NULL;
37915 }
37916
37917
37918 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37919 PyObject *resultobj = 0;
37920 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37921 wxString *arg2 = 0 ;
37922 void *argp1 = 0 ;
37923 int res1 = 0 ;
37924 bool temp2 = false ;
37925 PyObject * obj0 = 0 ;
37926 PyObject * obj1 = 0 ;
37927 char * kwnames[] = {
37928 (char *) "self",(char *) "licence", NULL
37929 };
37930
37931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37933 if (!SWIG_IsOK(res1)) {
37934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37935 }
37936 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37937 {
37938 arg2 = wxString_in_helper(obj1);
37939 if (arg2 == NULL) SWIG_fail;
37940 temp2 = true;
37941 }
37942 {
37943 PyThreadState* __tstate = wxPyBeginAllowThreads();
37944 (arg1)->SetLicence((wxString const &)*arg2);
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 resultobj = SWIG_Py_Void();
37949 {
37950 if (temp2)
37951 delete arg2;
37952 }
37953 return resultobj;
37954 fail:
37955 {
37956 if (temp2)
37957 delete arg2;
37958 }
37959 return NULL;
37960 }
37961
37962
37963 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37964 PyObject *resultobj = 0;
37965 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37966 wxString *arg2 = 0 ;
37967 void *argp1 = 0 ;
37968 int res1 = 0 ;
37969 bool temp2 = false ;
37970 PyObject * obj0 = 0 ;
37971 PyObject * obj1 = 0 ;
37972 char * kwnames[] = {
37973 (char *) "self",(char *) "licence", NULL
37974 };
37975
37976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
37977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37978 if (!SWIG_IsOK(res1)) {
37979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37980 }
37981 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37982 {
37983 arg2 = wxString_in_helper(obj1);
37984 if (arg2 == NULL) SWIG_fail;
37985 temp2 = true;
37986 }
37987 {
37988 PyThreadState* __tstate = wxPyBeginAllowThreads();
37989 (arg1)->SetLicense((wxString const &)*arg2);
37990 wxPyEndAllowThreads(__tstate);
37991 if (PyErr_Occurred()) SWIG_fail;
37992 }
37993 resultobj = SWIG_Py_Void();
37994 {
37995 if (temp2)
37996 delete arg2;
37997 }
37998 return resultobj;
37999 fail:
38000 {
38001 if (temp2)
38002 delete arg2;
38003 }
38004 return NULL;
38005 }
38006
38007
38008 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38009 PyObject *resultobj = 0;
38010 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38011 bool result;
38012 void *argp1 = 0 ;
38013 int res1 = 0 ;
38014 PyObject *swig_obj[1] ;
38015
38016 if (!args) SWIG_fail;
38017 swig_obj[0] = args;
38018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38019 if (!SWIG_IsOK(res1)) {
38020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38021 }
38022 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38023 {
38024 PyThreadState* __tstate = wxPyBeginAllowThreads();
38025 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38026 wxPyEndAllowThreads(__tstate);
38027 if (PyErr_Occurred()) SWIG_fail;
38028 }
38029 {
38030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38031 }
38032 return resultobj;
38033 fail:
38034 return NULL;
38035 }
38036
38037
38038 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38039 PyObject *resultobj = 0;
38040 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38041 wxString result;
38042 void *argp1 = 0 ;
38043 int res1 = 0 ;
38044 PyObject *swig_obj[1] ;
38045
38046 if (!args) SWIG_fail;
38047 swig_obj[0] = args;
38048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38049 if (!SWIG_IsOK(res1)) {
38050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38051 }
38052 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 {
38060 #if wxUSE_UNICODE
38061 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38062 #else
38063 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38064 #endif
38065 }
38066 return resultobj;
38067 fail:
38068 return NULL;
38069 }
38070
38071
38072 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38073 PyObject *resultobj = 0;
38074 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38075 wxIcon *arg2 = 0 ;
38076 void *argp1 = 0 ;
38077 int res1 = 0 ;
38078 void *argp2 = 0 ;
38079 int res2 = 0 ;
38080 PyObject * obj0 = 0 ;
38081 PyObject * obj1 = 0 ;
38082 char * kwnames[] = {
38083 (char *) "self",(char *) "icon", NULL
38084 };
38085
38086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38088 if (!SWIG_IsOK(res1)) {
38089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38090 }
38091 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38092 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38093 if (!SWIG_IsOK(res2)) {
38094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38095 }
38096 if (!argp2) {
38097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38098 }
38099 arg2 = reinterpret_cast< wxIcon * >(argp2);
38100 {
38101 PyThreadState* __tstate = wxPyBeginAllowThreads();
38102 (arg1)->SetIcon((wxIcon const &)*arg2);
38103 wxPyEndAllowThreads(__tstate);
38104 if (PyErr_Occurred()) SWIG_fail;
38105 }
38106 resultobj = SWIG_Py_Void();
38107 return resultobj;
38108 fail:
38109 return NULL;
38110 }
38111
38112
38113 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38114 PyObject *resultobj = 0;
38115 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38116 bool result;
38117 void *argp1 = 0 ;
38118 int res1 = 0 ;
38119 PyObject *swig_obj[1] ;
38120
38121 if (!args) SWIG_fail;
38122 swig_obj[0] = args;
38123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38124 if (!SWIG_IsOK(res1)) {
38125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38126 }
38127 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38131 wxPyEndAllowThreads(__tstate);
38132 if (PyErr_Occurred()) SWIG_fail;
38133 }
38134 {
38135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38136 }
38137 return resultobj;
38138 fail:
38139 return NULL;
38140 }
38141
38142
38143 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38144 PyObject *resultobj = 0;
38145 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38146 wxIcon result;
38147 void *argp1 = 0 ;
38148 int res1 = 0 ;
38149 PyObject *swig_obj[1] ;
38150
38151 if (!args) SWIG_fail;
38152 swig_obj[0] = args;
38153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38154 if (!SWIG_IsOK(res1)) {
38155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38156 }
38157 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38158 {
38159 PyThreadState* __tstate = wxPyBeginAllowThreads();
38160 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38161 wxPyEndAllowThreads(__tstate);
38162 if (PyErr_Occurred()) SWIG_fail;
38163 }
38164 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38165 return resultobj;
38166 fail:
38167 return NULL;
38168 }
38169
38170
38171 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38172 PyObject *resultobj = 0;
38173 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38174 wxString *arg2 = 0 ;
38175 wxString const &arg3_defvalue = wxEmptyString ;
38176 wxString *arg3 = (wxString *) &arg3_defvalue ;
38177 void *argp1 = 0 ;
38178 int res1 = 0 ;
38179 bool temp2 = false ;
38180 bool temp3 = false ;
38181 PyObject * obj0 = 0 ;
38182 PyObject * obj1 = 0 ;
38183 PyObject * obj2 = 0 ;
38184 char * kwnames[] = {
38185 (char *) "self",(char *) "url",(char *) "desc", NULL
38186 };
38187
38188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38190 if (!SWIG_IsOK(res1)) {
38191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38192 }
38193 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38194 {
38195 arg2 = wxString_in_helper(obj1);
38196 if (arg2 == NULL) SWIG_fail;
38197 temp2 = true;
38198 }
38199 if (obj2) {
38200 {
38201 arg3 = wxString_in_helper(obj2);
38202 if (arg3 == NULL) SWIG_fail;
38203 temp3 = true;
38204 }
38205 }
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 resultobj = SWIG_Py_Void();
38213 {
38214 if (temp2)
38215 delete arg2;
38216 }
38217 {
38218 if (temp3)
38219 delete arg3;
38220 }
38221 return resultobj;
38222 fail:
38223 {
38224 if (temp2)
38225 delete arg2;
38226 }
38227 {
38228 if (temp3)
38229 delete arg3;
38230 }
38231 return NULL;
38232 }
38233
38234
38235 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38236 PyObject *resultobj = 0;
38237 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38238 wxString result;
38239 void *argp1 = 0 ;
38240 int res1 = 0 ;
38241 PyObject *swig_obj[1] ;
38242
38243 if (!args) SWIG_fail;
38244 swig_obj[0] = args;
38245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38246 if (!SWIG_IsOK(res1)) {
38247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38248 }
38249 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38250 {
38251 PyThreadState* __tstate = wxPyBeginAllowThreads();
38252 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38253 wxPyEndAllowThreads(__tstate);
38254 if (PyErr_Occurred()) SWIG_fail;
38255 }
38256 {
38257 #if wxUSE_UNICODE
38258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38259 #else
38260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38261 #endif
38262 }
38263 return resultobj;
38264 fail:
38265 return NULL;
38266 }
38267
38268
38269 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38270 PyObject *resultobj = 0;
38271 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38272 wxString result;
38273 void *argp1 = 0 ;
38274 int res1 = 0 ;
38275 PyObject *swig_obj[1] ;
38276
38277 if (!args) SWIG_fail;
38278 swig_obj[0] = args;
38279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38280 if (!SWIG_IsOK(res1)) {
38281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38282 }
38283 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38284 {
38285 PyThreadState* __tstate = wxPyBeginAllowThreads();
38286 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38287 wxPyEndAllowThreads(__tstate);
38288 if (PyErr_Occurred()) SWIG_fail;
38289 }
38290 {
38291 #if wxUSE_UNICODE
38292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38293 #else
38294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38295 #endif
38296 }
38297 return resultobj;
38298 fail:
38299 return NULL;
38300 }
38301
38302
38303 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38304 PyObject *resultobj = 0;
38305 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38306 bool result;
38307 void *argp1 = 0 ;
38308 int res1 = 0 ;
38309 PyObject *swig_obj[1] ;
38310
38311 if (!args) SWIG_fail;
38312 swig_obj[0] = args;
38313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38314 if (!SWIG_IsOK(res1)) {
38315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38316 }
38317 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38318 {
38319 PyThreadState* __tstate = wxPyBeginAllowThreads();
38320 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38321 wxPyEndAllowThreads(__tstate);
38322 if (PyErr_Occurred()) SWIG_fail;
38323 }
38324 {
38325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38326 }
38327 return resultobj;
38328 fail:
38329 return NULL;
38330 }
38331
38332
38333 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38334 PyObject *resultobj = 0;
38335 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38336 wxArrayString *arg2 = 0 ;
38337 void *argp1 = 0 ;
38338 int res1 = 0 ;
38339 bool temp2 = false ;
38340 PyObject * obj0 = 0 ;
38341 PyObject * obj1 = 0 ;
38342 char * kwnames[] = {
38343 (char *) "self",(char *) "developers", NULL
38344 };
38345
38346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38348 if (!SWIG_IsOK(res1)) {
38349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38350 }
38351 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38352 {
38353 if (! PySequence_Check(obj1)) {
38354 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38355 SWIG_fail;
38356 }
38357 arg2 = new wxArrayString;
38358 temp2 = true;
38359 int i, len=PySequence_Length(obj1);
38360 for (i=0; i<len; i++) {
38361 PyObject* item = PySequence_GetItem(obj1, i);
38362 wxString* s = wxString_in_helper(item);
38363 if (PyErr_Occurred()) SWIG_fail;
38364 arg2->Add(*s);
38365 delete s;
38366 Py_DECREF(item);
38367 }
38368 }
38369 {
38370 PyThreadState* __tstate = wxPyBeginAllowThreads();
38371 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38372 wxPyEndAllowThreads(__tstate);
38373 if (PyErr_Occurred()) SWIG_fail;
38374 }
38375 resultobj = SWIG_Py_Void();
38376 {
38377 if (temp2) delete arg2;
38378 }
38379 return resultobj;
38380 fail:
38381 {
38382 if (temp2) delete arg2;
38383 }
38384 return NULL;
38385 }
38386
38387
38388 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38389 PyObject *resultobj = 0;
38390 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38391 wxString *arg2 = 0 ;
38392 void *argp1 = 0 ;
38393 int res1 = 0 ;
38394 bool temp2 = false ;
38395 PyObject * obj0 = 0 ;
38396 PyObject * obj1 = 0 ;
38397 char * kwnames[] = {
38398 (char *) "self",(char *) "developer", NULL
38399 };
38400
38401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38403 if (!SWIG_IsOK(res1)) {
38404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38405 }
38406 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38407 {
38408 arg2 = wxString_in_helper(obj1);
38409 if (arg2 == NULL) SWIG_fail;
38410 temp2 = true;
38411 }
38412 {
38413 PyThreadState* __tstate = wxPyBeginAllowThreads();
38414 (arg1)->AddDeveloper((wxString const &)*arg2);
38415 wxPyEndAllowThreads(__tstate);
38416 if (PyErr_Occurred()) SWIG_fail;
38417 }
38418 resultobj = SWIG_Py_Void();
38419 {
38420 if (temp2)
38421 delete arg2;
38422 }
38423 return resultobj;
38424 fail:
38425 {
38426 if (temp2)
38427 delete arg2;
38428 }
38429 return NULL;
38430 }
38431
38432
38433 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38434 PyObject *resultobj = 0;
38435 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38436 bool result;
38437 void *argp1 = 0 ;
38438 int res1 = 0 ;
38439 PyObject *swig_obj[1] ;
38440
38441 if (!args) SWIG_fail;
38442 swig_obj[0] = args;
38443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38444 if (!SWIG_IsOK(res1)) {
38445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38446 }
38447 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38448 {
38449 PyThreadState* __tstate = wxPyBeginAllowThreads();
38450 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38451 wxPyEndAllowThreads(__tstate);
38452 if (PyErr_Occurred()) SWIG_fail;
38453 }
38454 {
38455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38456 }
38457 return resultobj;
38458 fail:
38459 return NULL;
38460 }
38461
38462
38463 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38464 PyObject *resultobj = 0;
38465 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38466 wxArrayString *result = 0 ;
38467 void *argp1 = 0 ;
38468 int res1 = 0 ;
38469 PyObject *swig_obj[1] ;
38470
38471 if (!args) SWIG_fail;
38472 swig_obj[0] = args;
38473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38474 if (!SWIG_IsOK(res1)) {
38475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38476 }
38477 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38478 {
38479 PyThreadState* __tstate = wxPyBeginAllowThreads();
38480 {
38481 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38482 result = (wxArrayString *) &_result_ref;
38483 }
38484 wxPyEndAllowThreads(__tstate);
38485 if (PyErr_Occurred()) SWIG_fail;
38486 }
38487 {
38488 resultobj = wxArrayString2PyList_helper(*result);
38489 }
38490 return resultobj;
38491 fail:
38492 return NULL;
38493 }
38494
38495
38496 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38497 PyObject *resultobj = 0;
38498 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38499 wxArrayString *arg2 = 0 ;
38500 void *argp1 = 0 ;
38501 int res1 = 0 ;
38502 bool temp2 = false ;
38503 PyObject * obj0 = 0 ;
38504 PyObject * obj1 = 0 ;
38505 char * kwnames[] = {
38506 (char *) "self",(char *) "docwriters", NULL
38507 };
38508
38509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38511 if (!SWIG_IsOK(res1)) {
38512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38513 }
38514 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38515 {
38516 if (! PySequence_Check(obj1)) {
38517 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38518 SWIG_fail;
38519 }
38520 arg2 = new wxArrayString;
38521 temp2 = true;
38522 int i, len=PySequence_Length(obj1);
38523 for (i=0; i<len; i++) {
38524 PyObject* item = PySequence_GetItem(obj1, i);
38525 wxString* s = wxString_in_helper(item);
38526 if (PyErr_Occurred()) SWIG_fail;
38527 arg2->Add(*s);
38528 delete s;
38529 Py_DECREF(item);
38530 }
38531 }
38532 {
38533 PyThreadState* __tstate = wxPyBeginAllowThreads();
38534 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38535 wxPyEndAllowThreads(__tstate);
38536 if (PyErr_Occurred()) SWIG_fail;
38537 }
38538 resultobj = SWIG_Py_Void();
38539 {
38540 if (temp2) delete arg2;
38541 }
38542 return resultobj;
38543 fail:
38544 {
38545 if (temp2) delete arg2;
38546 }
38547 return NULL;
38548 }
38549
38550
38551 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38552 PyObject *resultobj = 0;
38553 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38554 wxString *arg2 = 0 ;
38555 void *argp1 = 0 ;
38556 int res1 = 0 ;
38557 bool temp2 = false ;
38558 PyObject * obj0 = 0 ;
38559 PyObject * obj1 = 0 ;
38560 char * kwnames[] = {
38561 (char *) "self",(char *) "docwriter", NULL
38562 };
38563
38564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38566 if (!SWIG_IsOK(res1)) {
38567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38568 }
38569 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38570 {
38571 arg2 = wxString_in_helper(obj1);
38572 if (arg2 == NULL) SWIG_fail;
38573 temp2 = true;
38574 }
38575 {
38576 PyThreadState* __tstate = wxPyBeginAllowThreads();
38577 (arg1)->AddDocWriter((wxString const &)*arg2);
38578 wxPyEndAllowThreads(__tstate);
38579 if (PyErr_Occurred()) SWIG_fail;
38580 }
38581 resultobj = SWIG_Py_Void();
38582 {
38583 if (temp2)
38584 delete arg2;
38585 }
38586 return resultobj;
38587 fail:
38588 {
38589 if (temp2)
38590 delete arg2;
38591 }
38592 return NULL;
38593 }
38594
38595
38596 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38597 PyObject *resultobj = 0;
38598 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38599 bool result;
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_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38609 }
38610 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38611 {
38612 PyThreadState* __tstate = wxPyBeginAllowThreads();
38613 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 {
38618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38619 }
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38627 PyObject *resultobj = 0;
38628 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38629 wxArrayString *result = 0 ;
38630 void *argp1 = 0 ;
38631 int res1 = 0 ;
38632 PyObject *swig_obj[1] ;
38633
38634 if (!args) SWIG_fail;
38635 swig_obj[0] = args;
38636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38637 if (!SWIG_IsOK(res1)) {
38638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38639 }
38640 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38641 {
38642 PyThreadState* __tstate = wxPyBeginAllowThreads();
38643 {
38644 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38645 result = (wxArrayString *) &_result_ref;
38646 }
38647 wxPyEndAllowThreads(__tstate);
38648 if (PyErr_Occurred()) SWIG_fail;
38649 }
38650 {
38651 resultobj = wxArrayString2PyList_helper(*result);
38652 }
38653 return resultobj;
38654 fail:
38655 return NULL;
38656 }
38657
38658
38659 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38660 PyObject *resultobj = 0;
38661 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38662 wxArrayString *arg2 = 0 ;
38663 void *argp1 = 0 ;
38664 int res1 = 0 ;
38665 bool temp2 = false ;
38666 PyObject * obj0 = 0 ;
38667 PyObject * obj1 = 0 ;
38668 char * kwnames[] = {
38669 (char *) "self",(char *) "artists", NULL
38670 };
38671
38672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38674 if (!SWIG_IsOK(res1)) {
38675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38676 }
38677 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38678 {
38679 if (! PySequence_Check(obj1)) {
38680 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38681 SWIG_fail;
38682 }
38683 arg2 = new wxArrayString;
38684 temp2 = true;
38685 int i, len=PySequence_Length(obj1);
38686 for (i=0; i<len; i++) {
38687 PyObject* item = PySequence_GetItem(obj1, i);
38688 wxString* s = wxString_in_helper(item);
38689 if (PyErr_Occurred()) SWIG_fail;
38690 arg2->Add(*s);
38691 delete s;
38692 Py_DECREF(item);
38693 }
38694 }
38695 {
38696 PyThreadState* __tstate = wxPyBeginAllowThreads();
38697 (arg1)->SetArtists((wxArrayString const &)*arg2);
38698 wxPyEndAllowThreads(__tstate);
38699 if (PyErr_Occurred()) SWIG_fail;
38700 }
38701 resultobj = SWIG_Py_Void();
38702 {
38703 if (temp2) delete arg2;
38704 }
38705 return resultobj;
38706 fail:
38707 {
38708 if (temp2) delete arg2;
38709 }
38710 return NULL;
38711 }
38712
38713
38714 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38715 PyObject *resultobj = 0;
38716 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38717 wxString *arg2 = 0 ;
38718 void *argp1 = 0 ;
38719 int res1 = 0 ;
38720 bool temp2 = false ;
38721 PyObject * obj0 = 0 ;
38722 PyObject * obj1 = 0 ;
38723 char * kwnames[] = {
38724 (char *) "self",(char *) "artist", NULL
38725 };
38726
38727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38729 if (!SWIG_IsOK(res1)) {
38730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38731 }
38732 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38733 {
38734 arg2 = wxString_in_helper(obj1);
38735 if (arg2 == NULL) SWIG_fail;
38736 temp2 = true;
38737 }
38738 {
38739 PyThreadState* __tstate = wxPyBeginAllowThreads();
38740 (arg1)->AddArtist((wxString const &)*arg2);
38741 wxPyEndAllowThreads(__tstate);
38742 if (PyErr_Occurred()) SWIG_fail;
38743 }
38744 resultobj = SWIG_Py_Void();
38745 {
38746 if (temp2)
38747 delete arg2;
38748 }
38749 return resultobj;
38750 fail:
38751 {
38752 if (temp2)
38753 delete arg2;
38754 }
38755 return NULL;
38756 }
38757
38758
38759 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38760 PyObject *resultobj = 0;
38761 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38762 bool result;
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_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38772 }
38773 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38774 {
38775 PyThreadState* __tstate = wxPyBeginAllowThreads();
38776 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38777 wxPyEndAllowThreads(__tstate);
38778 if (PyErr_Occurred()) SWIG_fail;
38779 }
38780 {
38781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38782 }
38783 return resultobj;
38784 fail:
38785 return NULL;
38786 }
38787
38788
38789 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38790 PyObject *resultobj = 0;
38791 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38792 wxArrayString *result = 0 ;
38793 void *argp1 = 0 ;
38794 int res1 = 0 ;
38795 PyObject *swig_obj[1] ;
38796
38797 if (!args) SWIG_fail;
38798 swig_obj[0] = args;
38799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38800 if (!SWIG_IsOK(res1)) {
38801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38802 }
38803 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38804 {
38805 PyThreadState* __tstate = wxPyBeginAllowThreads();
38806 {
38807 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38808 result = (wxArrayString *) &_result_ref;
38809 }
38810 wxPyEndAllowThreads(__tstate);
38811 if (PyErr_Occurred()) SWIG_fail;
38812 }
38813 {
38814 resultobj = wxArrayString2PyList_helper(*result);
38815 }
38816 return resultobj;
38817 fail:
38818 return NULL;
38819 }
38820
38821
38822 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38823 PyObject *resultobj = 0;
38824 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38825 wxArrayString *arg2 = 0 ;
38826 void *argp1 = 0 ;
38827 int res1 = 0 ;
38828 bool temp2 = false ;
38829 PyObject * obj0 = 0 ;
38830 PyObject * obj1 = 0 ;
38831 char * kwnames[] = {
38832 (char *) "self",(char *) "translators", NULL
38833 };
38834
38835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38837 if (!SWIG_IsOK(res1)) {
38838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38839 }
38840 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38841 {
38842 if (! PySequence_Check(obj1)) {
38843 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38844 SWIG_fail;
38845 }
38846 arg2 = new wxArrayString;
38847 temp2 = true;
38848 int i, len=PySequence_Length(obj1);
38849 for (i=0; i<len; i++) {
38850 PyObject* item = PySequence_GetItem(obj1, i);
38851 wxString* s = wxString_in_helper(item);
38852 if (PyErr_Occurred()) SWIG_fail;
38853 arg2->Add(*s);
38854 delete s;
38855 Py_DECREF(item);
38856 }
38857 }
38858 {
38859 PyThreadState* __tstate = wxPyBeginAllowThreads();
38860 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38861 wxPyEndAllowThreads(__tstate);
38862 if (PyErr_Occurred()) SWIG_fail;
38863 }
38864 resultobj = SWIG_Py_Void();
38865 {
38866 if (temp2) delete arg2;
38867 }
38868 return resultobj;
38869 fail:
38870 {
38871 if (temp2) delete arg2;
38872 }
38873 return NULL;
38874 }
38875
38876
38877 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38878 PyObject *resultobj = 0;
38879 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38880 wxString *arg2 = 0 ;
38881 void *argp1 = 0 ;
38882 int res1 = 0 ;
38883 bool temp2 = false ;
38884 PyObject * obj0 = 0 ;
38885 PyObject * obj1 = 0 ;
38886 char * kwnames[] = {
38887 (char *) "self",(char *) "translator", NULL
38888 };
38889
38890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38892 if (!SWIG_IsOK(res1)) {
38893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38894 }
38895 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38896 {
38897 arg2 = wxString_in_helper(obj1);
38898 if (arg2 == NULL) SWIG_fail;
38899 temp2 = true;
38900 }
38901 {
38902 PyThreadState* __tstate = wxPyBeginAllowThreads();
38903 (arg1)->AddTranslator((wxString const &)*arg2);
38904 wxPyEndAllowThreads(__tstate);
38905 if (PyErr_Occurred()) SWIG_fail;
38906 }
38907 resultobj = SWIG_Py_Void();
38908 {
38909 if (temp2)
38910 delete arg2;
38911 }
38912 return resultobj;
38913 fail:
38914 {
38915 if (temp2)
38916 delete arg2;
38917 }
38918 return NULL;
38919 }
38920
38921
38922 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38923 PyObject *resultobj = 0;
38924 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38925 bool result;
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_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38935 }
38936 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38937 {
38938 PyThreadState* __tstate = wxPyBeginAllowThreads();
38939 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38940 wxPyEndAllowThreads(__tstate);
38941 if (PyErr_Occurred()) SWIG_fail;
38942 }
38943 {
38944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38945 }
38946 return resultobj;
38947 fail:
38948 return NULL;
38949 }
38950
38951
38952 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38953 PyObject *resultobj = 0;
38954 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38955 wxArrayString *result = 0 ;
38956 void *argp1 = 0 ;
38957 int res1 = 0 ;
38958 PyObject *swig_obj[1] ;
38959
38960 if (!args) SWIG_fail;
38961 swig_obj[0] = args;
38962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38963 if (!SWIG_IsOK(res1)) {
38964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38965 }
38966 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38967 {
38968 PyThreadState* __tstate = wxPyBeginAllowThreads();
38969 {
38970 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
38971 result = (wxArrayString *) &_result_ref;
38972 }
38973 wxPyEndAllowThreads(__tstate);
38974 if (PyErr_Occurred()) SWIG_fail;
38975 }
38976 {
38977 resultobj = wxArrayString2PyList_helper(*result);
38978 }
38979 return resultobj;
38980 fail:
38981 return NULL;
38982 }
38983
38984
38985 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38986 PyObject *resultobj = 0;
38987 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38988 bool result;
38989 void *argp1 = 0 ;
38990 int res1 = 0 ;
38991 PyObject *swig_obj[1] ;
38992
38993 if (!args) SWIG_fail;
38994 swig_obj[0] = args;
38995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38996 if (!SWIG_IsOK(res1)) {
38997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38998 }
38999 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39000 {
39001 PyThreadState* __tstate = wxPyBeginAllowThreads();
39002 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39003 wxPyEndAllowThreads(__tstate);
39004 if (PyErr_Occurred()) SWIG_fail;
39005 }
39006 {
39007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39008 }
39009 return resultobj;
39010 fail:
39011 return NULL;
39012 }
39013
39014
39015 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39016 PyObject *resultobj = 0;
39017 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39018 wxString result;
39019 void *argp1 = 0 ;
39020 int res1 = 0 ;
39021 PyObject *swig_obj[1] ;
39022
39023 if (!args) SWIG_fail;
39024 swig_obj[0] = args;
39025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39026 if (!SWIG_IsOK(res1)) {
39027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39028 }
39029 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39030 {
39031 PyThreadState* __tstate = wxPyBeginAllowThreads();
39032 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39033 wxPyEndAllowThreads(__tstate);
39034 if (PyErr_Occurred()) SWIG_fail;
39035 }
39036 {
39037 #if wxUSE_UNICODE
39038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39039 #else
39040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39041 #endif
39042 }
39043 return resultobj;
39044 fail:
39045 return NULL;
39046 }
39047
39048
39049 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39050 PyObject *obj;
39051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39052 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39053 return SWIG_Py_Void();
39054 }
39055
39056 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39057 return SWIG_Python_InitShadowInstance(args);
39058 }
39059
39060 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39061 PyObject *resultobj = 0;
39062 wxAboutDialogInfo *arg1 = 0 ;
39063 void *argp1 = 0 ;
39064 int res1 = 0 ;
39065 PyObject * obj0 = 0 ;
39066 char * kwnames[] = {
39067 (char *) "info", NULL
39068 };
39069
39070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39071 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39072 if (!SWIG_IsOK(res1)) {
39073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39074 }
39075 if (!argp1) {
39076 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39077 }
39078 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39079 {
39080 PyThreadState* __tstate = wxPyBeginAllowThreads();
39081 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39082 wxPyEndAllowThreads(__tstate);
39083 if (PyErr_Occurred()) SWIG_fail;
39084 }
39085 resultobj = SWIG_Py_Void();
39086 return resultobj;
39087 fail:
39088 return NULL;
39089 }
39090
39091
39092 static PyMethodDef SwigMethods[] = {
39093 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39094 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39095 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39096 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39097 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39098 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39099 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39100 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39101 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39102 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39103 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39104 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39105 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39106 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39107 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39108 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39109 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39110 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39111 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39112 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39113 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39114 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39115 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39116 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39117 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39118 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39119 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39120 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39121 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39122 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39123 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39124 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39125 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39126 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39127 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39128 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39129 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39130 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39131 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39132 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39133 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39134 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39135 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39136 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39137 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39138 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39139 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39140 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39141 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39142 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39143 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39144 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39145 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39146 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39147 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39148 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39149 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39151 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39152 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39153 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39154 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39155 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39156 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39157 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39158 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39159 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39160 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39161 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39162 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39163 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39164 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39165 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39166 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39167 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39168 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39169 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39170 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39171 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39172 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39173 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39174 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39175 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39176 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39177 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39178 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39179 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39180 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39181 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39182 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39183 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39184 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39185 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39186 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39187 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39188 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39189 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39195 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39196 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39197 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39198 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39199 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39200 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39201 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39202 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39203 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39204 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39205 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39206 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39207 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39208 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39209 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39210 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39213 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39214 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39215 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39216 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39217 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39218 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39219 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39220 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39221 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39222 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39223 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39224 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39225 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39228 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39230 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39231 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39233 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39234 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39236 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39237 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39238 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39239 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39240 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39241 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39242 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39243 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39244 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39245 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39246 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39247 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39248 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39250 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39251 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39252 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39253 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39254 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39256 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39257 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39258 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39259 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39260 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39263 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39264 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39267 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39268 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39269 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39271 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39272 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39274 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39275 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39276 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39277 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39278 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39279 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39280 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39281 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39282 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39283 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39284 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39285 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39286 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39287 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39288 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39289 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39290 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39291 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39292 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39293 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39294 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39295 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39296 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39297 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39298 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39299 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39302 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39303 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39304 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39305 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39306 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39307 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39308 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39309 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39310 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39311 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39312 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39313 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39314 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39315 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39318 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39319 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39320 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39322 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39324 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39325 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39326 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39327 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39328 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39329 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39330 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39331 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39333 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39334 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39335 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39336 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39337 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39338 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39339 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39340 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39341 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39342 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39343 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39346 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39347 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39348 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39349 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39350 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39351 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39352 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39354 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39355 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39356 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39357 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39360 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39361 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39363 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39364 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39365 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39366 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39367 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39368 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39369 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39370 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39371 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39372 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39373 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39374 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39375 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39376 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39377 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39378 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39379 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39380 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39383 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39384 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39385 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39387 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39388 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39389 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39390 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39391 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39392 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39393 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39394 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39395 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39396 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39397 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39398 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39399 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39400 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39411 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39413 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39415 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39416 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39417 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39418 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39419 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39420 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39421 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39422 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39423 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39426 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39427 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39428 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39429 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39430 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39431 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39432 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39433 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39434 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39435 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39436 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39437 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39438 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39439 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39440 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39441 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39442 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39443 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39444 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39445 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39446 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39447 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39448 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39449 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39450 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39451 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39455 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39456 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39457 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39458 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39459 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39460 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39461 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39462 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39463 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39464 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39466 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39467 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39468 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39469 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39470 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39471 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39472 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39473 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39474 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39475 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39476 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39477 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39478 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39479 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39480 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39481 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39482 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39483 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39484 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39485 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39486 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39487 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39488 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39489 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39490 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39491 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39492 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39493 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39494 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39495 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39497 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39498 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39499 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39500 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39501 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39502 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39503 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39504 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39505 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39511 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39512 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39513 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39515 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39516 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39517 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39518 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39519 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39520 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39521 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39522 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39523 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39524 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39527 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39528 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39529 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39530 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39531 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39532 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39533 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39534 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39536 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39537 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39538 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39539 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39540 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39541 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39542 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39543 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39544 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39545 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39546 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39548 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39549 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39550 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39551 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39552 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39553 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39554 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39555 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39559 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39560 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39561 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39562 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39563 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39564 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39565 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39566 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39567 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39572 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39575 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39576 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39577 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39578 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39579 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39580 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39581 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39583 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39584 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39585 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39586 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39589 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39590 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39591 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39592 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39594 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39595 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39596 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39598 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39599 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39600 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39601 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39603 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39606 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39622 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39624 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39625 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39626 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39627 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39628 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39629 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39632 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39633 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39634 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39636 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39637 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39638 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39640 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39641 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39642 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39643 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39644 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39645 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39646 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39647 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39650 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39661 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39665 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39666 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39667 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39668 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39674 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39675 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39680 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39704 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39705 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39706 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39707 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39708 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39720 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39721 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39747 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39748 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39749 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39750 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39763 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39764 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39765 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39766 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39767 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39768 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39770 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39772 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39774 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39776 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39778 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39780 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39782 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39786 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39787 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39791 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39802 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39803 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39804 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39808 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39809 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39810 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39811 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39812 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39813 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39815 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39816 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39818 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39820 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39822 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39824 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39826 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39831 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39832 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39833 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39834 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39835 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39838 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39842 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39850 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39851 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39852 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39853 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39854 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39855 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39858 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39859 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39860 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39862 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39863 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39865 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39866 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39867 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39875 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39877 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39879 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39880 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39882 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39883 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39886 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39887 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39888 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39890 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39891 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39892 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39894 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39895 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39897 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39898 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39901 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39902 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39904 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39906 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39907 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39910 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39911 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39912 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39913 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39915 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39916 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39917 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39919 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39920 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39921 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39922 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39924 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39926 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39927 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39928 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39929 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39930 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39934 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39935 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39936 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39940 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39941 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39944 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39945 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39948 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
39949 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
39951 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
39953 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
39954 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
39955 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
39956 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39957 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
39961 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
39964 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
39965 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
39966 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39970 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
39971 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
39974 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
39975 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
39976 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
39977 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
39978 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
39979 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
39980 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
39985 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
39986 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
39988 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
39989 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
39990 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
39992 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
39993 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
39994 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
39995 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
39996 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
39997 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
39998 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
39999 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40000 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40001 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40002 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40003 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40004 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40005 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40006 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40007 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40008 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40009 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40010 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40011 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40012 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40013 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40014 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40016 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40017 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40019 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40020 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40021 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40022 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40023 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40024 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40026 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40027 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40028 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40029 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40030 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40031 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40032 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40033 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40034 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40035 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40036 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40037 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40038 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40039 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40040 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40041 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40042 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40043 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40044 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40045 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40047 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40048 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40049 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40050 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40051 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40052 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40053 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40054 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40055 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40056 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40057 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40058 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40059 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40060 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40061 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40062 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40063 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40064 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40065 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40068 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40069 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40070 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40071 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40072 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40073 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40074 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40075 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40076 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40077 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40078 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40079 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40080 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40082 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40083 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40084 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40085 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40086 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40087 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40088 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40091 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40092 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40093 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40094 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40095 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40096 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40097 { NULL, NULL, 0, NULL }
40098 };
40099
40100
40101 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40102
40103 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40104 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40105 }
40106 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40107 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40108 }
40109 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40110 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40111 }
40112 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40113 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40114 }
40115 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40116 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40117 }
40118 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40119 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40120 }
40121 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40122 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40123 }
40124 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40125 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40126 }
40127 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40128 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40129 }
40130 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40131 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40132 }
40133 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40134 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40135 }
40136 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40137 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40138 }
40139 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40140 return (void *)((wxEvent *) ((wxPyEvent *) x));
40141 }
40142 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40143 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40144 }
40145 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40146 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40147 }
40148 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40149 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40150 }
40151 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40152 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40153 }
40154 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40155 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40156 }
40157 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40158 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40159 }
40160 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40161 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40162 }
40163 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40164 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40165 }
40166 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40167 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40168 }
40169 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40170 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40171 }
40172 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40173 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40174 }
40175 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40176 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40177 }
40178 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40179 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40180 }
40181 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40182 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40183 }
40184 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40185 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40186 }
40187 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40188 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40189 }
40190 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40191 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40192 }
40193 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40194 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40195 }
40196 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40197 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40198 }
40199 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40200 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40201 }
40202 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40203 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40204 }
40205 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40206 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40207 }
40208 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40209 return (void *)((wxEvent *) ((wxShowEvent *) x));
40210 }
40211 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40212 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40213 }
40214 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40215 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40216 }
40217 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40218 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40219 }
40220 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40221 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40222 }
40223 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40224 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40225 }
40226 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40227 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40228 }
40229 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40230 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40231 }
40232 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40233 return (void *)((wxConfigBase *) ((wxConfig *) x));
40234 }
40235 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40236 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40237 }
40238 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40239 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40240 }
40241 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40242 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40243 }
40244 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40245 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40246 }
40247 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40248 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40249 }
40250 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40251 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40252 }
40253 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40254 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40255 }
40256 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40257 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40258 }
40259 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40260 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40261 }
40262 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40263 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40264 }
40265 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40266 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40267 }
40268 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40269 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40270 }
40271 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40272 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40273 }
40274 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40275 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40276 }
40277 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40278 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40279 }
40280 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40281 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40282 }
40283 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40284 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40285 }
40286 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40287 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40288 }
40289 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40290 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40291 }
40292 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40293 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40294 }
40295 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40296 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40297 }
40298 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40299 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40300 }
40301 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40302 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40303 }
40304 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40305 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40306 }
40307 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40308 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40309 }
40310 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40311 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40312 }
40313 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40314 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40315 }
40316 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40317 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40318 }
40319 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40320 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40321 }
40322 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40323 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40324 }
40325 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40326 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40327 }
40328 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40329 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40330 }
40331 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40332 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40333 }
40334 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40335 return (void *)((wxObject *) ((wxSizerItem *) x));
40336 }
40337 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40338 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40339 }
40340 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40341 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40342 }
40343 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40344 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40345 }
40346 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40347 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40348 }
40349 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40350 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40351 }
40352 static void *_p_wxSizerTo_p_wxObject(void *x) {
40353 return (void *)((wxObject *) ((wxSizer *) x));
40354 }
40355 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40356 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40357 }
40358 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40359 return (void *)((wxObject *) ((wxFileHistory *) x));
40360 }
40361 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40362 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40363 }
40364 static void *_p_wxEventTo_p_wxObject(void *x) {
40365 return (void *)((wxObject *) ((wxEvent *) x));
40366 }
40367 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40368 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40369 }
40370 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40371 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40372 }
40373 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40374 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40375 }
40376 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40377 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40378 }
40379 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40380 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40381 }
40382 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40383 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40384 }
40385 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40386 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40387 }
40388 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40389 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40390 }
40391 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40392 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40393 }
40394 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40395 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40396 }
40397 static void *_p_wxControlTo_p_wxObject(void *x) {
40398 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40399 }
40400 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40401 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40402 }
40403 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40404 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40405 }
40406 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40407 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40408 }
40409 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40410 return (void *)((wxObject *) ((wxFSFile *) x));
40411 }
40412 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40413 return (void *)((wxObject *) ((wxClipboard *) x));
40414 }
40415 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40416 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40417 }
40418 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40419 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40420 }
40421 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40422 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40423 }
40424 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40425 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40426 }
40427 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40428 return (void *)((wxObject *) ((wxToolTip *) x));
40429 }
40430 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40431 return (void *)((wxObject *) ((wxMenuItem *) x));
40432 }
40433 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40434 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40435 }
40436 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40437 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40438 }
40439 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40440 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40441 }
40442 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40443 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40444 }
40445 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40446 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40447 }
40448 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40449 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40450 }
40451 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40452 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40453 }
40454 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40455 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40456 }
40457 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40458 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40459 }
40460 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40461 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40462 }
40463 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40464 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40465 }
40466 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40467 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40468 }
40469 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40470 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40471 }
40472 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40473 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40474 }
40475 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40476 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40477 }
40478 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40479 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40480 }
40481 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40482 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40483 }
40484 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40485 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40486 }
40487 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40488 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40489 }
40490 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40491 return (void *)((wxObject *) ((wxImageHandler *) x));
40492 }
40493 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40494 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40495 }
40496 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40497 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40498 }
40499 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40500 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40501 }
40502 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40503 return (void *)((wxObject *) ((wxEvtHandler *) x));
40504 }
40505 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40506 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40507 }
40508 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40509 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40510 }
40511 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40512 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40513 }
40514 static void *_p_wxImageTo_p_wxObject(void *x) {
40515 return (void *)((wxObject *) ((wxImage *) x));
40516 }
40517 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40518 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40519 }
40520 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40521 return (void *)((wxObject *) ((wxSystemOptions *) x));
40522 }
40523 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40524 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40525 }
40526 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40527 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40528 }
40529 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40530 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40531 }
40532 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40533 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40534 }
40535 static void *_p_wxWindowTo_p_wxObject(void *x) {
40536 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40537 }
40538 static void *_p_wxMenuTo_p_wxObject(void *x) {
40539 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40540 }
40541 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40542 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40543 }
40544 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40545 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40546 }
40547 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40548 return (void *)((wxObject *) ((wxFileSystem *) x));
40549 }
40550 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40551 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40552 }
40553 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40554 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40555 }
40556 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40557 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40558 }
40559 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40560 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40561 }
40562 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40563 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40564 }
40565 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40566 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40567 }
40568 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40569 return (void *)((wxObject *) ((wxBusyInfo *) x));
40570 }
40571 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40572 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40573 }
40574 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40575 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40576 }
40577 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40578 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40579 }
40580 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40581 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40582 }
40583 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40584 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40585 }
40586 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40587 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40588 }
40589 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40590 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40591 }
40592 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40593 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40594 }
40595 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40596 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40597 }
40598 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40599 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40600 }
40601 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40602 return (void *)((wxLog *) ((wxLogBuffer *) x));
40603 }
40604 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40605 return (void *)((wxLog *) ((wxLogStderr *) x));
40606 }
40607 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40608 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40609 }
40610 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40611 return (void *)((wxLog *) ((wxLogWindow *) x));
40612 }
40613 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40614 return (void *)((wxLog *) ((wxLogChain *) x));
40615 }
40616 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40617 return (void *)((wxLog *) ((wxLogGui *) x));
40618 }
40619 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40620 return (void *)((wxLog *) ((wxPyLog *) x));
40621 }
40622 static void *_p_wxControlTo_p_wxWindow(void *x) {
40623 return (void *)((wxWindow *) ((wxControl *) x));
40624 }
40625 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40626 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40627 }
40628 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40629 return (void *)((wxWindow *) ((wxMenuBar *) x));
40630 }
40631 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40632 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40633 }
40634 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40635 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40636 }
40637 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40638 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};
40639 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40640 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40641 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40642 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40643 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40644 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40645 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40646 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40647 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40648 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40649 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40650 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40651 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40652 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40653 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40654 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40655 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40656 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40657 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40658 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40659 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40660 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40661 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40662 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40663 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40664 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40665 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40666 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40667 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40668 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40669 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40670 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40671 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40672 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40673 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40674 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40675 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40676 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40677 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40678 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40679 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40680 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40681 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40682 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40683 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40684 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40685 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40686 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40687 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40688 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40689 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40690 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40691 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40692 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40693 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40694 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40695 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40696 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40697 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40698 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40699 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40700 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40701 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40702 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40703 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40704 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40705 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40706 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40707 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40708 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40709 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40710 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40711 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40712 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40713 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40714 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40715 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40716 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40717 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40736 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40737 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40738 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40739 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40740 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40741 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40742 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40743 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40754 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40773 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40779 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40811
40812 static swig_type_info *swig_type_initial[] = {
40813 &_swigt__p_char,
40814 &_swigt__p_form_ops_t,
40815 &_swigt__p_int,
40816 &_swigt__p_unsigned_char,
40817 &_swigt__p_unsigned_int,
40818 &_swigt__p_unsigned_long,
40819 &_swigt__p_void,
40820 &_swigt__p_wxANIHandler,
40821 &_swigt__p_wxAboutDialogInfo,
40822 &_swigt__p_wxAcceleratorTable,
40823 &_swigt__p_wxActivateEvent,
40824 &_swigt__p_wxArrayString,
40825 &_swigt__p_wxBMPHandler,
40826 &_swigt__p_wxBitmap,
40827 &_swigt__p_wxBitmapDataObject,
40828 &_swigt__p_wxBoxSizer,
40829 &_swigt__p_wxBusyCursor,
40830 &_swigt__p_wxBusyInfo,
40831 &_swigt__p_wxCURHandler,
40832 &_swigt__p_wxCaret,
40833 &_swigt__p_wxChar,
40834 &_swigt__p_wxChildFocusEvent,
40835 &_swigt__p_wxClipboard,
40836 &_swigt__p_wxClipboardLocker,
40837 &_swigt__p_wxClipboardTextEvent,
40838 &_swigt__p_wxCloseEvent,
40839 &_swigt__p_wxColour,
40840 &_swigt__p_wxCommandEvent,
40841 &_swigt__p_wxConfig,
40842 &_swigt__p_wxConfigBase,
40843 &_swigt__p_wxConfigPathChanger,
40844 &_swigt__p_wxContextMenuEvent,
40845 &_swigt__p_wxControl,
40846 &_swigt__p_wxControlWithItems,
40847 &_swigt__p_wxCursor,
40848 &_swigt__p_wxCustomDataObject,
40849 &_swigt__p_wxDC,
40850 &_swigt__p_wxDataFormat,
40851 &_swigt__p_wxDataObject,
40852 &_swigt__p_wxDataObjectComposite,
40853 &_swigt__p_wxDataObjectSimple,
40854 &_swigt__p_wxDateEvent,
40855 &_swigt__p_wxDateSpan,
40856 &_swigt__p_wxDateTime,
40857 &_swigt__p_wxDateTime__TimeZone,
40858 &_swigt__p_wxDisplay,
40859 &_swigt__p_wxDisplayChangedEvent,
40860 &_swigt__p_wxDropFilesEvent,
40861 &_swigt__p_wxDuplexMode,
40862 &_swigt__p_wxEraseEvent,
40863 &_swigt__p_wxEvent,
40864 &_swigt__p_wxEvtHandler,
40865 &_swigt__p_wxFSFile,
40866 &_swigt__p_wxFileConfig,
40867 &_swigt__p_wxFileDataObject,
40868 &_swigt__p_wxFileHistory,
40869 &_swigt__p_wxFileSystem,
40870 &_swigt__p_wxFileType,
40871 &_swigt__p_wxFileTypeInfo,
40872 &_swigt__p_wxFlexGridSizer,
40873 &_swigt__p_wxFocusEvent,
40874 &_swigt__p_wxFont,
40875 &_swigt__p_wxFrame,
40876 &_swigt__p_wxGBSizerItem,
40877 &_swigt__p_wxGIFHandler,
40878 &_swigt__p_wxGridBagSizer,
40879 &_swigt__p_wxGridSizer,
40880 &_swigt__p_wxICOHandler,
40881 &_swigt__p_wxIcon,
40882 &_swigt__p_wxIconizeEvent,
40883 &_swigt__p_wxIdleEvent,
40884 &_swigt__p_wxImage,
40885 &_swigt__p_wxImageHandler,
40886 &_swigt__p_wxIndividualLayoutConstraint,
40887 &_swigt__p_wxInitDialogEvent,
40888 &_swigt__p_wxJPEGHandler,
40889 &_swigt__p_wxJoystick,
40890 &_swigt__p_wxJoystickEvent,
40891 &_swigt__p_wxKeyEvent,
40892 &_swigt__p_wxKillError,
40893 &_swigt__p_wxLayoutConstraints,
40894 &_swigt__p_wxLog,
40895 &_swigt__p_wxLogBuffer,
40896 &_swigt__p_wxLogChain,
40897 &_swigt__p_wxLogGui,
40898 &_swigt__p_wxLogNull,
40899 &_swigt__p_wxLogStderr,
40900 &_swigt__p_wxLogTextCtrl,
40901 &_swigt__p_wxLogWindow,
40902 &_swigt__p_wxMaximizeEvent,
40903 &_swigt__p_wxMenu,
40904 &_swigt__p_wxMenuBar,
40905 &_swigt__p_wxMenuEvent,
40906 &_swigt__p_wxMenuItem,
40907 &_swigt__p_wxMetafileDataObject,
40908 &_swigt__p_wxMimeTypesManager,
40909 &_swigt__p_wxMouseCaptureChangedEvent,
40910 &_swigt__p_wxMouseCaptureLostEvent,
40911 &_swigt__p_wxMouseEvent,
40912 &_swigt__p_wxMouseState,
40913 &_swigt__p_wxMoveEvent,
40914 &_swigt__p_wxMutexGuiLocker,
40915 &_swigt__p_wxNavigationKeyEvent,
40916 &_swigt__p_wxNcPaintEvent,
40917 &_swigt__p_wxNotifyEvent,
40918 &_swigt__p_wxObject,
40919 &_swigt__p_wxOutputStream,
40920 &_swigt__p_wxPCXHandler,
40921 &_swigt__p_wxPNGHandler,
40922 &_swigt__p_wxPNMHandler,
40923 &_swigt__p_wxPaintEvent,
40924 &_swigt__p_wxPaletteChangedEvent,
40925 &_swigt__p_wxPaperSize,
40926 &_swigt__p_wxPlatformInfo,
40927 &_swigt__p_wxPoint,
40928 &_swigt__p_wxPowerEvent,
40929 &_swigt__p_wxProcessEvent,
40930 &_swigt__p_wxPyApp,
40931 &_swigt__p_wxPyArtProvider,
40932 &_swigt__p_wxPyBitmapDataObject,
40933 &_swigt__p_wxPyCommandEvent,
40934 &_swigt__p_wxPyDataObjectSimple,
40935 &_swigt__p_wxPyDropSource,
40936 &_swigt__p_wxPyDropTarget,
40937 &_swigt__p_wxPyEvent,
40938 &_swigt__p_wxPyFileDropTarget,
40939 &_swigt__p_wxPyImageHandler,
40940 &_swigt__p_wxPyLog,
40941 &_swigt__p_wxPyProcess,
40942 &_swigt__p_wxPySizer,
40943 &_swigt__p_wxPyTextDataObject,
40944 &_swigt__p_wxPyTextDropTarget,
40945 &_swigt__p_wxPyTimer,
40946 &_swigt__p_wxPyTipProvider,
40947 &_swigt__p_wxPyValidator,
40948 &_swigt__p_wxQueryNewPaletteEvent,
40949 &_swigt__p_wxRect,
40950 &_swigt__p_wxScrollEvent,
40951 &_swigt__p_wxScrollWinEvent,
40952 &_swigt__p_wxSetCursorEvent,
40953 &_swigt__p_wxShowEvent,
40954 &_swigt__p_wxSingleInstanceChecker,
40955 &_swigt__p_wxSize,
40956 &_swigt__p_wxSizeEvent,
40957 &_swigt__p_wxSizer,
40958 &_swigt__p_wxSizerItem,
40959 &_swigt__p_wxSound,
40960 &_swigt__p_wxStandardPaths,
40961 &_swigt__p_wxStaticBoxSizer,
40962 &_swigt__p_wxStdDialogButtonSizer,
40963 &_swigt__p_wxStopWatch,
40964 &_swigt__p_wxString,
40965 &_swigt__p_wxSysColourChangedEvent,
40966 &_swigt__p_wxSystemOptions,
40967 &_swigt__p_wxSystemSettings,
40968 &_swigt__p_wxTGAHandler,
40969 &_swigt__p_wxTIFFHandler,
40970 &_swigt__p_wxTextCtrl,
40971 &_swigt__p_wxTextDataObject,
40972 &_swigt__p_wxTimeSpan,
40973 &_swigt__p_wxTimer,
40974 &_swigt__p_wxTimerEvent,
40975 &_swigt__p_wxTimerRunner,
40976 &_swigt__p_wxTipProvider,
40977 &_swigt__p_wxToolTip,
40978 &_swigt__p_wxURLDataObject,
40979 &_swigt__p_wxUpdateUIEvent,
40980 &_swigt__p_wxValidator,
40981 &_swigt__p_wxVideoMode,
40982 &_swigt__p_wxWindow,
40983 &_swigt__p_wxWindowCreateEvent,
40984 &_swigt__p_wxWindowDestroyEvent,
40985 &_swigt__p_wxWindowDisabler,
40986 &_swigt__p_wxXPMHandler,
40987 };
40988
40989 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
40990 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
40991 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
40992 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
40993 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
40994 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
40995 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
40996 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
40997 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
40998 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
40999 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}};
41000 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41001 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41002 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41003 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41004 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41005 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41006 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41007 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41008 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}};
41009 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41010 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41011 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41012 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41013 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41014 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}};
41015 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41016 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}};
41017 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41018 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41019 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41020 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41021 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41022 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41023 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41024 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41025 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41026 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41027 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41028 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41029 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41030 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41031 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41032 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41033 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41034 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41035 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41036 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41037 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41038 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41039 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41040 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41041 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41042 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41043 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41044 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41045 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41046 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41047 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41048 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41052 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41053 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41054 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41055 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41060 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}};
41061 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41073 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41079 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}};
41080 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41134 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}};
41135 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41152 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}};
41153 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41157 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}};
41158 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41161 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}};
41162 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41163
41164 static swig_cast_info *swig_cast_initial[] = {
41165 _swigc__p_char,
41166 _swigc__p_form_ops_t,
41167 _swigc__p_int,
41168 _swigc__p_unsigned_char,
41169 _swigc__p_unsigned_int,
41170 _swigc__p_unsigned_long,
41171 _swigc__p_void,
41172 _swigc__p_wxANIHandler,
41173 _swigc__p_wxAboutDialogInfo,
41174 _swigc__p_wxAcceleratorTable,
41175 _swigc__p_wxActivateEvent,
41176 _swigc__p_wxArrayString,
41177 _swigc__p_wxBMPHandler,
41178 _swigc__p_wxBitmap,
41179 _swigc__p_wxBitmapDataObject,
41180 _swigc__p_wxBoxSizer,
41181 _swigc__p_wxBusyCursor,
41182 _swigc__p_wxBusyInfo,
41183 _swigc__p_wxCURHandler,
41184 _swigc__p_wxCaret,
41185 _swigc__p_wxChar,
41186 _swigc__p_wxChildFocusEvent,
41187 _swigc__p_wxClipboard,
41188 _swigc__p_wxClipboardLocker,
41189 _swigc__p_wxClipboardTextEvent,
41190 _swigc__p_wxCloseEvent,
41191 _swigc__p_wxColour,
41192 _swigc__p_wxCommandEvent,
41193 _swigc__p_wxConfig,
41194 _swigc__p_wxConfigBase,
41195 _swigc__p_wxConfigPathChanger,
41196 _swigc__p_wxContextMenuEvent,
41197 _swigc__p_wxControl,
41198 _swigc__p_wxControlWithItems,
41199 _swigc__p_wxCursor,
41200 _swigc__p_wxCustomDataObject,
41201 _swigc__p_wxDC,
41202 _swigc__p_wxDataFormat,
41203 _swigc__p_wxDataObject,
41204 _swigc__p_wxDataObjectComposite,
41205 _swigc__p_wxDataObjectSimple,
41206 _swigc__p_wxDateEvent,
41207 _swigc__p_wxDateSpan,
41208 _swigc__p_wxDateTime,
41209 _swigc__p_wxDateTime__TimeZone,
41210 _swigc__p_wxDisplay,
41211 _swigc__p_wxDisplayChangedEvent,
41212 _swigc__p_wxDropFilesEvent,
41213 _swigc__p_wxDuplexMode,
41214 _swigc__p_wxEraseEvent,
41215 _swigc__p_wxEvent,
41216 _swigc__p_wxEvtHandler,
41217 _swigc__p_wxFSFile,
41218 _swigc__p_wxFileConfig,
41219 _swigc__p_wxFileDataObject,
41220 _swigc__p_wxFileHistory,
41221 _swigc__p_wxFileSystem,
41222 _swigc__p_wxFileType,
41223 _swigc__p_wxFileTypeInfo,
41224 _swigc__p_wxFlexGridSizer,
41225 _swigc__p_wxFocusEvent,
41226 _swigc__p_wxFont,
41227 _swigc__p_wxFrame,
41228 _swigc__p_wxGBSizerItem,
41229 _swigc__p_wxGIFHandler,
41230 _swigc__p_wxGridBagSizer,
41231 _swigc__p_wxGridSizer,
41232 _swigc__p_wxICOHandler,
41233 _swigc__p_wxIcon,
41234 _swigc__p_wxIconizeEvent,
41235 _swigc__p_wxIdleEvent,
41236 _swigc__p_wxImage,
41237 _swigc__p_wxImageHandler,
41238 _swigc__p_wxIndividualLayoutConstraint,
41239 _swigc__p_wxInitDialogEvent,
41240 _swigc__p_wxJPEGHandler,
41241 _swigc__p_wxJoystick,
41242 _swigc__p_wxJoystickEvent,
41243 _swigc__p_wxKeyEvent,
41244 _swigc__p_wxKillError,
41245 _swigc__p_wxLayoutConstraints,
41246 _swigc__p_wxLog,
41247 _swigc__p_wxLogBuffer,
41248 _swigc__p_wxLogChain,
41249 _swigc__p_wxLogGui,
41250 _swigc__p_wxLogNull,
41251 _swigc__p_wxLogStderr,
41252 _swigc__p_wxLogTextCtrl,
41253 _swigc__p_wxLogWindow,
41254 _swigc__p_wxMaximizeEvent,
41255 _swigc__p_wxMenu,
41256 _swigc__p_wxMenuBar,
41257 _swigc__p_wxMenuEvent,
41258 _swigc__p_wxMenuItem,
41259 _swigc__p_wxMetafileDataObject,
41260 _swigc__p_wxMimeTypesManager,
41261 _swigc__p_wxMouseCaptureChangedEvent,
41262 _swigc__p_wxMouseCaptureLostEvent,
41263 _swigc__p_wxMouseEvent,
41264 _swigc__p_wxMouseState,
41265 _swigc__p_wxMoveEvent,
41266 _swigc__p_wxMutexGuiLocker,
41267 _swigc__p_wxNavigationKeyEvent,
41268 _swigc__p_wxNcPaintEvent,
41269 _swigc__p_wxNotifyEvent,
41270 _swigc__p_wxObject,
41271 _swigc__p_wxOutputStream,
41272 _swigc__p_wxPCXHandler,
41273 _swigc__p_wxPNGHandler,
41274 _swigc__p_wxPNMHandler,
41275 _swigc__p_wxPaintEvent,
41276 _swigc__p_wxPaletteChangedEvent,
41277 _swigc__p_wxPaperSize,
41278 _swigc__p_wxPlatformInfo,
41279 _swigc__p_wxPoint,
41280 _swigc__p_wxPowerEvent,
41281 _swigc__p_wxProcessEvent,
41282 _swigc__p_wxPyApp,
41283 _swigc__p_wxPyArtProvider,
41284 _swigc__p_wxPyBitmapDataObject,
41285 _swigc__p_wxPyCommandEvent,
41286 _swigc__p_wxPyDataObjectSimple,
41287 _swigc__p_wxPyDropSource,
41288 _swigc__p_wxPyDropTarget,
41289 _swigc__p_wxPyEvent,
41290 _swigc__p_wxPyFileDropTarget,
41291 _swigc__p_wxPyImageHandler,
41292 _swigc__p_wxPyLog,
41293 _swigc__p_wxPyProcess,
41294 _swigc__p_wxPySizer,
41295 _swigc__p_wxPyTextDataObject,
41296 _swigc__p_wxPyTextDropTarget,
41297 _swigc__p_wxPyTimer,
41298 _swigc__p_wxPyTipProvider,
41299 _swigc__p_wxPyValidator,
41300 _swigc__p_wxQueryNewPaletteEvent,
41301 _swigc__p_wxRect,
41302 _swigc__p_wxScrollEvent,
41303 _swigc__p_wxScrollWinEvent,
41304 _swigc__p_wxSetCursorEvent,
41305 _swigc__p_wxShowEvent,
41306 _swigc__p_wxSingleInstanceChecker,
41307 _swigc__p_wxSize,
41308 _swigc__p_wxSizeEvent,
41309 _swigc__p_wxSizer,
41310 _swigc__p_wxSizerItem,
41311 _swigc__p_wxSound,
41312 _swigc__p_wxStandardPaths,
41313 _swigc__p_wxStaticBoxSizer,
41314 _swigc__p_wxStdDialogButtonSizer,
41315 _swigc__p_wxStopWatch,
41316 _swigc__p_wxString,
41317 _swigc__p_wxSysColourChangedEvent,
41318 _swigc__p_wxSystemOptions,
41319 _swigc__p_wxSystemSettings,
41320 _swigc__p_wxTGAHandler,
41321 _swigc__p_wxTIFFHandler,
41322 _swigc__p_wxTextCtrl,
41323 _swigc__p_wxTextDataObject,
41324 _swigc__p_wxTimeSpan,
41325 _swigc__p_wxTimer,
41326 _swigc__p_wxTimerEvent,
41327 _swigc__p_wxTimerRunner,
41328 _swigc__p_wxTipProvider,
41329 _swigc__p_wxToolTip,
41330 _swigc__p_wxURLDataObject,
41331 _swigc__p_wxUpdateUIEvent,
41332 _swigc__p_wxValidator,
41333 _swigc__p_wxVideoMode,
41334 _swigc__p_wxWindow,
41335 _swigc__p_wxWindowCreateEvent,
41336 _swigc__p_wxWindowDestroyEvent,
41337 _swigc__p_wxWindowDisabler,
41338 _swigc__p_wxXPMHandler,
41339 };
41340
41341
41342 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41343
41344 static swig_const_info swig_const_table[] = {
41345 {0, 0, 0, 0.0, 0, 0}};
41346
41347 #ifdef __cplusplus
41348 }
41349 #endif
41350 /* -----------------------------------------------------------------------------
41351 * Type initialization:
41352 * This problem is tough by the requirement that no dynamic
41353 * memory is used. Also, since swig_type_info structures store pointers to
41354 * swig_cast_info structures and swig_cast_info structures store pointers back
41355 * to swig_type_info structures, we need some lookup code at initialization.
41356 * The idea is that swig generates all the structures that are needed.
41357 * The runtime then collects these partially filled structures.
41358 * The SWIG_InitializeModule function takes these initial arrays out of
41359 * swig_module, and does all the lookup, filling in the swig_module.types
41360 * array with the correct data and linking the correct swig_cast_info
41361 * structures together.
41362 *
41363 * The generated swig_type_info structures are assigned staticly to an initial
41364 * array. We just loop though that array, and handle each type individually.
41365 * First we lookup if this type has been already loaded, and if so, use the
41366 * loaded structure instead of the generated one. Then we have to fill in the
41367 * cast linked list. The cast data is initially stored in something like a
41368 * two-dimensional array. Each row corresponds to a type (there are the same
41369 * number of rows as there are in the swig_type_initial array). Each entry in
41370 * a column is one of the swig_cast_info structures for that type.
41371 * The cast_initial array is actually an array of arrays, because each row has
41372 * a variable number of columns. So to actually build the cast linked list,
41373 * we find the array of casts associated with the type, and loop through it
41374 * adding the casts to the list. The one last trick we need to do is making
41375 * sure the type pointer in the swig_cast_info struct is correct.
41376 *
41377 * First off, we lookup the cast->type name to see if it is already loaded.
41378 * There are three cases to handle:
41379 * 1) If the cast->type has already been loaded AND the type we are adding
41380 * casting info to has not been loaded (it is in this module), THEN we
41381 * replace the cast->type pointer with the type pointer that has already
41382 * been loaded.
41383 * 2) If BOTH types (the one we are adding casting info to, and the
41384 * cast->type) are loaded, THEN the cast info has already been loaded by
41385 * the previous module so we just ignore it.
41386 * 3) Finally, if cast->type has not already been loaded, then we add that
41387 * swig_cast_info to the linked list (because the cast->type) pointer will
41388 * be correct.
41389 * ----------------------------------------------------------------------------- */
41390
41391 #ifdef __cplusplus
41392 extern "C" {
41393 #if 0
41394 } /* c-mode */
41395 #endif
41396 #endif
41397
41398 #if 0
41399 #define SWIGRUNTIME_DEBUG
41400 #endif
41401
41402 SWIGRUNTIME void
41403 SWIG_InitializeModule(void *clientdata) {
41404 size_t i;
41405 swig_module_info *module_head;
41406 static int init_run = 0;
41407
41408 clientdata = clientdata;
41409
41410 if (init_run) return;
41411 init_run = 1;
41412
41413 /* Initialize the swig_module */
41414 swig_module.type_initial = swig_type_initial;
41415 swig_module.cast_initial = swig_cast_initial;
41416
41417 /* Try and load any already created modules */
41418 module_head = SWIG_GetModule(clientdata);
41419 if (module_head) {
41420 swig_module.next = module_head->next;
41421 module_head->next = &swig_module;
41422 } else {
41423 /* This is the first module loaded */
41424 swig_module.next = &swig_module;
41425 SWIG_SetModule(clientdata, &swig_module);
41426 }
41427
41428 /* Now work on filling in swig_module.types */
41429 #ifdef SWIGRUNTIME_DEBUG
41430 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41431 #endif
41432 for (i = 0; i < swig_module.size; ++i) {
41433 swig_type_info *type = 0;
41434 swig_type_info *ret;
41435 swig_cast_info *cast;
41436
41437 #ifdef SWIGRUNTIME_DEBUG
41438 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41439 #endif
41440
41441 /* if there is another module already loaded */
41442 if (swig_module.next != &swig_module) {
41443 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41444 }
41445 if (type) {
41446 /* Overwrite clientdata field */
41447 #ifdef SWIGRUNTIME_DEBUG
41448 printf("SWIG_InitializeModule: found type %s\n", type->name);
41449 #endif
41450 if (swig_module.type_initial[i]->clientdata) {
41451 type->clientdata = swig_module.type_initial[i]->clientdata;
41452 #ifdef SWIGRUNTIME_DEBUG
41453 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41454 #endif
41455 }
41456 } else {
41457 type = swig_module.type_initial[i];
41458 }
41459
41460 /* Insert casting types */
41461 cast = swig_module.cast_initial[i];
41462 while (cast->type) {
41463 /* Don't need to add information already in the list */
41464 ret = 0;
41465 #ifdef SWIGRUNTIME_DEBUG
41466 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41467 #endif
41468 if (swig_module.next != &swig_module) {
41469 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41470 #ifdef SWIGRUNTIME_DEBUG
41471 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41472 #endif
41473 }
41474 if (ret) {
41475 if (type == swig_module.type_initial[i]) {
41476 #ifdef SWIGRUNTIME_DEBUG
41477 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41478 #endif
41479 cast->type = ret;
41480 ret = 0;
41481 } else {
41482 /* Check for casting already in the list */
41483 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41484 #ifdef SWIGRUNTIME_DEBUG
41485 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41486 #endif
41487 if (!ocast) ret = 0;
41488 }
41489 }
41490
41491 if (!ret) {
41492 #ifdef SWIGRUNTIME_DEBUG
41493 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41494 #endif
41495 if (type->cast) {
41496 type->cast->prev = cast;
41497 cast->next = type->cast;
41498 }
41499 type->cast = cast;
41500 }
41501 cast++;
41502 }
41503 /* Set entry in modules->types array equal to the type */
41504 swig_module.types[i] = type;
41505 }
41506 swig_module.types[i] = 0;
41507
41508 #ifdef SWIGRUNTIME_DEBUG
41509 printf("**** SWIG_InitializeModule: Cast List ******\n");
41510 for (i = 0; i < swig_module.size; ++i) {
41511 int j = 0;
41512 swig_cast_info *cast = swig_module.cast_initial[i];
41513 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41514 while (cast->type) {
41515 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41516 cast++;
41517 ++j;
41518 }
41519 printf("---- Total casts: %d\n",j);
41520 }
41521 printf("**** SWIG_InitializeModule: Cast List ******\n");
41522 #endif
41523 }
41524
41525 /* This function will propagate the clientdata field of type to
41526 * any new swig_type_info structures that have been added into the list
41527 * of equivalent types. It is like calling
41528 * SWIG_TypeClientData(type, clientdata) a second time.
41529 */
41530 SWIGRUNTIME void
41531 SWIG_PropagateClientData(void) {
41532 size_t i;
41533 swig_cast_info *equiv;
41534 static int init_run = 0;
41535
41536 if (init_run) return;
41537 init_run = 1;
41538
41539 for (i = 0; i < swig_module.size; i++) {
41540 if (swig_module.types[i]->clientdata) {
41541 equiv = swig_module.types[i]->cast;
41542 while (equiv) {
41543 if (!equiv->converter) {
41544 if (equiv->type && !equiv->type->clientdata)
41545 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41546 }
41547 equiv = equiv->next;
41548 }
41549 }
41550 }
41551 }
41552
41553 #ifdef __cplusplus
41554 #if 0
41555 {
41556 /* c-mode */
41557 #endif
41558 }
41559 #endif
41560
41561
41562
41563 #ifdef __cplusplus
41564 extern "C" {
41565 #endif
41566
41567 /* Python-specific SWIG API */
41568 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41569 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41570 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41571
41572 /* -----------------------------------------------------------------------------
41573 * global variable support code.
41574 * ----------------------------------------------------------------------------- */
41575
41576 typedef struct swig_globalvar {
41577 char *name; /* Name of global variable */
41578 PyObject *(*get_attr)(void); /* Return the current value */
41579 int (*set_attr)(PyObject *); /* Set the value */
41580 struct swig_globalvar *next;
41581 } swig_globalvar;
41582
41583 typedef struct swig_varlinkobject {
41584 PyObject_HEAD
41585 swig_globalvar *vars;
41586 } swig_varlinkobject;
41587
41588 SWIGINTERN PyObject *
41589 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41590 return PyString_FromString("<Swig global variables>");
41591 }
41592
41593 SWIGINTERN PyObject *
41594 swig_varlink_str(swig_varlinkobject *v) {
41595 PyObject *str = PyString_FromString("(");
41596 swig_globalvar *var;
41597 for (var = v->vars; var; var=var->next) {
41598 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41599 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41600 }
41601 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41602 return str;
41603 }
41604
41605 SWIGINTERN int
41606 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41607 PyObject *str = swig_varlink_str(v);
41608 fprintf(fp,"Swig global variables ");
41609 fprintf(fp,"%s\n", PyString_AsString(str));
41610 Py_DECREF(str);
41611 return 0;
41612 }
41613
41614 SWIGINTERN void
41615 swig_varlink_dealloc(swig_varlinkobject *v) {
41616 swig_globalvar *var = v->vars;
41617 while (var) {
41618 swig_globalvar *n = var->next;
41619 free(var->name);
41620 free(var);
41621 var = n;
41622 }
41623 }
41624
41625 SWIGINTERN PyObject *
41626 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41627 PyObject *res = NULL;
41628 swig_globalvar *var = v->vars;
41629 while (var) {
41630 if (strcmp(var->name,n) == 0) {
41631 res = (*var->get_attr)();
41632 break;
41633 }
41634 var = var->next;
41635 }
41636 if (res == NULL && !PyErr_Occurred()) {
41637 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41638 }
41639 return res;
41640 }
41641
41642 SWIGINTERN int
41643 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41644 int res = 1;
41645 swig_globalvar *var = v->vars;
41646 while (var) {
41647 if (strcmp(var->name,n) == 0) {
41648 res = (*var->set_attr)(p);
41649 break;
41650 }
41651 var = var->next;
41652 }
41653 if (res == 1 && !PyErr_Occurred()) {
41654 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41655 }
41656 return res;
41657 }
41658
41659 SWIGINTERN PyTypeObject*
41660 swig_varlink_type(void) {
41661 static char varlink__doc__[] = "Swig var link object";
41662 static PyTypeObject varlink_type;
41663 static int type_init = 0;
41664 if (!type_init) {
41665 const PyTypeObject tmp
41666 = {
41667 PyObject_HEAD_INIT(NULL)
41668 0, /* Number of items in variable part (ob_size) */
41669 (char *)"swigvarlink", /* Type name (tp_name) */
41670 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41671 0, /* Itemsize (tp_itemsize) */
41672 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41673 (printfunc) swig_varlink_print, /* Print (tp_print) */
41674 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41675 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41676 0, /* tp_compare */
41677 (reprfunc) swig_varlink_repr, /* tp_repr */
41678 0, /* tp_as_number */
41679 0, /* tp_as_sequence */
41680 0, /* tp_as_mapping */
41681 0, /* tp_hash */
41682 0, /* tp_call */
41683 (reprfunc)swig_varlink_str, /* tp_str */
41684 0, /* tp_getattro */
41685 0, /* tp_setattro */
41686 0, /* tp_as_buffer */
41687 0, /* tp_flags */
41688 varlink__doc__, /* tp_doc */
41689 0, /* tp_traverse */
41690 0, /* tp_clear */
41691 0, /* tp_richcompare */
41692 0, /* tp_weaklistoffset */
41693 #if PY_VERSION_HEX >= 0x02020000
41694 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41695 #endif
41696 #if PY_VERSION_HEX >= 0x02030000
41697 0, /* tp_del */
41698 #endif
41699 #ifdef COUNT_ALLOCS
41700 0,0,0,0 /* tp_alloc -> tp_next */
41701 #endif
41702 };
41703 varlink_type = tmp;
41704 varlink_type.ob_type = &PyType_Type;
41705 type_init = 1;
41706 }
41707 return &varlink_type;
41708 }
41709
41710 /* Create a variable linking object for use later */
41711 SWIGINTERN PyObject *
41712 SWIG_Python_newvarlink(void) {
41713 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41714 if (result) {
41715 result->vars = 0;
41716 }
41717 return ((PyObject*) result);
41718 }
41719
41720 SWIGINTERN void
41721 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41722 swig_varlinkobject *v = (swig_varlinkobject *) p;
41723 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41724 if (gv) {
41725 size_t size = strlen(name)+1;
41726 gv->name = (char *)malloc(size);
41727 if (gv->name) {
41728 strncpy(gv->name,name,size);
41729 gv->get_attr = get_attr;
41730 gv->set_attr = set_attr;
41731 gv->next = v->vars;
41732 }
41733 }
41734 v->vars = gv;
41735 }
41736
41737 SWIGINTERN PyObject *
41738 SWIG_globals() {
41739 static PyObject *_SWIG_globals = 0;
41740 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41741 return _SWIG_globals;
41742 }
41743
41744 /* -----------------------------------------------------------------------------
41745 * constants/methods manipulation
41746 * ----------------------------------------------------------------------------- */
41747
41748 /* Install Constants */
41749 SWIGINTERN void
41750 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41751 PyObject *obj = 0;
41752 size_t i;
41753 for (i = 0; constants[i].type; ++i) {
41754 switch(constants[i].type) {
41755 case SWIG_PY_POINTER:
41756 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41757 break;
41758 case SWIG_PY_BINARY:
41759 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41760 break;
41761 default:
41762 obj = 0;
41763 break;
41764 }
41765 if (obj) {
41766 PyDict_SetItemString(d, constants[i].name, obj);
41767 Py_DECREF(obj);
41768 }
41769 }
41770 }
41771
41772 /* -----------------------------------------------------------------------------*/
41773 /* Fix SwigMethods to carry the callback ptrs when needed */
41774 /* -----------------------------------------------------------------------------*/
41775
41776 SWIGINTERN void
41777 SWIG_Python_FixMethods(PyMethodDef *methods,
41778 swig_const_info *const_table,
41779 swig_type_info **types,
41780 swig_type_info **types_initial) {
41781 size_t i;
41782 for (i = 0; methods[i].ml_name; ++i) {
41783 const char *c = methods[i].ml_doc;
41784 if (c && (c = strstr(c, "swig_ptr: "))) {
41785 int j;
41786 swig_const_info *ci = 0;
41787 const char *name = c + 10;
41788 for (j = 0; const_table[j].type; ++j) {
41789 if (strncmp(const_table[j].name, name,
41790 strlen(const_table[j].name)) == 0) {
41791 ci = &(const_table[j]);
41792 break;
41793 }
41794 }
41795 if (ci) {
41796 size_t shift = (ci->ptype) - types;
41797 swig_type_info *ty = types_initial[shift];
41798 size_t ldoc = (c - methods[i].ml_doc);
41799 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41800 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41801 if (ndoc) {
41802 char *buff = ndoc;
41803 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41804 if (ptr) {
41805 strncpy(buff, methods[i].ml_doc, ldoc);
41806 buff += ldoc;
41807 strncpy(buff, "swig_ptr: ", 10);
41808 buff += 10;
41809 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41810 methods[i].ml_doc = ndoc;
41811 }
41812 }
41813 }
41814 }
41815 }
41816 }
41817
41818 #ifdef __cplusplus
41819 }
41820 #endif
41821
41822 /* -----------------------------------------------------------------------------*
41823 * Partial Init method
41824 * -----------------------------------------------------------------------------*/
41825
41826 #ifdef __cplusplus
41827 extern "C"
41828 #endif
41829 SWIGEXPORT void SWIG_init(void) {
41830 PyObject *m, *d;
41831
41832 /* Fix SwigMethods to carry the callback ptrs when needed */
41833 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41834
41835 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41836 d = PyModule_GetDict(m);
41837
41838 SWIG_InitializeModule(0);
41839 SWIG_InstallConstants(d,swig_const_table);
41840
41841
41842 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41843 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41844 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41845 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41846 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41847 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41848 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41849 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41850 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41851 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41852 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41853 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41854 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41855 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41856 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41857 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41858 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41859 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41860 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41861 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41862 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41863 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41864 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41865 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41866 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41867 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41868 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41869 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41870 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41871 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41872 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41873 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41874 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41875 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41876 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41877 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41878 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41879 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41880 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41881 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41882 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41883 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41884 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41885 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41886 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41887 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41888 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41889 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41890 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41891 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41892 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41893 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41894 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41895 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41896 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41897 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41898 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41899 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41900 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41901 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41902 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41903 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41904 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41905 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41906 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41907 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41908 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41909 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41910 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41911 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41912 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41913 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41914 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41915 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41916 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41917 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41918 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41919 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41920 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41921 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41922 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41923 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41924 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41925 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41926 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41927 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41928 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41929 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41930 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41931 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41932 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41933 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41934 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41935 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41936 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41937 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41938 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41939 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41940 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41941 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41942 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41943 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41944 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
41945 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
41946 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
41947 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
41948 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
41949 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
41950 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
41951 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
41952 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
41953 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
41954 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
41955 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
41956 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
41957 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
41958 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
41959 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
41960 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
41961 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
41962 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
41963 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
41964 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
41965 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
41966 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
41967 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
41968 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
41969 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
41970 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
41971 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
41972 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
41973 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
41974 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
41975 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
41976 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
41977 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
41978 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
41979 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
41980 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
41981 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
41982 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
41983 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
41984 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
41985 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
41986 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
41987 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
41988 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
41989 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
41990
41991 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
41992
41993 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
41994 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
41995 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
41996 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
41997 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
41998 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
41999 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42000 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42001 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42002 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42003 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42004 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42005 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42006 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42007 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42008 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42009 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42010 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42011 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42012 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42013 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42014 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42015 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42016 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42017 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42018 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42019 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42020 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42021 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42022 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42023 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42024 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42025 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42026 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42027 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42028 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42029 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42030 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42031 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42032 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42033 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42034 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42035 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42036 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42037 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42038 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42039 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42040 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42041 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42042 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42043 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42044 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42045 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42046
42047 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42048
42049 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42050 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42051 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42052 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42053 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42054 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42055 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42056 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42057 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42058 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42059 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42060 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42061 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42062 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42063 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42064 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42065 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42066 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42067 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42068 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42069 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42070 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42071 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42072 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42073 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42074 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42075 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42076 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42077 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42078 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42079 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42080 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42081 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42082 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42083 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42084 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42085 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42086 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42087 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42088 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42089 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42090 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42091 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42092 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42093 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42094 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42095 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42096 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42097 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42098 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42099 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42100 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42101 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42102 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42103 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42104 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42105 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42106 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42107 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42108 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42109 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42110 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42111 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42112 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42113 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42114 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42115 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42117 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42118 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42119 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42120 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42121 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42122 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42125
42126 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42127
42128 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42129 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42130 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42131 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42132 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42133 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42134 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42135 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42136 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42137 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42138 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42139 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42140 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42141 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42142 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42143 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42144 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42145 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42146 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42147 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42148 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42149 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42150 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42151 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42152 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42153 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42154 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42155 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42156 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42157 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42158 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42159 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42160 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42161 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42162 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42163 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42164 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42165 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42166 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42167 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42168 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42169 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42170 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42171 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42172 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42173 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42174 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42175 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42176 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42177 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42178 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42179 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42180 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42181 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42182 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42183 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42184 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42185 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42186 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42187 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42188 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42189 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42190 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42191 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42192 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42193 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42194 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42195 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42196 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42197 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42198 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42199 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42200 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42201 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42202 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42203 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42204 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42205 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42206 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42207 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42208 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42209 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42210 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42211 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42212 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42213 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42214 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42215 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42216 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42217 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42218 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42219 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42220 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42221 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42222 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42223 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42224 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42225 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42226 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42227 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42228 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42229 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42230 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42231 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42232 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42233 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42234 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42235 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42236 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42237 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42238 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42239 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42240 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42241 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42242 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42243 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42244 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42245 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42246 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42247 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42248 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42249 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42250 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42251 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42252 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42253 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42254 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42255 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42256 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42257 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42258 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42259 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42260 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42261 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42262 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42263 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42264 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42265 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42266 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42267 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42268 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42269 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42270 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42271 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42272 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42273 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42274 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42275 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42276 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42277 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42278 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42279 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42280 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42281 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42282 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42283 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42284 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42285 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42286 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42287 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42288 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42289 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42290 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42291 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42292 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42293 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42294 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42295 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42296 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42297 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42298 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42299 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42300 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42301 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42302 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42303 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42304 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42305 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42306 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42307 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42308 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42309 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42310 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42311 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42312 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42313 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42314 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42315 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42316 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42317 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42318 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42319 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42320 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42321 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42322 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42323 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42324 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42325 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42326 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42327 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42328 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42329 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42330 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42331
42332 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42333 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42334 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42335 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42336
42337 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42338 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42339 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42340 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42341 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42342 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42343 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42344 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42345 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42346 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42347 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42348 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42349 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42350 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42351 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42352 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42353 }
42354
wxWidgets (Impactor)