projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
aui docking works well on systems with solid window dragging turned off
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_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 SWIGINTERN int
2822 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2823 {
2824 long v = 0;
2825 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2826 return SWIG_TypeError;
2827 }
2828 else if (val)
2829 *val = (unsigned long)v;
2830 return SWIG_OK;
2831 }
2832
2833
2834 SWIGINTERNINLINE PyObject*
2835 SWIG_From_unsigned_SS_long (unsigned long value)
2836 {
2837 return (value > LONG_MAX) ?
2838 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2839 }
2840
2841
2842 void* wxGetXDisplay()
2843 {
2844 #ifdef __WXGTK__
2845 return wxGetDisplay();
2846 #else
2847 return NULL;
2848 #endif
2849 }
2850
2851
2852 wxWindow* FindWindowAtPointer() {
2853 wxPoint unused;
2854 return wxFindWindowAtPointer(unused);
2855 }
2856
2857
2858 bool wxThread_IsMain() {
2859 #ifdef WXP_WITH_THREAD
2860 return wxThread::IsMain();
2861 #else
2862 return true;
2863 #endif
2864 }
2865
2866 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2867 delete self;
2868 }
2869
2870 #include <wx/snglinst.h>
2871
2872
2873 #ifdef __WXMSW__
2874 #include <wx/msw/private.h>
2875 #include <wx/dynload.h>
2876 #endif
2877
2878
2879
2880 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2881 #if 0
2882 , int method
2883 #endif
2884 )
2885 {
2886 #ifdef __WXMSW__
2887 #if 0
2888 switch (method)
2889 {
2890 case 1:
2891 // This one only partially works. Appears to be an undocumented
2892 // "standard" convention that not all widgets adhear to. For
2893 // example, for some widgets backgrounds or non-client areas may
2894 // not be painted.
2895 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2896 break;
2897
2898 case 2:
2899 #endif
2900 // This one works much better, nearly all widgets and their
2901 // children are captured correctly[**]. Prior to the big
2902 // background erase changes that Vadim did in 2004-2005 this
2903 // method failed badly on XP with Themes activated, most native
2904 // widgets draw only partially, if at all. Without themes it
2905 // worked just like on Win2k. After those changes this method
2906 // works very well.
2907 //
2908 // ** For example the radio buttons in a wxRadioBox are not its
2909 // children by default, but you can capture it via the panel
2910 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2911 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2912 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2913 PRF_ERASEBKGND | PRF_OWNED );
2914 return true;
2915 #if 0
2916 break;
2917
2918 case 3:
2919 // This one is only defined in the latest SDK and is only
2920 // available on XP. MSDN says it is similar to sending WM_PRINT
2921 // so I expect that it will work similar to the above. Since it
2922 // is avaialble only on XP, it can't be compiled like this and
2923 // will have to be loaded dynamically.
2924 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2925
2926 // fall through
2927
2928 case 4:
2929 // Use PrintWindow if available, or fallback to WM_PRINT
2930 // otherwise. Unfortunately using PrintWindow is even worse than
2931 // WM_PRINT. For most native widgets nothing is drawn to the dc
2932 // at all, with or without Themes.
2933 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2934 static bool s_triedToLoad = false;
2935 static PrintWindow_t pfnPrintWindow = NULL;
2936 if ( !s_triedToLoad )
2937 {
2938
2939 s_triedToLoad = true;
2940 wxDynamicLibrary dllUser32(_T("user32.dll"));
2941 if ( dllUser32.IsLoaded() )
2942 {
2943 wxLogNull nolog; // Don't report errors here
2944 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2945 }
2946 }
2947 if (pfnPrintWindow)
2948 {
2949 //printf("Using PrintWindow\n");
2950 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2951 }
2952 else
2953 {
2954 //printf("Using WM_PRINT\n");
2955 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2956 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2957 PRF_ERASEBKGND | PRF_OWNED );
2958 }
2959 }
2960 #endif // 0
2961 #else
2962 return false;
2963 #endif // __WXMSW__
2964 }
2965
2966
2967
2968 #include <wx/tipdlg.h>
2969
2970
2971 SWIGINTERNINLINE PyObject *
2972 SWIG_From_size_t (size_t value)
2973 {
2974 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2975 }
2976
2977
2978 class wxPyTipProvider : public wxTipProvider {
2979 public:
2980 wxPyTipProvider(size_t currentTip)
2981 : wxTipProvider(currentTip) {}
2982
2983 DEC_PYCALLBACK_STRING__pure(GetTip);
2984 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2985 PYPRIVATE;
2986 };
2987
2988 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2989 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2990
2991
2992 SWIGINTERNINLINE int
2993 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2994 {
2995 unsigned long v;
2996 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2997 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2998 return res;
2999 }
3000
3001
3002 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3003
3004 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3005
3006 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3007 : wxTimer(owner, id)
3008 {
3009 if (owner == NULL)
3010 SetOwner(this);
3011 }
3012
3013
3014 SWIGINTERN swig_type_info*
3015 SWIG_pchar_descriptor()
3016 {
3017 static int init = 0;
3018 static swig_type_info* info = 0;
3019 if (!init) {
3020 info = SWIG_TypeQuery("_p_char");
3021 init = 1;
3022 }
3023 return info;
3024 }
3025
3026
3027 SWIGINTERNINLINE PyObject *
3028 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3029 {
3030 if (carray) {
3031 if (size > INT_MAX) {
3032 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3033 return pchar_descriptor ?
3034 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3035 } else {
3036 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3037 }
3038 } else {
3039 return SWIG_Py_Void();
3040 }
3041 }
3042
3043
3044 SWIGINTERNINLINE PyObject *
3045 SWIG_FromCharPtr(const char *cptr)
3046 {
3047 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3048 }
3049
3050
3051 SWIGINTERN int
3052 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3053 {
3054 unsigned long v;
3055 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3056 if (SWIG_IsOK(res)) {
3057 if ((v > UINT_MAX)) {
3058 return SWIG_OverflowError;
3059 } else {
3060 if (val) *val = static_cast< unsigned int >(v);
3061 }
3062 }
3063 return res;
3064 }
3065
3066 SWIGINTERN wxString wxLog_TimeStamp(){
3067 wxString msg;
3068 wxLog::TimeStamp(&msg);
3069 return msg;
3070 }
3071 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3072 // Make some wrappers that double any % signs so they are 'escaped'
3073 void wxPyLogFatalError(const wxString& msg)
3074 {
3075 wxString m(msg);
3076 m.Replace(wxT("%"), wxT("%%"));
3077 wxLogFatalError(m);
3078 }
3079
3080 void wxPyLogError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogError(m);
3085 }
3086
3087 void wxPyLogWarning(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogWarning(m);
3092 }
3093
3094 void wxPyLogMessage(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogMessage(m);
3099 }
3100
3101 void wxPyLogInfo(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogInfo(m);
3106 }
3107
3108 void wxPyLogDebug(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogDebug(m);
3113 }
3114
3115 void wxPyLogVerbose(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogVerbose(m);
3120 }
3121
3122 void wxPyLogStatus(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogStatus(m);
3127 }
3128
3129 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(pFrame, m);
3134 }
3135
3136 void wxPyLogSysError(const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogSysError(m);
3141 }
3142
3143 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogGeneric(level, m);
3148 }
3149
3150 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogTrace(mask, m);
3155 }
3156
3157 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164
3165
3166 // A wxLog class that can be derived from in wxPython
3167 class wxPyLog : public wxLog {
3168 public:
3169 wxPyLog() : wxLog() {}
3170
3171 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3172 bool found;
3173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3174 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3175 PyObject* s = wx2PyString(szString);
3176 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3177 Py_DECREF(s);
3178 }
3179 wxPyEndBlockThreads(blocked);
3180 if (! found)
3181 wxLog::DoLog(level, szString, t);
3182 }
3183
3184 virtual void DoLogString(const wxChar *szString, time_t t) {
3185 bool found;
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3188 PyObject* s = wx2PyString(szString);
3189 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3190 Py_DECREF(s);
3191 }
3192 wxPyEndBlockThreads(blocked);
3193 if (! found)
3194 wxLog::DoLogString(szString, t);
3195 }
3196
3197 DEC_PYCALLBACK_VOID_(Flush);
3198 PYPRIVATE;
3199 };
3200 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3201
3202
3203
3204
3205 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3206
3207
3208 #include <wx/joystick.h>
3209
3210
3211 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3212 // A C++ stub class for wxJoystick for platforms that don't have it.
3213 class wxJoystick : public wxObject {
3214 public:
3215 wxJoystick(int joystick = wxJOYSTICK1) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 PyErr_SetString(PyExc_NotImplementedError,
3218 "wxJoystick is not available on this platform.");
3219 wxPyEndBlockThreads(blocked);
3220 }
3221 wxPoint GetPosition() { return wxPoint(-1,-1); }
3222 int GetZPosition() { return -1; }
3223 int GetButtonState() { return -1; }
3224 int GetPOVPosition() { return -1; }
3225 int GetPOVCTSPosition() { return -1; }
3226 int GetRudderPosition() { return -1; }
3227 int GetUPosition() { return -1; }
3228 int GetVPosition() { return -1; }
3229 int GetMovementThreshold() { return -1; }
3230 void SetMovementThreshold(int threshold) {}
3231
3232 bool IsOk(void) { return false; }
3233 int GetNumberJoysticks() { return -1; }
3234 int GetManufacturerId() { return -1; }
3235 int GetProductId() { return -1; }
3236 wxString GetProductName() { return wxEmptyString; }
3237 int GetXMin() { return -1; }
3238 int GetYMin() { return -1; }
3239 int GetZMin() { return -1; }
3240 int GetXMax() { return -1; }
3241 int GetYMax() { return -1; }
3242 int GetZMax() { return -1; }
3243 int GetNumberButtons() { return -1; }
3244 int GetNumberAxes() { return -1; }
3245 int GetMaxButtons() { return -1; }
3246 int GetMaxAxes() { return -1; }
3247 int GetPollingMin() { return -1; }
3248 int GetPollingMax() { return -1; }
3249 int GetRudderMin() { return -1; }
3250 int GetRudderMax() { return -1; }
3251 int GetUMin() { return -1; }
3252 int GetUMax() { return -1; }
3253 int GetVMin() { return -1; }
3254 int GetVMax() { return -1; }
3255
3256 bool HasRudder() { return false; }
3257 bool HasZ() { return false; }
3258 bool HasU() { return false; }
3259 bool HasV() { return false; }
3260 bool HasPOV() { return false; }
3261 bool HasPOV4Dir() { return false; }
3262 bool HasPOVCTS() { return false; }
3263
3264 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3265 bool ReleaseCapture() { return false; }
3266 };
3267 #endif
3268
3269
3270 #include <wx/sound.h>
3271
3272
3273 #if !wxUSE_SOUND
3274 // A C++ stub class for wxWave for platforms that don't have it.
3275 class wxSound : public wxObject
3276 {
3277 public:
3278 wxSound() {
3279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3280 PyErr_SetString(PyExc_NotImplementedError,
3281 "wxSound is not available on this platform.");
3282 wxPyEndBlockThreads(blocked);
3283 }
3284 wxSound(const wxString&/*, bool*/) {
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 PyErr_SetString(PyExc_NotImplementedError,
3287 "wxSound is not available on this platform.");
3288 wxPyEndBlockThreads(blocked);
3289 }
3290 wxSound(int, const wxByte*) {
3291 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3292 PyErr_SetString(PyExc_NotImplementedError,
3293 "wxSound is not available on this platform.");
3294 wxPyEndBlockThreads(blocked);
3295 }
3296
3297 ~wxSound() {};
3298
3299 bool Create(const wxString&/*, bool*/) { return false; }
3300 bool Create(int, const wxByte*) { return false; };
3301 bool IsOk() { return false; };
3302 bool Play(unsigned) const { return false; }
3303 static bool Play(const wxString&, unsigned) { return false; }
3304 static void Stop() {}
3305 };
3306
3307 #endif
3308
3309 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3310 if (fileName.Length() == 0)
3311 return new wxSound;
3312 else
3313 return new wxSound(fileName);
3314 }
3315 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3316 unsigned char* buffer; int size;
3317 wxSound *sound = NULL;
3318
3319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3320 if (!PyArg_Parse(data, "t#", &buffer, &size))
3321 goto done;
3322 sound = new wxSound(size, buffer);
3323 done:
3324 wxPyEndBlockThreads(blocked);
3325 return sound;
3326 }
3327 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3328 #ifndef __WXMAC__
3329 unsigned char* buffer;
3330 int size;
3331 bool rv = false;
3332
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 if (!PyArg_Parse(data, "t#", &buffer, &size))
3335 goto done;
3336 rv = self->Create(size, buffer);
3337 done:
3338 wxPyEndBlockThreads(blocked);
3339 return rv;
3340 #else
3341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3342 PyErr_SetString(PyExc_NotImplementedError,
3343 "Create from data is not available on this platform.");
3344 wxPyEndBlockThreads(blocked);
3345 return false;
3346 #endif
3347 }
3348
3349 #include <wx/mimetype.h>
3350
3351 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3352 wxString str;
3353 if (self->GetMimeType(&str))
3354 return wx2PyString(str);
3355 else
3356 RETURN_NONE();
3357 }
3358 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3359 wxArrayString arr;
3360 if (self->GetMimeTypes(arr))
3361 return wxArrayString2PyList_helper(arr);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetExtensions(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3373 wxIconLocation loc;
3374 if (self->GetIcon(&loc))
3375 return new wxIcon(loc);
3376 else
3377 return NULL;
3378 }
3379 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc)) {
3382 wxString iconFile = loc.GetFileName();
3383 int iconIndex = -1;
3384
3385
3386
3387 // Make a tuple and put the values in it
3388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3389 PyObject* tuple = PyTuple_New(3);
3390 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3391 wxT("wxIcon"), true));
3392 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3393 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3394 wxPyEndBlockThreads(blocked);
3395 return tuple;
3396 }
3397 else
3398 RETURN_NONE();
3399 }
3400 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3401 wxString str;
3402 if (self->GetDescription(&str))
3403 return wx2PyString(str);
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3408 wxString str;
3409 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxArrayString verbs;
3423 wxArrayString commands;
3424 if (self->GetAllCommands(&verbs, &commands,
3425 wxFileType::MessageParameters(filename, mimetype))) {
3426 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3427 PyObject* tuple = PyTuple_New(2);
3428 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3429 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3430 wxPyEndBlockThreads(blocked);
3431 return tuple;
3432 }
3433 else
3434 RETURN_NONE();
3435 }
3436 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3437 return wxFileType::ExpandCommand(command,
3438 wxFileType::MessageParameters(filename, mimetype));
3439 }
3440 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3441 wxArrayString arr;
3442 self->EnumAllFileTypes(arr);
3443 return wxArrayString2PyList_helper(arr);
3444 }
3445
3446 #include <wx/artprov.h>
3447
3448 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3449 static const wxString wxPyART_MENU(wxART_MENU);
3450 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3451 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3452 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3453 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3454 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3455 static const wxString wxPyART_OTHER(wxART_OTHER);
3456 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3457 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3458 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3459 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3460 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3461 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3462 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3463 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3464 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3465 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3466 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3467 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3468 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3469 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3470 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3471 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3472 static const wxString wxPyART_PRINT(wxART_PRINT);
3473 static const wxString wxPyART_HELP(wxART_HELP);
3474 static const wxString wxPyART_TIP(wxART_TIP);
3475 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3476 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3477 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3478 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3479 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3480 static const wxString wxPyART_CDROM(wxART_CDROM);
3481 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3482 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3483 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3484 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3485 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3486 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3487 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3488 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3489 static const wxString wxPyART_ERROR(wxART_ERROR);
3490 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3491 static const wxString wxPyART_WARNING(wxART_WARNING);
3492 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3493 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3494 static const wxString wxPyART_COPY(wxART_COPY);
3495 static const wxString wxPyART_CUT(wxART_CUT);
3496 static const wxString wxPyART_PASTE(wxART_PASTE);
3497 static const wxString wxPyART_DELETE(wxART_DELETE);
3498 static const wxString wxPyART_NEW(wxART_NEW);
3499 static const wxString wxPyART_UNDO(wxART_UNDO);
3500 static const wxString wxPyART_REDO(wxART_REDO);
3501 static const wxString wxPyART_QUIT(wxART_QUIT);
3502 static const wxString wxPyART_FIND(wxART_FIND);
3503 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3504 // Python aware wxArtProvider
3505 class wxPyArtProvider : public wxArtProvider {
3506 public:
3507
3508 virtual wxBitmap CreateBitmap(const wxArtID& id,
3509 const wxArtClient& client,
3510 const wxSize& size) {
3511 wxBitmap rval = wxNullBitmap;
3512 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3513 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3514 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3515 PyObject* ro;
3516 wxBitmap* ptr;
3517 PyObject* s1, *s2;
3518 s1 = wx2PyString(id);
3519 s2 = wx2PyString(client);
3520 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3521 Py_DECREF(so);
3522 Py_DECREF(s1);
3523 Py_DECREF(s2);
3524 if (ro) {
3525 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3526 rval = *ptr;
3527 Py_DECREF(ro);
3528 }
3529 }
3530 wxPyEndBlockThreads(blocked);
3531 return rval;
3532 }
3533
3534 PYPRIVATE;
3535 };
3536
3537 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3538
3539
3540
3541 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3542 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3543 PyObject* ret = PyTuple_New(3);
3544 if (ret) {
3545 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3546 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3547 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3548 }
3549 wxPyEndBlockThreads(blocked);
3550 return ret;
3551 }
3552
3553 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3554 bool cont;
3555 long index = 0;
3556 wxString value;
3557
3558 cont = self->GetFirstGroup(value, index);
3559 return __EnumerationHelper(cont, value, index);
3560 }
3561 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3562 bool cont;
3563 wxString value;
3564
3565 cont = self->GetNextGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3569 bool cont;
3570 long index = 0;
3571 wxString value;
3572
3573 cont = self->GetFirstEntry(value, index);
3574 return __EnumerationHelper(cont, value, index);
3575 }
3576 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3577 bool cont;
3578 wxString value;
3579
3580 cont = self->GetNextEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3584 long rv;
3585 self->Read(key, &rv, defaultVal);
3586 return rv;
3587 }
3588
3589 SWIGINTERN int
3590 SWIG_AsVal_double (PyObject *obj, double* val)
3591 {
3592 if (PyNumber_Check(obj)) {
3593 if (val) *val = PyFloat_AsDouble(obj);
3594 return SWIG_OK;
3595 }
3596 return SWIG_TypeError;
3597 }
3598
3599 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3600 double rv;
3601 self->Read(key, &rv, defaultVal);
3602 return rv;
3603 }
3604
3605 #define SWIG_From_double PyFloat_FromDouble
3606
3607 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3608 bool rv;
3609 self->Read(key, &rv, defaultVal);
3610 return rv;
3611 }
3612
3613 #include <wx/datetime.h>
3614
3615 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3616 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3617
3618 #define LOCAL_TZ wxDateTime::Local
3619
3620 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3621 wxString am;
3622 wxString pm;
3623 wxDateTime::GetAmPmStrings(&am, &pm);
3624 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3625 PyObject* tup = PyTuple_New(2);
3626 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3627 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3628 wxPyEndBlockThreads(blocked);
3629 return tup;
3630 }
3631
3632 SWIGINTERNINLINE PyObject *
3633 SWIG_From_unsigned_SS_int (unsigned int value)
3634 {
3635 return SWIG_From_unsigned_SS_long (value);
3636 }
3637
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3639 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3640 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3642 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3643 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3644 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3645 return (*self < *other);
3646 }
3647 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3649 return (*self <= *other);
3650 }
3651 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3653 return (*self > *other);
3654 }
3655 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3657 return (*self >= *other);
3658 }
3659 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3661 return (*self == *other);
3662 }
3663 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3665 return (*self != *other);
3666 }
3667 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3668 const wxChar* rv;
3669 const wxChar* _date = date;
3670 rv = self->ParseRfc822Date(_date);
3671 if (rv == NULL) return -1;
3672 return rv - _date;
3673 }
3674 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseFormat(_date, format, dateDef);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3682 const wxChar* rv;
3683 const wxChar* _datetime = datetime;
3684 rv = self->ParseDateTime(_datetime);
3685 if (rv == NULL) return -1;
3686 return rv - _datetime;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3689 const wxChar* rv;
3690 const wxChar* _date = date;
3691 rv = self->ParseDate(_date);
3692 if (rv == NULL) return -1;
3693 return rv - _date;
3694 }
3695 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3696 const wxChar* rv;
3697 const wxChar* _time = time;
3698 rv = self->ParseTime(_time);
3699 if (rv == NULL) return -1;
3700 return rv - _time;
3701 }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3705 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3706 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3710 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3712 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3714 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3715 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3716 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3717 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3718
3719 #include <wx/dataobj.h>
3720
3721 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3722 size_t count = self->GetFormatCount(dir);
3723 wxDataFormat* formats = new wxDataFormat[count];
3724 self->GetAllFormats(formats, dir);
3725
3726 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3727 PyObject* list = PyList_New(count);
3728 for (size_t i=0; i<count; i++) {
3729 wxDataFormat* format = new wxDataFormat(formats[i]);
3730 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3731 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3732 }
3733 wxPyEndBlockThreads(blocked);
3734 delete [] formats;
3735 return list;
3736 }
3737 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3738 PyObject* rval = NULL;
3739 size_t size = self->GetDataSize(format);
3740 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3741 if (size) {
3742 char* buf = new char[size];
3743 if (self->GetDataHere(format, buf))
3744 rval = PyString_FromStringAndSize(buf, size);
3745 delete [] buf;
3746 }
3747 if (! rval) {
3748 rval = Py_None;
3749 Py_INCREF(rval);
3750 }
3751 wxPyEndBlockThreads(blocked);
3752 return rval;
3753 }
3754 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3755 bool rval;
3756 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3757 if (PyString_Check(data)) {
3758 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3759 }
3760 else {
3761 // raise a TypeError if not a string
3762 PyErr_SetString(PyExc_TypeError, "String expected.");
3763 rval = false;
3764 }
3765 wxPyEndBlockThreads(blocked);
3766 return rval;
3767 }
3768 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3769 PyObject* rval = NULL;
3770 size_t size = self->GetDataSize();
3771 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3772 if (size) {
3773 char* buf = new char[size];
3774 if (self->GetDataHere(buf))
3775 rval = PyString_FromStringAndSize(buf, size);
3776 delete [] buf;
3777 }
3778 if (! rval) {
3779 rval = Py_None;
3780 Py_INCREF(rval);
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return rval;
3784 }
3785 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3786 bool rval;
3787 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3788 if (PyString_Check(data)) {
3789 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3790 }
3791 else {
3792 // raise a TypeError if not a string
3793 PyErr_SetString(PyExc_TypeError, "String expected.");
3794 rval = false;
3795 }
3796 wxPyEndBlockThreads(blocked);
3797 return rval;
3798 }
3799 // Create a new class for wxPython to use
3800 class wxPyDataObjectSimple : public wxDataObjectSimple {
3801 public:
3802 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3803 : wxDataObjectSimple(format) {}
3804
3805 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3806 bool GetDataHere(void *buf) const;
3807 bool SetData(size_t len, const void *buf);
3808 PYPRIVATE;
3809 };
3810
3811 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3812
3813 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3814 // We need to get the data for this object and write it to buf. I think
3815 // the best way to do this for wxPython is to have the Python method
3816 // return either a string or None and then act appropriately with the
3817 // C++ version.
3818
3819 bool rval = false;
3820 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3821 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3822 PyObject* ro;
3823 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3824 if (ro) {
3825 rval = (ro != Py_None && PyString_Check(ro));
3826 if (rval)
3827 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3828 Py_DECREF(ro);
3829 }
3830 }
3831 wxPyEndBlockThreads(blocked);
3832 return rval;
3833 }
3834
3835 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3836 // For this one we simply need to make a string from buf and len
3837 // and send it to the Python method.
3838 bool rval = false;
3839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3840 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3841 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3842 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3843 Py_DECREF(data);
3844 }
3845 wxPyEndBlockThreads(blocked);
3846 return rval;
3847 }
3848
3849 // Create a new class for wxPython to use
3850 class wxPyTextDataObject : public wxTextDataObject {
3851 public:
3852 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3853 : wxTextDataObject(text) {}
3854
3855 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3856 DEC_PYCALLBACK_STRING__const(GetText);
3857 DEC_PYCALLBACK__STRING(SetText);
3858 PYPRIVATE;
3859 };
3860
3861 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3862 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3863 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3864
3865
3866 // Create a new class for wxPython to use
3867 class wxPyBitmapDataObject : public wxBitmapDataObject {
3868 public:
3869 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3870 : wxBitmapDataObject(bitmap) {}
3871
3872 wxBitmap GetBitmap() const;
3873 void SetBitmap(const wxBitmap& bitmap);
3874 PYPRIVATE;
3875 };
3876
3877 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3878 wxBitmap* rval = &wxNullBitmap;
3879 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3880 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3881 PyObject* ro;
3882 wxBitmap* ptr;
3883 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3884 if (ro) {
3885 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3886 rval = ptr;
3887 Py_DECREF(ro);
3888 }
3889 }
3890 wxPyEndBlockThreads(blocked);
3891 return *rval;
3892 }
3893
3894 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3895 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3896 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3897 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3898 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3899 Py_DECREF(bo);
3900 }
3901 wxPyEndBlockThreads(blocked);
3902 }
3903
3904 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3905 return new wxCustomDataObject(wxDataFormat(formatName));
3906 }
3907 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3908 bool rval;
3909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3910 if (PyString_Check(data)) {
3911 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3912 }
3913 else {
3914 // raise a TypeError if not a string
3915 PyErr_SetString(PyExc_TypeError, "String expected.");
3916 rval = false;
3917 }
3918 wxPyEndBlockThreads(blocked);
3919 return rval;
3920 }
3921 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3922 PyObject* obj;
3923 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3924 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3925 wxPyEndBlockThreads(blocked);
3926 return obj;
3927 }
3928
3929 #include <wx/metafile.h>
3930
3931
3932 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3933
3934
3935 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3937 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3938 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3939 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3940
3941
3942 class wxPyTextDropTarget : public wxTextDropTarget {
3943 public:
3944 wxPyTextDropTarget() {}
3945
3946 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3947
3948 DEC_PYCALLBACK__(OnLeave);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3951 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3952 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3953
3954 PYPRIVATE;
3955 };
3956
3957 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3958 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3961 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3962 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3963
3964
3965
3966 class wxPyFileDropTarget : public wxFileDropTarget {
3967 public:
3968 wxPyFileDropTarget() {}
3969
3970 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3971
3972 DEC_PYCALLBACK__(OnLeave);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3975 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3976 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3977
3978 PYPRIVATE;
3979 };
3980
3981 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3982 const wxArrayString& filenames) {
3983 bool rval = false;
3984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3985 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3986 PyObject* list = wxArrayString2PyList_helper(filenames);
3987 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3988 Py_DECREF(list);
3989 }
3990 wxPyEndBlockThreads(blocked);
3991 return rval;
3992 }
3993
3994
3995
3996 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3999 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4000 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4001
4002
4003
4004
4005 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4006
4007 #include <wx/display.h>
4008
4009 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4010 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4011
4012 #if !wxUSE_DISPLAY
4013 const wxVideoMode wxDefaultVideoMode;
4014 #endif
4015
4016 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4017 #if wxUSE_DISPLAY
4018 PyObject* pyList = NULL;
4019 wxArrayVideoModes arr = self->GetModes(mode);
4020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4021 pyList = PyList_New(0);
4022 for (size_t i=0; i < arr.GetCount(); i++)
4023 {
4024 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4025 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4026 PyList_Append(pyList, pyObj);
4027 Py_DECREF(pyObj);
4028 }
4029 wxPyEndBlockThreads(blocked);
4030 return pyList;
4031 #else
4032 wxPyRaiseNotImplemented();
4033 return NULL;
4034 #endif
4035 }
4036 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4037 #if wxUSE_DISPLAY
4038 return self->GetCurrentMode();
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return wxDefaultVideoMode;
4042 #endif
4043 }
4044 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4045 #if wxUSE_DISPLAY
4046 return self->ChangeMode(mode);
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return false;
4050 #endif
4051 }
4052 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4053 #if wxUSE_DISPLAY
4054 self->ResetMode();
4055 #else
4056 wxPyRaiseNotImplemented();
4057 #endif
4058 }
4059
4060 #include <wx/stdpaths.h>
4061
4062 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4063 return (wxStandardPaths*) &wxStandardPaths::Get();
4064 }
4065 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4066 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4067
4068 #ifndef wxHAS_POWER_EVENTS
4069 // Dummy class and other definitions for platforms that don't have them
4070
4071 // See wxPython_int.h for wxPowerEvent
4072
4073 enum {
4074 wxEVT_POWER_SUSPENDING,
4075 wxEVT_POWER_SUSPENDED,
4076 wxEVT_POWER_SUSPEND_CANCEL,
4077 wxEVT_POWER_RESUME,
4078 };
4079
4080 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4081 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4082
4083 #endif
4084
4085
4086 #include <wx/aboutdlg.h>
4087
4088 #ifdef __cplusplus
4089 extern "C" {
4090 #endif
4091 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4092 PyObject *resultobj = 0;
4093 wxSystemColour arg1 ;
4094 wxColour result;
4095 int val1 ;
4096 int ecode1 = 0 ;
4097 PyObject * obj0 = 0 ;
4098 char * kwnames[] = {
4099 (char *) "index", NULL
4100 };
4101
4102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4103 ecode1 = SWIG_AsVal_int(obj0, &val1);
4104 if (!SWIG_IsOK(ecode1)) {
4105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4106 }
4107 arg1 = static_cast< wxSystemColour >(val1);
4108 {
4109 if (!wxPyCheckForApp()) SWIG_fail;
4110 PyThreadState* __tstate = wxPyBeginAllowThreads();
4111 result = wxSystemSettings::GetColour(arg1);
4112 wxPyEndAllowThreads(__tstate);
4113 if (PyErr_Occurred()) SWIG_fail;
4114 }
4115 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4116 return resultobj;
4117 fail:
4118 return NULL;
4119 }
4120
4121
4122 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4123 PyObject *resultobj = 0;
4124 wxSystemFont arg1 ;
4125 wxFont result;
4126 int val1 ;
4127 int ecode1 = 0 ;
4128 PyObject * obj0 = 0 ;
4129 char * kwnames[] = {
4130 (char *) "index", NULL
4131 };
4132
4133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4134 ecode1 = SWIG_AsVal_int(obj0, &val1);
4135 if (!SWIG_IsOK(ecode1)) {
4136 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4137 }
4138 arg1 = static_cast< wxSystemFont >(val1);
4139 {
4140 if (!wxPyCheckForApp()) SWIG_fail;
4141 PyThreadState* __tstate = wxPyBeginAllowThreads();
4142 result = wxSystemSettings::GetFont(arg1);
4143 wxPyEndAllowThreads(__tstate);
4144 if (PyErr_Occurred()) SWIG_fail;
4145 }
4146 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj = 0;
4155 wxSystemMetric arg1 ;
4156 wxWindow *arg2 = (wxWindow *) NULL ;
4157 int result;
4158 int val1 ;
4159 int ecode1 = 0 ;
4160 void *argp2 = 0 ;
4161 int res2 = 0 ;
4162 PyObject * obj0 = 0 ;
4163 PyObject * obj1 = 0 ;
4164 char * kwnames[] = {
4165 (char *) "index",(char *) "win", NULL
4166 };
4167
4168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4169 ecode1 = SWIG_AsVal_int(obj0, &val1);
4170 if (!SWIG_IsOK(ecode1)) {
4171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4172 }
4173 arg1 = static_cast< wxSystemMetric >(val1);
4174 if (obj1) {
4175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4176 if (!SWIG_IsOK(res2)) {
4177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4178 }
4179 arg2 = reinterpret_cast< wxWindow * >(argp2);
4180 }
4181 {
4182 if (!wxPyCheckForApp()) SWIG_fail;
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4185 wxPyEndAllowThreads(__tstate);
4186 if (PyErr_Occurred()) SWIG_fail;
4187 }
4188 resultobj = SWIG_From_int(static_cast< int >(result));
4189 return resultobj;
4190 fail:
4191 return NULL;
4192 }
4193
4194
4195 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4196 PyObject *resultobj = 0;
4197 wxSystemFeature arg1 ;
4198 bool result;
4199 int val1 ;
4200 int ecode1 = 0 ;
4201 PyObject * obj0 = 0 ;
4202 char * kwnames[] = {
4203 (char *) "index", NULL
4204 };
4205
4206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4207 ecode1 = SWIG_AsVal_int(obj0, &val1);
4208 if (!SWIG_IsOK(ecode1)) {
4209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4210 }
4211 arg1 = static_cast< wxSystemFeature >(val1);
4212 {
4213 if (!wxPyCheckForApp()) SWIG_fail;
4214 PyThreadState* __tstate = wxPyBeginAllowThreads();
4215 result = (bool)wxSystemSettings::HasFeature(arg1);
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 {
4220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4221 }
4222 return resultobj;
4223 fail:
4224 return NULL;
4225 }
4226
4227
4228 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4229 PyObject *resultobj = 0;
4230 wxSystemScreenType result;
4231
4232 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4233 {
4234 if (!wxPyCheckForApp()) SWIG_fail;
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4237 wxPyEndAllowThreads(__tstate);
4238 if (PyErr_Occurred()) SWIG_fail;
4239 }
4240 resultobj = SWIG_From_int(static_cast< int >(result));
4241 return resultobj;
4242 fail:
4243 return NULL;
4244 }
4245
4246
4247 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4248 PyObject *resultobj = 0;
4249 wxSystemScreenType arg1 ;
4250 int val1 ;
4251 int ecode1 = 0 ;
4252 PyObject * obj0 = 0 ;
4253 char * kwnames[] = {
4254 (char *) "screen", NULL
4255 };
4256
4257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4258 ecode1 = SWIG_AsVal_int(obj0, &val1);
4259 if (!SWIG_IsOK(ecode1)) {
4260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4261 }
4262 arg1 = static_cast< wxSystemScreenType >(val1);
4263 {
4264 if (!wxPyCheckForApp()) SWIG_fail;
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 wxSystemSettings::SetScreenType(arg1);
4267 wxPyEndAllowThreads(__tstate);
4268 if (PyErr_Occurred()) SWIG_fail;
4269 }
4270 resultobj = SWIG_Py_Void();
4271 return resultobj;
4272 fail:
4273 return NULL;
4274 }
4275
4276
4277 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4278 PyObject *obj;
4279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4280 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4281 return SWIG_Py_Void();
4282 }
4283
4284 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4285 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4286 return 1;
4287 }
4288
4289
4290 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4291 PyObject *pyobj = 0;
4292
4293 {
4294 #if wxUSE_UNICODE
4295 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4296 #else
4297 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4298 #endif
4299 }
4300 return pyobj;
4301 }
4302
4303
4304 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4305 PyObject *resultobj = 0;
4306 wxSystemOptions *result = 0 ;
4307
4308 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4309 {
4310 PyThreadState* __tstate = wxPyBeginAllowThreads();
4311 result = (wxSystemOptions *)new wxSystemOptions();
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4316 return resultobj;
4317 fail:
4318 return NULL;
4319 }
4320
4321
4322 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4323 PyObject *resultobj = 0;
4324 wxString *arg1 = 0 ;
4325 wxString *arg2 = 0 ;
4326 bool temp1 = false ;
4327 bool temp2 = false ;
4328 PyObject * obj0 = 0 ;
4329 PyObject * obj1 = 0 ;
4330 char * kwnames[] = {
4331 (char *) "name",(char *) "value", NULL
4332 };
4333
4334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4335 {
4336 arg1 = wxString_in_helper(obj0);
4337 if (arg1 == NULL) SWIG_fail;
4338 temp1 = true;
4339 }
4340 {
4341 arg2 = wxString_in_helper(obj1);
4342 if (arg2 == NULL) SWIG_fail;
4343 temp2 = true;
4344 }
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4348 wxPyEndAllowThreads(__tstate);
4349 if (PyErr_Occurred()) SWIG_fail;
4350 }
4351 resultobj = SWIG_Py_Void();
4352 {
4353 if (temp1)
4354 delete arg1;
4355 }
4356 {
4357 if (temp2)
4358 delete arg2;
4359 }
4360 return resultobj;
4361 fail:
4362 {
4363 if (temp1)
4364 delete arg1;
4365 }
4366 {
4367 if (temp2)
4368 delete arg2;
4369 }
4370 return NULL;
4371 }
4372
4373
4374 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4375 PyObject *resultobj = 0;
4376 wxString *arg1 = 0 ;
4377 int arg2 ;
4378 bool temp1 = false ;
4379 int val2 ;
4380 int ecode2 = 0 ;
4381 PyObject * obj0 = 0 ;
4382 PyObject * obj1 = 0 ;
4383 char * kwnames[] = {
4384 (char *) "name",(char *) "value", NULL
4385 };
4386
4387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4388 {
4389 arg1 = wxString_in_helper(obj0);
4390 if (arg1 == NULL) SWIG_fail;
4391 temp1 = true;
4392 }
4393 ecode2 = SWIG_AsVal_int(obj1, &val2);
4394 if (!SWIG_IsOK(ecode2)) {
4395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4396 }
4397 arg2 = static_cast< int >(val2);
4398 {
4399 PyThreadState* __tstate = wxPyBeginAllowThreads();
4400 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4401 wxPyEndAllowThreads(__tstate);
4402 if (PyErr_Occurred()) SWIG_fail;
4403 }
4404 resultobj = SWIG_Py_Void();
4405 {
4406 if (temp1)
4407 delete arg1;
4408 }
4409 return resultobj;
4410 fail:
4411 {
4412 if (temp1)
4413 delete arg1;
4414 }
4415 return NULL;
4416 }
4417
4418
4419 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj = 0;
4421 wxString *arg1 = 0 ;
4422 wxString result;
4423 bool temp1 = false ;
4424 PyObject * obj0 = 0 ;
4425 char * kwnames[] = {
4426 (char *) "name", NULL
4427 };
4428
4429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4430 {
4431 arg1 = wxString_in_helper(obj0);
4432 if (arg1 == NULL) SWIG_fail;
4433 temp1 = true;
4434 }
4435 {
4436 PyThreadState* __tstate = wxPyBeginAllowThreads();
4437 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 {
4442 #if wxUSE_UNICODE
4443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4444 #else
4445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4446 #endif
4447 }
4448 {
4449 if (temp1)
4450 delete arg1;
4451 }
4452 return resultobj;
4453 fail:
4454 {
4455 if (temp1)
4456 delete arg1;
4457 }
4458 return NULL;
4459 }
4460
4461
4462 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4463 PyObject *resultobj = 0;
4464 wxString *arg1 = 0 ;
4465 int result;
4466 bool temp1 = false ;
4467 PyObject * obj0 = 0 ;
4468 char * kwnames[] = {
4469 (char *) "name", NULL
4470 };
4471
4472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4473 {
4474 arg1 = wxString_in_helper(obj0);
4475 if (arg1 == NULL) SWIG_fail;
4476 temp1 = true;
4477 }
4478 {
4479 PyThreadState* __tstate = wxPyBeginAllowThreads();
4480 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4481 wxPyEndAllowThreads(__tstate);
4482 if (PyErr_Occurred()) SWIG_fail;
4483 }
4484 resultobj = SWIG_From_int(static_cast< int >(result));
4485 {
4486 if (temp1)
4487 delete arg1;
4488 }
4489 return resultobj;
4490 fail:
4491 {
4492 if (temp1)
4493 delete arg1;
4494 }
4495 return NULL;
4496 }
4497
4498
4499 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4500 PyObject *resultobj = 0;
4501 wxString *arg1 = 0 ;
4502 bool result;
4503 bool temp1 = false ;
4504 PyObject * obj0 = 0 ;
4505 char * kwnames[] = {
4506 (char *) "name", NULL
4507 };
4508
4509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4510 {
4511 arg1 = wxString_in_helper(obj0);
4512 if (arg1 == NULL) SWIG_fail;
4513 temp1 = true;
4514 }
4515 {
4516 PyThreadState* __tstate = wxPyBeginAllowThreads();
4517 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4518 wxPyEndAllowThreads(__tstate);
4519 if (PyErr_Occurred()) SWIG_fail;
4520 }
4521 {
4522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4523 }
4524 {
4525 if (temp1)
4526 delete arg1;
4527 }
4528 return resultobj;
4529 fail:
4530 {
4531 if (temp1)
4532 delete arg1;
4533 }
4534 return NULL;
4535 }
4536
4537
4538 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4539 PyObject *resultobj = 0;
4540 wxString *arg1 = 0 ;
4541 bool result;
4542 bool temp1 = false ;
4543 PyObject * obj0 = 0 ;
4544 char * kwnames[] = {
4545 (char *) "name", NULL
4546 };
4547
4548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4549 {
4550 arg1 = wxString_in_helper(obj0);
4551 if (arg1 == NULL) SWIG_fail;
4552 temp1 = true;
4553 }
4554 {
4555 PyThreadState* __tstate = wxPyBeginAllowThreads();
4556 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4557 wxPyEndAllowThreads(__tstate);
4558 if (PyErr_Occurred()) SWIG_fail;
4559 }
4560 {
4561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4562 }
4563 {
4564 if (temp1)
4565 delete arg1;
4566 }
4567 return resultobj;
4568 fail:
4569 {
4570 if (temp1)
4571 delete arg1;
4572 }
4573 return NULL;
4574 }
4575
4576
4577 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4578 PyObject *obj;
4579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4580 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4581 return SWIG_Py_Void();
4582 }
4583
4584 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4585 return SWIG_Python_InitShadowInstance(args);
4586 }
4587
4588 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4589 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4590 return 1;
4591 }
4592
4593
4594 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4595 PyObject *pyobj = 0;
4596
4597 {
4598 #if wxUSE_UNICODE
4599 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4600 #else
4601 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4602 #endif
4603 }
4604 return pyobj;
4605 }
4606
4607
4608 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4609 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4610 return 1;
4611 }
4612
4613
4614 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4615 PyObject *pyobj = 0;
4616
4617 {
4618 #if wxUSE_UNICODE
4619 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4620 #else
4621 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4622 #endif
4623 }
4624 return pyobj;
4625 }
4626
4627
4628 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4629 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4630 return 1;
4631 }
4632
4633
4634 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4635 PyObject *pyobj = 0;
4636
4637 {
4638 #if wxUSE_UNICODE
4639 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4640 #else
4641 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4642 #endif
4643 }
4644 return pyobj;
4645 }
4646
4647
4648 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4649 PyObject *resultobj = 0;
4650 long result;
4651
4652 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4653 {
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 result = (long)wxNewId();
4656 wxPyEndAllowThreads(__tstate);
4657 if (PyErr_Occurred()) SWIG_fail;
4658 }
4659 resultobj = SWIG_From_long(static_cast< long >(result));
4660 return resultobj;
4661 fail:
4662 return NULL;
4663 }
4664
4665
4666 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4667 PyObject *resultobj = 0;
4668 long arg1 ;
4669 long val1 ;
4670 int ecode1 = 0 ;
4671 PyObject * obj0 = 0 ;
4672 char * kwnames[] = {
4673 (char *) "id", NULL
4674 };
4675
4676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4677 ecode1 = SWIG_AsVal_long(obj0, &val1);
4678 if (!SWIG_IsOK(ecode1)) {
4679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4680 }
4681 arg1 = static_cast< long >(val1);
4682 {
4683 PyThreadState* __tstate = wxPyBeginAllowThreads();
4684 wxRegisterId(arg1);
4685 wxPyEndAllowThreads(__tstate);
4686 if (PyErr_Occurred()) SWIG_fail;
4687 }
4688 resultobj = SWIG_Py_Void();
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4696 PyObject *resultobj = 0;
4697 long result;
4698
4699 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4700 {
4701 PyThreadState* __tstate = wxPyBeginAllowThreads();
4702 result = (long)wxGetCurrentId();
4703 wxPyEndAllowThreads(__tstate);
4704 if (PyErr_Occurred()) SWIG_fail;
4705 }
4706 resultobj = SWIG_From_long(static_cast< long >(result));
4707 return resultobj;
4708 fail:
4709 return NULL;
4710 }
4711
4712
4713 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4714 PyObject *resultobj = 0;
4715 int arg1 ;
4716 bool result;
4717 int val1 ;
4718 int ecode1 = 0 ;
4719 PyObject * obj0 = 0 ;
4720 char * kwnames[] = {
4721 (char *) "id", NULL
4722 };
4723
4724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4725 ecode1 = SWIG_AsVal_int(obj0, &val1);
4726 if (!SWIG_IsOK(ecode1)) {
4727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4728 }
4729 arg1 = static_cast< int >(val1);
4730 {
4731 PyThreadState* __tstate = wxPyBeginAllowThreads();
4732 result = (bool)wxIsStockID(arg1);
4733 wxPyEndAllowThreads(__tstate);
4734 if (PyErr_Occurred()) SWIG_fail;
4735 }
4736 {
4737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4738 }
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = 0;
4747 int arg1 ;
4748 wxString *arg2 = 0 ;
4749 bool result;
4750 int val1 ;
4751 int ecode1 = 0 ;
4752 bool temp2 = false ;
4753 PyObject * obj0 = 0 ;
4754 PyObject * obj1 = 0 ;
4755 char * kwnames[] = {
4756 (char *) "id",(char *) "label", NULL
4757 };
4758
4759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4760 ecode1 = SWIG_AsVal_int(obj0, &val1);
4761 if (!SWIG_IsOK(ecode1)) {
4762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4763 }
4764 arg1 = static_cast< int >(val1);
4765 {
4766 arg2 = wxString_in_helper(obj1);
4767 if (arg2 == NULL) SWIG_fail;
4768 temp2 = true;
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4773 wxPyEndAllowThreads(__tstate);
4774 if (PyErr_Occurred()) SWIG_fail;
4775 }
4776 {
4777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4778 }
4779 {
4780 if (temp2)
4781 delete arg2;
4782 }
4783 return resultobj;
4784 fail:
4785 {
4786 if (temp2)
4787 delete arg2;
4788 }
4789 return NULL;
4790 }
4791
4792
4793 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4794 PyObject *resultobj = 0;
4795 int arg1 ;
4796 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4797 wxString result;
4798 int val1 ;
4799 int ecode1 = 0 ;
4800 long val2 ;
4801 int ecode2 = 0 ;
4802 PyObject * obj0 = 0 ;
4803 PyObject * obj1 = 0 ;
4804 char * kwnames[] = {
4805 (char *) "id",(char *) "flags", NULL
4806 };
4807
4808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4809 ecode1 = SWIG_AsVal_int(obj0, &val1);
4810 if (!SWIG_IsOK(ecode1)) {
4811 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4812 }
4813 arg1 = static_cast< int >(val1);
4814 if (obj1) {
4815 ecode2 = SWIG_AsVal_long(obj1, &val2);
4816 if (!SWIG_IsOK(ecode2)) {
4817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4818 }
4819 arg2 = static_cast< long >(val2);
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 result = wxGetStockLabel(arg1,arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 {
4828 #if wxUSE_UNICODE
4829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4830 #else
4831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4832 #endif
4833 }
4834 return resultobj;
4835 fail:
4836 return NULL;
4837 }
4838
4839
4840 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4841 PyObject *resultobj = 0;
4842 int arg1 ;
4843 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4844 wxString result;
4845 int val1 ;
4846 int ecode1 = 0 ;
4847 int val2 ;
4848 int ecode2 = 0 ;
4849 PyObject * obj0 = 0 ;
4850 PyObject * obj1 = 0 ;
4851 char * kwnames[] = {
4852 (char *) "id",(char *) "client", NULL
4853 };
4854
4855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4856 ecode1 = SWIG_AsVal_int(obj0, &val1);
4857 if (!SWIG_IsOK(ecode1)) {
4858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4859 }
4860 arg1 = static_cast< int >(val1);
4861 if (obj1) {
4862 ecode2 = SWIG_AsVal_int(obj1, &val2);
4863 if (!SWIG_IsOK(ecode2)) {
4864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4865 }
4866 arg2 = static_cast< wxStockHelpStringClient >(val2);
4867 }
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 result = wxGetStockHelpString(arg1,arg2);
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 {
4875 #if wxUSE_UNICODE
4876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4877 #else
4878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4879 #endif
4880 }
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4888 PyObject *resultobj = 0;
4889
4890 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4891 {
4892 if (!wxPyCheckForApp()) SWIG_fail;
4893 PyThreadState* __tstate = wxPyBeginAllowThreads();
4894 wxBell();
4895 wxPyEndAllowThreads(__tstate);
4896 if (PyErr_Occurred()) SWIG_fail;
4897 }
4898 resultobj = SWIG_Py_Void();
4899 return resultobj;
4900 fail:
4901 return NULL;
4902 }
4903
4904
4905 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4906 PyObject *resultobj = 0;
4907
4908 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4909 {
4910 if (!wxPyCheckForApp()) SWIG_fail;
4911 PyThreadState* __tstate = wxPyBeginAllowThreads();
4912 wxEndBusyCursor();
4913 wxPyEndAllowThreads(__tstate);
4914 if (PyErr_Occurred()) SWIG_fail;
4915 }
4916 resultobj = SWIG_Py_Void();
4917 return resultobj;
4918 fail:
4919 return NULL;
4920 }
4921
4922
4923 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4924 PyObject *resultobj = 0;
4925 bool arg1 = (bool) true ;
4926 long result;
4927 bool val1 ;
4928 int ecode1 = 0 ;
4929 PyObject * obj0 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "resetTimer", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4935 if (obj0) {
4936 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4937 if (!SWIG_IsOK(ecode1)) {
4938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4939 }
4940 arg1 = static_cast< bool >(val1);
4941 }
4942 {
4943 PyThreadState* __tstate = wxPyBeginAllowThreads();
4944 result = (long)wxGetElapsedTime(arg1);
4945 wxPyEndAllowThreads(__tstate);
4946 if (PyErr_Occurred()) SWIG_fail;
4947 }
4948 resultobj = SWIG_From_long(static_cast< long >(result));
4949 return resultobj;
4950 fail:
4951 return NULL;
4952 }
4953
4954
4955 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4956 PyObject *resultobj = 0;
4957 bool result;
4958
4959 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4960 {
4961 PyThreadState* __tstate = wxPyBeginAllowThreads();
4962 result = (bool)wxIsBusy();
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 {
4967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4968 }
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4976 PyObject *resultobj = 0;
4977 wxString result;
4978
4979 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 result = wxNow();
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 {
4987 #if wxUSE_UNICODE
4988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4989 #else
4990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4991 #endif
4992 }
4993 return resultobj;
4994 fail:
4995 return NULL;
4996 }
4997
4998
4999 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5000 PyObject *resultobj = 0;
5001 wxString const &arg1_defvalue = wxPyEmptyString ;
5002 wxString *arg1 = (wxString *) &arg1_defvalue ;
5003 bool result;
5004 bool temp1 = false ;
5005 PyObject * obj0 = 0 ;
5006 char * kwnames[] = {
5007 (char *) "command", NULL
5008 };
5009
5010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5011 if (obj0) {
5012 {
5013 arg1 = wxString_in_helper(obj0);
5014 if (arg1 == NULL) SWIG_fail;
5015 temp1 = true;
5016 }
5017 }
5018 {
5019 PyThreadState* __tstate = wxPyBeginAllowThreads();
5020 result = (bool)wxShell((wxString const &)*arg1);
5021 wxPyEndAllowThreads(__tstate);
5022 if (PyErr_Occurred()) SWIG_fail;
5023 }
5024 {
5025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5026 }
5027 {
5028 if (temp1)
5029 delete arg1;
5030 }
5031 return resultobj;
5032 fail:
5033 {
5034 if (temp1)
5035 delete arg1;
5036 }
5037 return NULL;
5038 }
5039
5040
5041 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5042 PyObject *resultobj = 0;
5043
5044 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5045 {
5046 PyThreadState* __tstate = wxPyBeginAllowThreads();
5047 wxStartTimer();
5048 wxPyEndAllowThreads(__tstate);
5049 if (PyErr_Occurred()) SWIG_fail;
5050 }
5051 resultobj = SWIG_Py_Void();
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5059 PyObject *resultobj = 0;
5060 int *arg1 = (int *) 0 ;
5061 int *arg2 = (int *) 0 ;
5062 int result;
5063 int temp1 ;
5064 int res1 = SWIG_TMPOBJ ;
5065 int temp2 ;
5066 int res2 = SWIG_TMPOBJ ;
5067
5068 arg1 = &temp1;
5069 arg2 = &temp2;
5070 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 result = (int)wxGetOsVersion(arg1,arg2);
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 resultobj = SWIG_From_int(static_cast< int >(result));
5078 if (SWIG_IsTmpObj(res1)) {
5079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5080 } else {
5081 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5083 }
5084 if (SWIG_IsTmpObj(res2)) {
5085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5086 } else {
5087 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5089 }
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxString result;
5099
5100 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5101 {
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 result = wxGetOsDescription();
5104 wxPyEndAllowThreads(__tstate);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 {
5108 #if wxUSE_UNICODE
5109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5110 #else
5111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5112 #endif
5113 }
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 bool result;
5123
5124 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5125 {
5126 PyThreadState* __tstate = wxPyBeginAllowThreads();
5127 result = (bool)wxIsPlatformLittleEndian();
5128 wxPyEndAllowThreads(__tstate);
5129 if (PyErr_Occurred()) SWIG_fail;
5130 }
5131 {
5132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5133 }
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5141 PyObject *resultobj = 0;
5142 bool result;
5143
5144 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5145 {
5146 PyThreadState* __tstate = wxPyBeginAllowThreads();
5147 result = (bool)wxIsPlatform64Bit();
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 {
5152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5153 }
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5161 PyObject *resultobj = 0;
5162 wxMemorySize result;
5163
5164 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5165 {
5166 PyThreadState* __tstate = wxPyBeginAllowThreads();
5167 result = wxGetFreeMemory();
5168 wxPyEndAllowThreads(__tstate);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 {
5172 #if wxUSE_LONGLONG
5173 resultobj = PyLong_FromLongLong((&result)->GetValue());
5174 #else
5175 resultobj = PyInt_FromLong(result);
5176 #endif
5177 }
5178 return resultobj;
5179 fail:
5180 return NULL;
5181 }
5182
5183
5184 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj = 0;
5186 wxShutdownFlags arg1 ;
5187 bool result;
5188 int val1 ;
5189 int ecode1 = 0 ;
5190 PyObject * obj0 = 0 ;
5191 char * kwnames[] = {
5192 (char *) "wFlags", NULL
5193 };
5194
5195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5196 ecode1 = SWIG_AsVal_int(obj0, &val1);
5197 if (!SWIG_IsOK(ecode1)) {
5198 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5199 }
5200 arg1 = static_cast< wxShutdownFlags >(val1);
5201 {
5202 if (!wxPyCheckForApp()) SWIG_fail;
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = (bool)wxShutdown(arg1);
5205 wxPyEndAllowThreads(__tstate);
5206 if (PyErr_Occurred()) SWIG_fail;
5207 }
5208 {
5209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5210 }
5211 return resultobj;
5212 fail:
5213 return NULL;
5214 }
5215
5216
5217 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5218 PyObject *resultobj = 0;
5219 int arg1 ;
5220 int val1 ;
5221 int ecode1 = 0 ;
5222 PyObject * obj0 = 0 ;
5223 char * kwnames[] = {
5224 (char *) "secs", NULL
5225 };
5226
5227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5228 ecode1 = SWIG_AsVal_int(obj0, &val1);
5229 if (!SWIG_IsOK(ecode1)) {
5230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5231 }
5232 arg1 = static_cast< int >(val1);
5233 {
5234 PyThreadState* __tstate = wxPyBeginAllowThreads();
5235 wxSleep(arg1);
5236 wxPyEndAllowThreads(__tstate);
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 resultobj = SWIG_Py_Void();
5240 return resultobj;
5241 fail:
5242 return NULL;
5243 }
5244
5245
5246 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5247 PyObject *resultobj = 0;
5248 unsigned long arg1 ;
5249 unsigned long val1 ;
5250 int ecode1 = 0 ;
5251 PyObject * obj0 = 0 ;
5252 char * kwnames[] = {
5253 (char *) "milliseconds", NULL
5254 };
5255
5256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5257 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5258 if (!SWIG_IsOK(ecode1)) {
5259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5260 }
5261 arg1 = static_cast< unsigned long >(val1);
5262 {
5263 PyThreadState* __tstate = wxPyBeginAllowThreads();
5264 wxMilliSleep(arg1);
5265 wxPyEndAllowThreads(__tstate);
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 resultobj = SWIG_Py_Void();
5269 return resultobj;
5270 fail:
5271 return NULL;
5272 }
5273
5274
5275 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5276 PyObject *resultobj = 0;
5277 unsigned long arg1 ;
5278 unsigned long val1 ;
5279 int ecode1 = 0 ;
5280 PyObject * obj0 = 0 ;
5281 char * kwnames[] = {
5282 (char *) "microseconds", NULL
5283 };
5284
5285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5286 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5287 if (!SWIG_IsOK(ecode1)) {
5288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5289 }
5290 arg1 = static_cast< unsigned long >(val1);
5291 {
5292 PyThreadState* __tstate = wxPyBeginAllowThreads();
5293 wxMicroSleep(arg1);
5294 wxPyEndAllowThreads(__tstate);
5295 if (PyErr_Occurred()) SWIG_fail;
5296 }
5297 resultobj = SWIG_Py_Void();
5298 return resultobj;
5299 fail:
5300 return NULL;
5301 }
5302
5303
5304 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5305 PyObject *resultobj = 0;
5306 bool arg1 ;
5307 bool val1 ;
5308 int ecode1 = 0 ;
5309 PyObject * obj0 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "enable", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5315 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5316 if (!SWIG_IsOK(ecode1)) {
5317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5318 }
5319 arg1 = static_cast< bool >(val1);
5320 {
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 wxEnableTopLevelWindows(arg1);
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 resultobj = SWIG_Py_Void();
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj = 0;
5335 wxString *arg1 = 0 ;
5336 wxString result;
5337 bool temp1 = false ;
5338 PyObject * obj0 = 0 ;
5339 char * kwnames[] = {
5340 (char *) "in", NULL
5341 };
5342
5343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5344 {
5345 arg1 = wxString_in_helper(obj0);
5346 if (arg1 == NULL) SWIG_fail;
5347 temp1 = true;
5348 }
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = wxStripMenuCodes((wxString const &)*arg1);
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 {
5356 #if wxUSE_UNICODE
5357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5358 #else
5359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5360 #endif
5361 }
5362 {
5363 if (temp1)
5364 delete arg1;
5365 }
5366 return resultobj;
5367 fail:
5368 {
5369 if (temp1)
5370 delete arg1;
5371 }
5372 return NULL;
5373 }
5374
5375
5376 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5377 PyObject *resultobj = 0;
5378 wxString result;
5379
5380 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5381 {
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 result = wxGetEmailAddress();
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 {
5388 #if wxUSE_UNICODE
5389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5390 #else
5391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5392 #endif
5393 }
5394 return resultobj;
5395 fail:
5396 return NULL;
5397 }
5398
5399
5400 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5401 PyObject *resultobj = 0;
5402 wxString result;
5403
5404 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5405 {
5406 PyThreadState* __tstate = wxPyBeginAllowThreads();
5407 result = wxGetHostName();
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 {
5412 #if wxUSE_UNICODE
5413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5414 #else
5415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5416 #endif
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425 PyObject *resultobj = 0;
5426 wxString result;
5427
5428 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5429 {
5430 PyThreadState* __tstate = wxPyBeginAllowThreads();
5431 result = wxGetFullHostName();
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 #if wxUSE_UNICODE
5437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5438 #else
5439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5440 #endif
5441 }
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5449 PyObject *resultobj = 0;
5450 wxString result;
5451
5452 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5453 {
5454 PyThreadState* __tstate = wxPyBeginAllowThreads();
5455 result = wxGetUserId();
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 {
5460 #if wxUSE_UNICODE
5461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5462 #else
5463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5464 #endif
5465 }
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5473 PyObject *resultobj = 0;
5474 wxString result;
5475
5476 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5477 {
5478 PyThreadState* __tstate = wxPyBeginAllowThreads();
5479 result = wxGetUserName();
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 {
5484 #if wxUSE_UNICODE
5485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5486 #else
5487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5488 #endif
5489 }
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498 wxString result;
5499
5500 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = wxGetHomeDir();
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 {
5508 #if wxUSE_UNICODE
5509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5510 #else
5511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5512 #endif
5513 }
5514 return resultobj;
5515 fail:
5516 return NULL;
5517 }
5518
5519
5520 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5521 PyObject *resultobj = 0;
5522 wxString const &arg1_defvalue = wxPyEmptyString ;
5523 wxString *arg1 = (wxString *) &arg1_defvalue ;
5524 wxString result;
5525 bool temp1 = false ;
5526 PyObject * obj0 = 0 ;
5527 char * kwnames[] = {
5528 (char *) "user", NULL
5529 };
5530
5531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5532 if (obj0) {
5533 {
5534 arg1 = wxString_in_helper(obj0);
5535 if (arg1 == NULL) SWIG_fail;
5536 temp1 = true;
5537 }
5538 }
5539 {
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = wxGetUserHome((wxString const &)*arg1);
5542 wxPyEndAllowThreads(__tstate);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 {
5546 #if wxUSE_UNICODE
5547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5548 #else
5549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5550 #endif
5551 }
5552 {
5553 if (temp1)
5554 delete arg1;
5555 }
5556 return resultobj;
5557 fail:
5558 {
5559 if (temp1)
5560 delete arg1;
5561 }
5562 return NULL;
5563 }
5564
5565
5566 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5567 PyObject *resultobj = 0;
5568 unsigned long result;
5569
5570 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5571 {
5572 PyThreadState* __tstate = wxPyBeginAllowThreads();
5573 result = (unsigned long)wxGetProcessId();
5574 wxPyEndAllowThreads(__tstate);
5575 if (PyErr_Occurred()) SWIG_fail;
5576 }
5577 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 PyObject *resultobj = 0;
5586
5587 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5588 {
5589 PyThreadState* __tstate = wxPyBeginAllowThreads();
5590 wxTrap();
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 resultobj = SWIG_Py_Void();
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj = 0;
5603 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5604 wxString *arg1 = (wxString *) &arg1_defvalue ;
5605 wxString const &arg2_defvalue = wxPyEmptyString ;
5606 wxString *arg2 = (wxString *) &arg2_defvalue ;
5607 wxString const &arg3_defvalue = wxPyEmptyString ;
5608 wxString *arg3 = (wxString *) &arg3_defvalue ;
5609 wxString const &arg4_defvalue = wxPyEmptyString ;
5610 wxString *arg4 = (wxString *) &arg4_defvalue ;
5611 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5612 wxString *arg5 = (wxString *) &arg5_defvalue ;
5613 int arg6 = (int) 0 ;
5614 wxWindow *arg7 = (wxWindow *) NULL ;
5615 int arg8 = (int) -1 ;
5616 int arg9 = (int) -1 ;
5617 wxString result;
5618 bool temp1 = false ;
5619 bool temp2 = false ;
5620 bool temp3 = false ;
5621 bool temp4 = false ;
5622 bool temp5 = false ;
5623 int val6 ;
5624 int ecode6 = 0 ;
5625 void *argp7 = 0 ;
5626 int res7 = 0 ;
5627 int val8 ;
5628 int ecode8 = 0 ;
5629 int val9 ;
5630 int ecode9 = 0 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 PyObject * obj2 = 0 ;
5634 PyObject * obj3 = 0 ;
5635 PyObject * obj4 = 0 ;
5636 PyObject * obj5 = 0 ;
5637 PyObject * obj6 = 0 ;
5638 PyObject * obj7 = 0 ;
5639 PyObject * obj8 = 0 ;
5640 char * kwnames[] = {
5641 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5642 };
5643
5644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5645 if (obj0) {
5646 {
5647 arg1 = wxString_in_helper(obj0);
5648 if (arg1 == NULL) SWIG_fail;
5649 temp1 = true;
5650 }
5651 }
5652 if (obj1) {
5653 {
5654 arg2 = wxString_in_helper(obj1);
5655 if (arg2 == NULL) SWIG_fail;
5656 temp2 = true;
5657 }
5658 }
5659 if (obj2) {
5660 {
5661 arg3 = wxString_in_helper(obj2);
5662 if (arg3 == NULL) SWIG_fail;
5663 temp3 = true;
5664 }
5665 }
5666 if (obj3) {
5667 {
5668 arg4 = wxString_in_helper(obj3);
5669 if (arg4 == NULL) SWIG_fail;
5670 temp4 = true;
5671 }
5672 }
5673 if (obj4) {
5674 {
5675 arg5 = wxString_in_helper(obj4);
5676 if (arg5 == NULL) SWIG_fail;
5677 temp5 = true;
5678 }
5679 }
5680 if (obj5) {
5681 ecode6 = SWIG_AsVal_int(obj5, &val6);
5682 if (!SWIG_IsOK(ecode6)) {
5683 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5684 }
5685 arg6 = static_cast< int >(val6);
5686 }
5687 if (obj6) {
5688 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5689 if (!SWIG_IsOK(res7)) {
5690 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5691 }
5692 arg7 = reinterpret_cast< wxWindow * >(argp7);
5693 }
5694 if (obj7) {
5695 ecode8 = SWIG_AsVal_int(obj7, &val8);
5696 if (!SWIG_IsOK(ecode8)) {
5697 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5698 }
5699 arg8 = static_cast< int >(val8);
5700 }
5701 if (obj8) {
5702 ecode9 = SWIG_AsVal_int(obj8, &val9);
5703 if (!SWIG_IsOK(ecode9)) {
5704 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5705 }
5706 arg9 = static_cast< int >(val9);
5707 }
5708 {
5709 if (!wxPyCheckForApp()) SWIG_fail;
5710 PyThreadState* __tstate = wxPyBeginAllowThreads();
5711 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 {
5716 #if wxUSE_UNICODE
5717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5718 #else
5719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5720 #endif
5721 }
5722 {
5723 if (temp1)
5724 delete arg1;
5725 }
5726 {
5727 if (temp2)
5728 delete arg2;
5729 }
5730 {
5731 if (temp3)
5732 delete arg3;
5733 }
5734 {
5735 if (temp4)
5736 delete arg4;
5737 }
5738 {
5739 if (temp5)
5740 delete arg5;
5741 }
5742 return resultobj;
5743 fail:
5744 {
5745 if (temp1)
5746 delete arg1;
5747 }
5748 {
5749 if (temp2)
5750 delete arg2;
5751 }
5752 {
5753 if (temp3)
5754 delete arg3;
5755 }
5756 {
5757 if (temp4)
5758 delete arg4;
5759 }
5760 {
5761 if (temp5)
5762 delete arg5;
5763 }
5764 return NULL;
5765 }
5766
5767
5768 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj = 0;
5770 wxString *arg1 = 0 ;
5771 wxString *arg2 = 0 ;
5772 wxString const &arg3_defvalue = wxPyEmptyString ;
5773 wxString *arg3 = (wxString *) &arg3_defvalue ;
5774 wxWindow *arg4 = (wxWindow *) NULL ;
5775 wxString result;
5776 bool temp1 = false ;
5777 bool temp2 = false ;
5778 bool temp3 = false ;
5779 void *argp4 = 0 ;
5780 int res4 = 0 ;
5781 PyObject * obj0 = 0 ;
5782 PyObject * obj1 = 0 ;
5783 PyObject * obj2 = 0 ;
5784 PyObject * obj3 = 0 ;
5785 char * kwnames[] = {
5786 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5787 };
5788
5789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5790 {
5791 arg1 = wxString_in_helper(obj0);
5792 if (arg1 == NULL) SWIG_fail;
5793 temp1 = true;
5794 }
5795 {
5796 arg2 = wxString_in_helper(obj1);
5797 if (arg2 == NULL) SWIG_fail;
5798 temp2 = true;
5799 }
5800 if (obj2) {
5801 {
5802 arg3 = wxString_in_helper(obj2);
5803 if (arg3 == NULL) SWIG_fail;
5804 temp3 = true;
5805 }
5806 }
5807 if (obj3) {
5808 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5809 if (!SWIG_IsOK(res4)) {
5810 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5811 }
5812 arg4 = reinterpret_cast< wxWindow * >(argp4);
5813 }
5814 {
5815 if (!wxPyCheckForApp()) SWIG_fail;
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 {
5822 #if wxUSE_UNICODE
5823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5824 #else
5825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5826 #endif
5827 }
5828 {
5829 if (temp1)
5830 delete arg1;
5831 }
5832 {
5833 if (temp2)
5834 delete arg2;
5835 }
5836 {
5837 if (temp3)
5838 delete arg3;
5839 }
5840 return resultobj;
5841 fail:
5842 {
5843 if (temp1)
5844 delete arg1;
5845 }
5846 {
5847 if (temp2)
5848 delete arg2;
5849 }
5850 {
5851 if (temp3)
5852 delete arg3;
5853 }
5854 return NULL;
5855 }
5856
5857
5858 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj = 0;
5860 wxString *arg1 = 0 ;
5861 wxString *arg2 = 0 ;
5862 wxString const &arg3_defvalue = wxPyEmptyString ;
5863 wxString *arg3 = (wxString *) &arg3_defvalue ;
5864 wxWindow *arg4 = (wxWindow *) NULL ;
5865 wxString result;
5866 bool temp1 = false ;
5867 bool temp2 = false ;
5868 bool temp3 = false ;
5869 void *argp4 = 0 ;
5870 int res4 = 0 ;
5871 PyObject * obj0 = 0 ;
5872 PyObject * obj1 = 0 ;
5873 PyObject * obj2 = 0 ;
5874 PyObject * obj3 = 0 ;
5875 char * kwnames[] = {
5876 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5877 };
5878
5879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5880 {
5881 arg1 = wxString_in_helper(obj0);
5882 if (arg1 == NULL) SWIG_fail;
5883 temp1 = true;
5884 }
5885 {
5886 arg2 = wxString_in_helper(obj1);
5887 if (arg2 == NULL) SWIG_fail;
5888 temp2 = true;
5889 }
5890 if (obj2) {
5891 {
5892 arg3 = wxString_in_helper(obj2);
5893 if (arg3 == NULL) SWIG_fail;
5894 temp3 = true;
5895 }
5896 }
5897 if (obj3) {
5898 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5899 if (!SWIG_IsOK(res4)) {
5900 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5901 }
5902 arg4 = reinterpret_cast< wxWindow * >(argp4);
5903 }
5904 {
5905 if (!wxPyCheckForApp()) SWIG_fail;
5906 PyThreadState* __tstate = wxPyBeginAllowThreads();
5907 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5908 wxPyEndAllowThreads(__tstate);
5909 if (PyErr_Occurred()) SWIG_fail;
5910 }
5911 {
5912 #if wxUSE_UNICODE
5913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5914 #else
5915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5916 #endif
5917 }
5918 {
5919 if (temp1)
5920 delete arg1;
5921 }
5922 {
5923 if (temp2)
5924 delete arg2;
5925 }
5926 {
5927 if (temp3)
5928 delete arg3;
5929 }
5930 return resultobj;
5931 fail:
5932 {
5933 if (temp1)
5934 delete arg1;
5935 }
5936 {
5937 if (temp2)
5938 delete arg2;
5939 }
5940 {
5941 if (temp3)
5942 delete arg3;
5943 }
5944 return NULL;
5945 }
5946
5947
5948 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5949 PyObject *resultobj = 0;
5950 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5951 wxString *arg1 = (wxString *) &arg1_defvalue ;
5952 wxString const &arg2_defvalue = wxPyEmptyString ;
5953 wxString *arg2 = (wxString *) &arg2_defvalue ;
5954 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5955 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5956 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5957 wxWindow *arg5 = (wxWindow *) NULL ;
5958 wxString result;
5959 bool temp1 = false ;
5960 bool temp2 = false ;
5961 long val3 ;
5962 int ecode3 = 0 ;
5963 wxPoint temp4 ;
5964 void *argp5 = 0 ;
5965 int res5 = 0 ;
5966 PyObject * obj0 = 0 ;
5967 PyObject * obj1 = 0 ;
5968 PyObject * obj2 = 0 ;
5969 PyObject * obj3 = 0 ;
5970 PyObject * obj4 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5976 if (obj0) {
5977 {
5978 arg1 = wxString_in_helper(obj0);
5979 if (arg1 == NULL) SWIG_fail;
5980 temp1 = true;
5981 }
5982 }
5983 if (obj1) {
5984 {
5985 arg2 = wxString_in_helper(obj1);
5986 if (arg2 == NULL) SWIG_fail;
5987 temp2 = true;
5988 }
5989 }
5990 if (obj2) {
5991 ecode3 = SWIG_AsVal_long(obj2, &val3);
5992 if (!SWIG_IsOK(ecode3)) {
5993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5994 }
5995 arg3 = static_cast< long >(val3);
5996 }
5997 if (obj3) {
5998 {
5999 arg4 = &temp4;
6000 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6001 }
6002 }
6003 if (obj4) {
6004 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6005 if (!SWIG_IsOK(res5)) {
6006 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6007 }
6008 arg5 = reinterpret_cast< wxWindow * >(argp5);
6009 }
6010 {
6011 if (!wxPyCheckForApp()) SWIG_fail;
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6014 wxPyEndAllowThreads(__tstate);
6015 if (PyErr_Occurred()) SWIG_fail;
6016 }
6017 {
6018 #if wxUSE_UNICODE
6019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6020 #else
6021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6022 #endif
6023 }
6024 {
6025 if (temp1)
6026 delete arg1;
6027 }
6028 {
6029 if (temp2)
6030 delete arg2;
6031 }
6032 return resultobj;
6033 fail:
6034 {
6035 if (temp1)
6036 delete arg1;
6037 }
6038 {
6039 if (temp2)
6040 delete arg2;
6041 }
6042 return NULL;
6043 }
6044
6045
6046 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj = 0;
6048 wxString *arg1 = 0 ;
6049 wxString const &arg2_defvalue = wxPyEmptyString ;
6050 wxString *arg2 = (wxString *) &arg2_defvalue ;
6051 wxString const &arg3_defvalue = wxPyEmptyString ;
6052 wxString *arg3 = (wxString *) &arg3_defvalue ;
6053 wxWindow *arg4 = (wxWindow *) NULL ;
6054 int arg5 = (int) -1 ;
6055 int arg6 = (int) -1 ;
6056 bool arg7 = (bool) true ;
6057 wxString result;
6058 bool temp1 = false ;
6059 bool temp2 = false ;
6060 bool temp3 = false ;
6061 void *argp4 = 0 ;
6062 int res4 = 0 ;
6063 int val5 ;
6064 int ecode5 = 0 ;
6065 int val6 ;
6066 int ecode6 = 0 ;
6067 bool val7 ;
6068 int ecode7 = 0 ;
6069 PyObject * obj0 = 0 ;
6070 PyObject * obj1 = 0 ;
6071 PyObject * obj2 = 0 ;
6072 PyObject * obj3 = 0 ;
6073 PyObject * obj4 = 0 ;
6074 PyObject * obj5 = 0 ;
6075 PyObject * obj6 = 0 ;
6076 char * kwnames[] = {
6077 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6078 };
6079
6080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6081 {
6082 arg1 = wxString_in_helper(obj0);
6083 if (arg1 == NULL) SWIG_fail;
6084 temp1 = true;
6085 }
6086 if (obj1) {
6087 {
6088 arg2 = wxString_in_helper(obj1);
6089 if (arg2 == NULL) SWIG_fail;
6090 temp2 = true;
6091 }
6092 }
6093 if (obj2) {
6094 {
6095 arg3 = wxString_in_helper(obj2);
6096 if (arg3 == NULL) SWIG_fail;
6097 temp3 = true;
6098 }
6099 }
6100 if (obj3) {
6101 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6102 if (!SWIG_IsOK(res4)) {
6103 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6104 }
6105 arg4 = reinterpret_cast< wxWindow * >(argp4);
6106 }
6107 if (obj4) {
6108 ecode5 = SWIG_AsVal_int(obj4, &val5);
6109 if (!SWIG_IsOK(ecode5)) {
6110 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6111 }
6112 arg5 = static_cast< int >(val5);
6113 }
6114 if (obj5) {
6115 ecode6 = SWIG_AsVal_int(obj5, &val6);
6116 if (!SWIG_IsOK(ecode6)) {
6117 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6118 }
6119 arg6 = static_cast< int >(val6);
6120 }
6121 if (obj6) {
6122 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6123 if (!SWIG_IsOK(ecode7)) {
6124 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6125 }
6126 arg7 = static_cast< bool >(val7);
6127 }
6128 {
6129 if (!wxPyCheckForApp()) SWIG_fail;
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6132 wxPyEndAllowThreads(__tstate);
6133 if (PyErr_Occurred()) SWIG_fail;
6134 }
6135 {
6136 #if wxUSE_UNICODE
6137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6138 #else
6139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6140 #endif
6141 }
6142 {
6143 if (temp1)
6144 delete arg1;
6145 }
6146 {
6147 if (temp2)
6148 delete arg2;
6149 }
6150 {
6151 if (temp3)
6152 delete arg3;
6153 }
6154 return resultobj;
6155 fail:
6156 {
6157 if (temp1)
6158 delete arg1;
6159 }
6160 {
6161 if (temp2)
6162 delete arg2;
6163 }
6164 {
6165 if (temp3)
6166 delete arg3;
6167 }
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj = 0;
6174 wxString *arg1 = 0 ;
6175 wxString const &arg2_defvalue = wxPyEmptyString ;
6176 wxString *arg2 = (wxString *) &arg2_defvalue ;
6177 wxString const &arg3_defvalue = wxPyEmptyString ;
6178 wxString *arg3 = (wxString *) &arg3_defvalue ;
6179 wxWindow *arg4 = (wxWindow *) NULL ;
6180 wxString result;
6181 bool temp1 = false ;
6182 bool temp2 = false ;
6183 bool temp3 = false ;
6184 void *argp4 = 0 ;
6185 int res4 = 0 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 PyObject * obj2 = 0 ;
6189 PyObject * obj3 = 0 ;
6190 char * kwnames[] = {
6191 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6192 };
6193
6194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6195 {
6196 arg1 = wxString_in_helper(obj0);
6197 if (arg1 == NULL) SWIG_fail;
6198 temp1 = true;
6199 }
6200 if (obj1) {
6201 {
6202 arg2 = wxString_in_helper(obj1);
6203 if (arg2 == NULL) SWIG_fail;
6204 temp2 = true;
6205 }
6206 }
6207 if (obj2) {
6208 {
6209 arg3 = wxString_in_helper(obj2);
6210 if (arg3 == NULL) SWIG_fail;
6211 temp3 = true;
6212 }
6213 }
6214 if (obj3) {
6215 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6216 if (!SWIG_IsOK(res4)) {
6217 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6218 }
6219 arg4 = reinterpret_cast< wxWindow * >(argp4);
6220 }
6221 {
6222 if (!wxPyCheckForApp()) SWIG_fail;
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 {
6229 #if wxUSE_UNICODE
6230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6231 #else
6232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6233 #endif
6234 }
6235 {
6236 if (temp1)
6237 delete arg1;
6238 }
6239 {
6240 if (temp2)
6241 delete arg2;
6242 }
6243 {
6244 if (temp3)
6245 delete arg3;
6246 }
6247 return resultobj;
6248 fail:
6249 {
6250 if (temp1)
6251 delete arg1;
6252 }
6253 {
6254 if (temp2)
6255 delete arg2;
6256 }
6257 {
6258 if (temp3)
6259 delete arg3;
6260 }
6261 return NULL;
6262 }
6263
6264
6265 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj = 0;
6267 wxString *arg1 = 0 ;
6268 wxString *arg2 = 0 ;
6269 int arg3 ;
6270 wxString *arg4 = (wxString *) 0 ;
6271 wxWindow *arg5 = (wxWindow *) NULL ;
6272 int arg6 = (int) -1 ;
6273 int arg7 = (int) -1 ;
6274 bool arg8 = (bool) true ;
6275 int arg9 = (int) 150 ;
6276 int arg10 = (int) 200 ;
6277 wxString result;
6278 bool temp1 = false ;
6279 bool temp2 = false ;
6280 void *argp5 = 0 ;
6281 int res5 = 0 ;
6282 int val6 ;
6283 int ecode6 = 0 ;
6284 int val7 ;
6285 int ecode7 = 0 ;
6286 bool val8 ;
6287 int ecode8 = 0 ;
6288 int val9 ;
6289 int ecode9 = 0 ;
6290 int val10 ;
6291 int ecode10 = 0 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 PyObject * obj2 = 0 ;
6295 PyObject * obj3 = 0 ;
6296 PyObject * obj4 = 0 ;
6297 PyObject * obj5 = 0 ;
6298 PyObject * obj6 = 0 ;
6299 PyObject * obj7 = 0 ;
6300 PyObject * obj8 = 0 ;
6301 char * kwnames[] = {
6302 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6303 };
6304
6305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6306 {
6307 arg1 = wxString_in_helper(obj0);
6308 if (arg1 == NULL) SWIG_fail;
6309 temp1 = true;
6310 }
6311 {
6312 arg2 = wxString_in_helper(obj1);
6313 if (arg2 == NULL) SWIG_fail;
6314 temp2 = true;
6315 }
6316 {
6317 arg3 = PyList_Size(obj2);
6318 arg4 = wxString_LIST_helper(obj2);
6319 if (arg4 == NULL) SWIG_fail;
6320 }
6321 if (obj3) {
6322 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6323 if (!SWIG_IsOK(res5)) {
6324 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6325 }
6326 arg5 = reinterpret_cast< wxWindow * >(argp5);
6327 }
6328 if (obj4) {
6329 ecode6 = SWIG_AsVal_int(obj4, &val6);
6330 if (!SWIG_IsOK(ecode6)) {
6331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6332 }
6333 arg6 = static_cast< int >(val6);
6334 }
6335 if (obj5) {
6336 ecode7 = SWIG_AsVal_int(obj5, &val7);
6337 if (!SWIG_IsOK(ecode7)) {
6338 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6339 }
6340 arg7 = static_cast< int >(val7);
6341 }
6342 if (obj6) {
6343 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6344 if (!SWIG_IsOK(ecode8)) {
6345 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6346 }
6347 arg8 = static_cast< bool >(val8);
6348 }
6349 if (obj7) {
6350 ecode9 = SWIG_AsVal_int(obj7, &val9);
6351 if (!SWIG_IsOK(ecode9)) {
6352 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6353 }
6354 arg9 = static_cast< int >(val9);
6355 }
6356 if (obj8) {
6357 ecode10 = SWIG_AsVal_int(obj8, &val10);
6358 if (!SWIG_IsOK(ecode10)) {
6359 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6360 }
6361 arg10 = static_cast< int >(val10);
6362 }
6363 {
6364 if (!wxPyCheckForApp()) SWIG_fail;
6365 PyThreadState* __tstate = wxPyBeginAllowThreads();
6366 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6367 wxPyEndAllowThreads(__tstate);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 {
6371 #if wxUSE_UNICODE
6372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6373 #else
6374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6375 #endif
6376 }
6377 {
6378 if (temp1)
6379 delete arg1;
6380 }
6381 {
6382 if (temp2)
6383 delete arg2;
6384 }
6385 {
6386 if (arg4) delete [] arg4;
6387 }
6388 return resultobj;
6389 fail:
6390 {
6391 if (temp1)
6392 delete arg1;
6393 }
6394 {
6395 if (temp2)
6396 delete arg2;
6397 }
6398 {
6399 if (arg4) delete [] arg4;
6400 }
6401 return NULL;
6402 }
6403
6404
6405 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6406 PyObject *resultobj = 0;
6407 wxString *arg1 = 0 ;
6408 wxString *arg2 = 0 ;
6409 int arg3 ;
6410 wxString *arg4 = (wxString *) 0 ;
6411 wxWindow *arg5 = (wxWindow *) NULL ;
6412 int arg6 = (int) -1 ;
6413 int arg7 = (int) -1 ;
6414 bool arg8 = (bool) true ;
6415 int arg9 = (int) 150 ;
6416 int arg10 = (int) 200 ;
6417 int result;
6418 bool temp1 = false ;
6419 bool temp2 = false ;
6420 void *argp5 = 0 ;
6421 int res5 = 0 ;
6422 int val6 ;
6423 int ecode6 = 0 ;
6424 int val7 ;
6425 int ecode7 = 0 ;
6426 bool val8 ;
6427 int ecode8 = 0 ;
6428 int val9 ;
6429 int ecode9 = 0 ;
6430 int val10 ;
6431 int ecode10 = 0 ;
6432 PyObject * obj0 = 0 ;
6433 PyObject * obj1 = 0 ;
6434 PyObject * obj2 = 0 ;
6435 PyObject * obj3 = 0 ;
6436 PyObject * obj4 = 0 ;
6437 PyObject * obj5 = 0 ;
6438 PyObject * obj6 = 0 ;
6439 PyObject * obj7 = 0 ;
6440 PyObject * obj8 = 0 ;
6441 char * kwnames[] = {
6442 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6443 };
6444
6445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6446 {
6447 arg1 = wxString_in_helper(obj0);
6448 if (arg1 == NULL) SWIG_fail;
6449 temp1 = true;
6450 }
6451 {
6452 arg2 = wxString_in_helper(obj1);
6453 if (arg2 == NULL) SWIG_fail;
6454 temp2 = true;
6455 }
6456 {
6457 arg3 = PyList_Size(obj2);
6458 arg4 = wxString_LIST_helper(obj2);
6459 if (arg4 == NULL) SWIG_fail;
6460 }
6461 if (obj3) {
6462 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6463 if (!SWIG_IsOK(res5)) {
6464 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6465 }
6466 arg5 = reinterpret_cast< wxWindow * >(argp5);
6467 }
6468 if (obj4) {
6469 ecode6 = SWIG_AsVal_int(obj4, &val6);
6470 if (!SWIG_IsOK(ecode6)) {
6471 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6472 }
6473 arg6 = static_cast< int >(val6);
6474 }
6475 if (obj5) {
6476 ecode7 = SWIG_AsVal_int(obj5, &val7);
6477 if (!SWIG_IsOK(ecode7)) {
6478 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6479 }
6480 arg7 = static_cast< int >(val7);
6481 }
6482 if (obj6) {
6483 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6484 if (!SWIG_IsOK(ecode8)) {
6485 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6486 }
6487 arg8 = static_cast< bool >(val8);
6488 }
6489 if (obj7) {
6490 ecode9 = SWIG_AsVal_int(obj7, &val9);
6491 if (!SWIG_IsOK(ecode9)) {
6492 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6493 }
6494 arg9 = static_cast< int >(val9);
6495 }
6496 if (obj8) {
6497 ecode10 = SWIG_AsVal_int(obj8, &val10);
6498 if (!SWIG_IsOK(ecode10)) {
6499 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6500 }
6501 arg10 = static_cast< int >(val10);
6502 }
6503 {
6504 if (!wxPyCheckForApp()) SWIG_fail;
6505 PyThreadState* __tstate = wxPyBeginAllowThreads();
6506 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6507 wxPyEndAllowThreads(__tstate);
6508 if (PyErr_Occurred()) SWIG_fail;
6509 }
6510 resultobj = SWIG_From_int(static_cast< int >(result));
6511 {
6512 if (temp1)
6513 delete arg1;
6514 }
6515 {
6516 if (temp2)
6517 delete arg2;
6518 }
6519 {
6520 if (arg4) delete [] arg4;
6521 }
6522 return resultobj;
6523 fail:
6524 {
6525 if (temp1)
6526 delete arg1;
6527 }
6528 {
6529 if (temp2)
6530 delete arg2;
6531 }
6532 {
6533 if (arg4) delete [] arg4;
6534 }
6535 return NULL;
6536 }
6537
6538
6539 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj = 0;
6541 wxString *arg1 = 0 ;
6542 wxString const &arg2_defvalue = wxPyEmptyString ;
6543 wxString *arg2 = (wxString *) &arg2_defvalue ;
6544 int arg3 = (int) wxOK|wxCENTRE ;
6545 wxWindow *arg4 = (wxWindow *) NULL ;
6546 int arg5 = (int) -1 ;
6547 int arg6 = (int) -1 ;
6548 int result;
6549 bool temp1 = false ;
6550 bool temp2 = false ;
6551 int val3 ;
6552 int ecode3 = 0 ;
6553 void *argp4 = 0 ;
6554 int res4 = 0 ;
6555 int val5 ;
6556 int ecode5 = 0 ;
6557 int val6 ;
6558 int ecode6 = 0 ;
6559 PyObject * obj0 = 0 ;
6560 PyObject * obj1 = 0 ;
6561 PyObject * obj2 = 0 ;
6562 PyObject * obj3 = 0 ;
6563 PyObject * obj4 = 0 ;
6564 PyObject * obj5 = 0 ;
6565 char * kwnames[] = {
6566 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6567 };
6568
6569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6570 {
6571 arg1 = wxString_in_helper(obj0);
6572 if (arg1 == NULL) SWIG_fail;
6573 temp1 = true;
6574 }
6575 if (obj1) {
6576 {
6577 arg2 = wxString_in_helper(obj1);
6578 if (arg2 == NULL) SWIG_fail;
6579 temp2 = true;
6580 }
6581 }
6582 if (obj2) {
6583 ecode3 = SWIG_AsVal_int(obj2, &val3);
6584 if (!SWIG_IsOK(ecode3)) {
6585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6586 }
6587 arg3 = static_cast< int >(val3);
6588 }
6589 if (obj3) {
6590 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6591 if (!SWIG_IsOK(res4)) {
6592 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6593 }
6594 arg4 = reinterpret_cast< wxWindow * >(argp4);
6595 }
6596 if (obj4) {
6597 ecode5 = SWIG_AsVal_int(obj4, &val5);
6598 if (!SWIG_IsOK(ecode5)) {
6599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6600 }
6601 arg5 = static_cast< int >(val5);
6602 }
6603 if (obj5) {
6604 ecode6 = SWIG_AsVal_int(obj5, &val6);
6605 if (!SWIG_IsOK(ecode6)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6607 }
6608 arg6 = static_cast< int >(val6);
6609 }
6610 {
6611 if (!wxPyCheckForApp()) SWIG_fail;
6612 PyThreadState* __tstate = wxPyBeginAllowThreads();
6613 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6614 wxPyEndAllowThreads(__tstate);
6615 if (PyErr_Occurred()) SWIG_fail;
6616 }
6617 resultobj = SWIG_From_int(static_cast< int >(result));
6618 {
6619 if (temp1)
6620 delete arg1;
6621 }
6622 {
6623 if (temp2)
6624 delete arg2;
6625 }
6626 return resultobj;
6627 fail:
6628 {
6629 if (temp1)
6630 delete arg1;
6631 }
6632 {
6633 if (temp2)
6634 delete arg2;
6635 }
6636 return NULL;
6637 }
6638
6639
6640 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj = 0;
6642 wxString *arg1 = 0 ;
6643 wxString *arg2 = 0 ;
6644 wxString *arg3 = 0 ;
6645 long arg4 ;
6646 long arg5 = (long) 0 ;
6647 long arg6 = (long) 100 ;
6648 wxWindow *arg7 = (wxWindow *) NULL ;
6649 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6650 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6651 long result;
6652 bool temp1 = false ;
6653 bool temp2 = false ;
6654 bool temp3 = false ;
6655 long val4 ;
6656 int ecode4 = 0 ;
6657 long val5 ;
6658 int ecode5 = 0 ;
6659 long val6 ;
6660 int ecode6 = 0 ;
6661 void *argp7 = 0 ;
6662 int res7 = 0 ;
6663 wxPoint temp8 ;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 PyObject * obj2 = 0 ;
6667 PyObject * obj3 = 0 ;
6668 PyObject * obj4 = 0 ;
6669 PyObject * obj5 = 0 ;
6670 PyObject * obj6 = 0 ;
6671 PyObject * obj7 = 0 ;
6672 char * kwnames[] = {
6673 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6674 };
6675
6676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6677 {
6678 arg1 = wxString_in_helper(obj0);
6679 if (arg1 == NULL) SWIG_fail;
6680 temp1 = true;
6681 }
6682 {
6683 arg2 = wxString_in_helper(obj1);
6684 if (arg2 == NULL) SWIG_fail;
6685 temp2 = true;
6686 }
6687 {
6688 arg3 = wxString_in_helper(obj2);
6689 if (arg3 == NULL) SWIG_fail;
6690 temp3 = true;
6691 }
6692 ecode4 = SWIG_AsVal_long(obj3, &val4);
6693 if (!SWIG_IsOK(ecode4)) {
6694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6695 }
6696 arg4 = static_cast< long >(val4);
6697 if (obj4) {
6698 ecode5 = SWIG_AsVal_long(obj4, &val5);
6699 if (!SWIG_IsOK(ecode5)) {
6700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6701 }
6702 arg5 = static_cast< long >(val5);
6703 }
6704 if (obj5) {
6705 ecode6 = SWIG_AsVal_long(obj5, &val6);
6706 if (!SWIG_IsOK(ecode6)) {
6707 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6708 }
6709 arg6 = static_cast< long >(val6);
6710 }
6711 if (obj6) {
6712 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6713 if (!SWIG_IsOK(res7)) {
6714 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6715 }
6716 arg7 = reinterpret_cast< wxWindow * >(argp7);
6717 }
6718 if (obj7) {
6719 {
6720 arg8 = &temp8;
6721 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6722 }
6723 }
6724 {
6725 if (!wxPyCheckForApp()) SWIG_fail;
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 resultobj = SWIG_From_long(static_cast< long >(result));
6732 {
6733 if (temp1)
6734 delete arg1;
6735 }
6736 {
6737 if (temp2)
6738 delete arg2;
6739 }
6740 {
6741 if (temp3)
6742 delete arg3;
6743 }
6744 return resultobj;
6745 fail:
6746 {
6747 if (temp1)
6748 delete arg1;
6749 }
6750 {
6751 if (temp2)
6752 delete arg2;
6753 }
6754 {
6755 if (temp3)
6756 delete arg3;
6757 }
6758 return NULL;
6759 }
6760
6761
6762 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6763 PyObject *resultobj = 0;
6764 bool result;
6765
6766 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6767 {
6768 if (!wxPyCheckForApp()) SWIG_fail;
6769 PyThreadState* __tstate = wxPyBeginAllowThreads();
6770 result = (bool)wxColourDisplay();
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6784 PyObject *resultobj = 0;
6785 int result;
6786
6787 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6788 {
6789 if (!wxPyCheckForApp()) SWIG_fail;
6790 PyThreadState* __tstate = wxPyBeginAllowThreads();
6791 result = (int)wxDisplayDepth();
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 resultobj = SWIG_From_int(static_cast< int >(result));
6796 return resultobj;
6797 fail:
6798 return NULL;
6799 }
6800
6801
6802 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6803 PyObject *resultobj = 0;
6804 int result;
6805
6806 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6807 {
6808 if (!wxPyCheckForApp()) SWIG_fail;
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = (int)wxGetDisplayDepth();
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 resultobj = SWIG_From_int(static_cast< int >(result));
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6822 PyObject *resultobj = 0;
6823 int *arg1 = (int *) 0 ;
6824 int *arg2 = (int *) 0 ;
6825 int temp1 ;
6826 int res1 = SWIG_TMPOBJ ;
6827 int temp2 ;
6828 int res2 = SWIG_TMPOBJ ;
6829
6830 arg1 = &temp1;
6831 arg2 = &temp2;
6832 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6833 {
6834 if (!wxPyCheckForApp()) SWIG_fail;
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 wxDisplaySize(arg1,arg2);
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_Py_Void();
6841 if (SWIG_IsTmpObj(res1)) {
6842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6843 } else {
6844 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6846 }
6847 if (SWIG_IsTmpObj(res2)) {
6848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6849 } else {
6850 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6852 }
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6860 PyObject *resultobj = 0;
6861 wxSize result;
6862
6863 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6864 {
6865 if (!wxPyCheckForApp()) SWIG_fail;
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 result = wxGetDisplaySize();
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6879 PyObject *resultobj = 0;
6880 int *arg1 = (int *) 0 ;
6881 int *arg2 = (int *) 0 ;
6882 int temp1 ;
6883 int res1 = SWIG_TMPOBJ ;
6884 int temp2 ;
6885 int res2 = SWIG_TMPOBJ ;
6886
6887 arg1 = &temp1;
6888 arg2 = &temp2;
6889 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6890 {
6891 if (!wxPyCheckForApp()) SWIG_fail;
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 wxDisplaySizeMM(arg1,arg2);
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_Py_Void();
6898 if (SWIG_IsTmpObj(res1)) {
6899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6900 } else {
6901 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6903 }
6904 if (SWIG_IsTmpObj(res2)) {
6905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6906 } else {
6907 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6909 }
6910 return resultobj;
6911 fail:
6912 return NULL;
6913 }
6914
6915
6916 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6917 PyObject *resultobj = 0;
6918 wxSize result;
6919
6920 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6921 {
6922 if (!wxPyCheckForApp()) SWIG_fail;
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 result = wxGetDisplaySizeMM();
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6936 PyObject *resultobj = 0;
6937 int *arg1 = (int *) 0 ;
6938 int *arg2 = (int *) 0 ;
6939 int *arg3 = (int *) 0 ;
6940 int *arg4 = (int *) 0 ;
6941 int temp1 ;
6942 int res1 = SWIG_TMPOBJ ;
6943 int temp2 ;
6944 int res2 = SWIG_TMPOBJ ;
6945 int temp3 ;
6946 int res3 = SWIG_TMPOBJ ;
6947 int temp4 ;
6948 int res4 = SWIG_TMPOBJ ;
6949
6950 arg1 = &temp1;
6951 arg2 = &temp2;
6952 arg3 = &temp3;
6953 arg4 = &temp4;
6954 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6955 {
6956 if (!wxPyCheckForApp()) SWIG_fail;
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6959 wxPyEndAllowThreads(__tstate);
6960 if (PyErr_Occurred()) SWIG_fail;
6961 }
6962 resultobj = SWIG_Py_Void();
6963 if (SWIG_IsTmpObj(res1)) {
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6965 } else {
6966 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6968 }
6969 if (SWIG_IsTmpObj(res2)) {
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6971 } else {
6972 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6974 }
6975 if (SWIG_IsTmpObj(res3)) {
6976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6977 } else {
6978 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6980 }
6981 if (SWIG_IsTmpObj(res4)) {
6982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6983 } else {
6984 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6986 }
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6994 PyObject *resultobj = 0;
6995 wxRect result;
6996
6997 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6998 {
6999 if (!wxPyCheckForApp()) SWIG_fail;
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 result = wxGetClientDisplayRect();
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7013 PyObject *resultobj = 0;
7014 wxCursor *arg1 = 0 ;
7015 void *argp1 = 0 ;
7016 int res1 = 0 ;
7017 PyObject * obj0 = 0 ;
7018 char * kwnames[] = {
7019 (char *) "cursor", NULL
7020 };
7021
7022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7023 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7024 if (!SWIG_IsOK(res1)) {
7025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7026 }
7027 if (!argp1) {
7028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7029 }
7030 arg1 = reinterpret_cast< wxCursor * >(argp1);
7031 {
7032 if (!wxPyCheckForApp()) SWIG_fail;
7033 PyThreadState* __tstate = wxPyBeginAllowThreads();
7034 wxSetCursor(*arg1);
7035 wxPyEndAllowThreads(__tstate);
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 resultobj = SWIG_Py_Void();
7039 return resultobj;
7040 fail:
7041 return NULL;
7042 }
7043
7044
7045 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7046 PyObject *resultobj = 0;
7047 void *result = 0 ;
7048
7049 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7050 {
7051 if (!wxPyCheckForApp()) SWIG_fail;
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 result = (void *)wxGetXDisplay();
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7067 void *argp1 = 0 ;
7068 int res1 = 0 ;
7069 PyObject * obj0 = 0 ;
7070 char * kwnames[] = {
7071 (char *) "cursor", NULL
7072 };
7073
7074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7075 if (obj0) {
7076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7077 if (!SWIG_IsOK(res1)) {
7078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7079 }
7080 arg1 = reinterpret_cast< wxCursor * >(argp1);
7081 }
7082 {
7083 if (!wxPyCheckForApp()) SWIG_fail;
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 wxBeginBusyCursor(arg1);
7086 wxPyEndAllowThreads(__tstate);
7087 if (PyErr_Occurred()) SWIG_fail;
7088 }
7089 resultobj = SWIG_Py_Void();
7090 return resultobj;
7091 fail:
7092 return NULL;
7093 }
7094
7095
7096 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7097 PyObject *resultobj = 0;
7098 wxPoint result;
7099
7100 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7101 {
7102 if (!wxPyCheckForApp()) SWIG_fail;
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = wxGetMousePosition();
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7116 PyObject *resultobj = 0;
7117 wxWindow *result = 0 ;
7118
7119 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7120 {
7121 if (!wxPyCheckForApp()) SWIG_fail;
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (wxWindow *)FindWindowAtPointer();
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 {
7128 resultobj = wxPyMake_wxObject(result, 0);
7129 }
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 wxWindow *result = 0 ;
7139
7140 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7141 {
7142 if (!wxPyCheckForApp()) SWIG_fail;
7143 PyThreadState* __tstate = wxPyBeginAllowThreads();
7144 result = (wxWindow *)wxGetActiveWindow();
7145 wxPyEndAllowThreads(__tstate);
7146 if (PyErr_Occurred()) SWIG_fail;
7147 }
7148 {
7149 resultobj = wxPyMake_wxObject(result, 0);
7150 }
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj = 0;
7159 wxPoint *arg1 = 0 ;
7160 wxWindow *result = 0 ;
7161 wxPoint temp1 ;
7162 PyObject * obj0 = 0 ;
7163 char * kwnames[] = {
7164 (char *) "pt", NULL
7165 };
7166
7167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7168 {
7169 arg1 = &temp1;
7170 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7171 }
7172 {
7173 if (!wxPyCheckForApp()) SWIG_fail;
7174 PyThreadState* __tstate = wxPyBeginAllowThreads();
7175 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 {
7180 resultobj = wxPyMake_wxObject(result, 0);
7181 }
7182 return resultobj;
7183 fail:
7184 return NULL;
7185 }
7186
7187
7188 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7189 PyObject *resultobj = 0;
7190 wxPoint *arg1 = 0 ;
7191 wxWindow *result = 0 ;
7192 wxPoint temp1 ;
7193 PyObject * obj0 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "pt", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7199 {
7200 arg1 = &temp1;
7201 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7202 }
7203 {
7204 if (!wxPyCheckForApp()) SWIG_fail;
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 {
7211 resultobj = wxPyMake_wxObject(result, 0);
7212 }
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxWindow *arg1 = (wxWindow *) 0 ;
7222 wxWindow *result = 0 ;
7223 void *argp1 = 0 ;
7224 int res1 = 0 ;
7225 PyObject * obj0 = 0 ;
7226 char * kwnames[] = {
7227 (char *) "win", NULL
7228 };
7229
7230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7232 if (!SWIG_IsOK(res1)) {
7233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7234 }
7235 arg1 = reinterpret_cast< wxWindow * >(argp1);
7236 {
7237 if (!wxPyCheckForApp()) SWIG_fail;
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 result = (wxWindow *)wxGetTopLevelParent(arg1);
7240 wxPyEndAllowThreads(__tstate);
7241 if (PyErr_Occurred()) SWIG_fail;
7242 }
7243 {
7244 resultobj = wxPyMake_wxObject(result, 0);
7245 }
7246 return resultobj;
7247 fail:
7248 return NULL;
7249 }
7250
7251
7252 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7253 PyObject *resultobj = 0;
7254 wxString *arg1 = 0 ;
7255 bool result;
7256 bool temp1 = false ;
7257 PyObject * obj0 = 0 ;
7258 char * kwnames[] = {
7259 (char *) "url", NULL
7260 };
7261
7262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7263 {
7264 arg1 = wxString_in_helper(obj0);
7265 if (arg1 == NULL) SWIG_fail;
7266 temp1 = true;
7267 }
7268 {
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 {
7278 if (temp1)
7279 delete arg1;
7280 }
7281 return resultobj;
7282 fail:
7283 {
7284 if (temp1)
7285 delete arg1;
7286 }
7287 return NULL;
7288 }
7289
7290
7291 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7292 PyObject *resultobj = 0;
7293 wxKeyCode arg1 ;
7294 bool result;
7295 int val1 ;
7296 int ecode1 = 0 ;
7297 PyObject * obj0 = 0 ;
7298 char * kwnames[] = {
7299 (char *) "key", NULL
7300 };
7301
7302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7303 ecode1 = SWIG_AsVal_int(obj0, &val1);
7304 if (!SWIG_IsOK(ecode1)) {
7305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7306 }
7307 arg1 = static_cast< wxKeyCode >(val1);
7308 {
7309 if (!wxPyCheckForApp()) SWIG_fail;
7310 PyThreadState* __tstate = wxPyBeginAllowThreads();
7311 result = (bool)wxGetKeyState(arg1);
7312 wxPyEndAllowThreads(__tstate);
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 {
7316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7317 }
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7325 PyObject *resultobj = 0;
7326 wxMouseState *result = 0 ;
7327
7328 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7329 {
7330 PyThreadState* __tstate = wxPyBeginAllowThreads();
7331 result = (wxMouseState *)new wxMouseState();
7332 wxPyEndAllowThreads(__tstate);
7333 if (PyErr_Occurred()) SWIG_fail;
7334 }
7335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7336 return resultobj;
7337 fail:
7338 return NULL;
7339 }
7340
7341
7342 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7343 PyObject *resultobj = 0;
7344 wxMouseState *arg1 = (wxMouseState *) 0 ;
7345 void *argp1 = 0 ;
7346 int res1 = 0 ;
7347 PyObject *swig_obj[1] ;
7348
7349 if (!args) SWIG_fail;
7350 swig_obj[0] = args;
7351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7352 if (!SWIG_IsOK(res1)) {
7353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7354 }
7355 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 delete arg1;
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 resultobj = SWIG_Py_Void();
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7371 PyObject *resultobj = 0;
7372 wxMouseState *arg1 = (wxMouseState *) 0 ;
7373 int result;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 PyObject *swig_obj[1] ;
7377
7378 if (!args) SWIG_fail;
7379 swig_obj[0] = args;
7380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7381 if (!SWIG_IsOK(res1)) {
7382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7383 }
7384 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (int)(arg1)->GetX();
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 resultobj = SWIG_From_int(static_cast< int >(result));
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7399 PyObject *resultobj = 0;
7400 wxMouseState *arg1 = (wxMouseState *) 0 ;
7401 int result;
7402 void *argp1 = 0 ;
7403 int res1 = 0 ;
7404 PyObject *swig_obj[1] ;
7405
7406 if (!args) SWIG_fail;
7407 swig_obj[0] = args;
7408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7409 if (!SWIG_IsOK(res1)) {
7410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7411 }
7412 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 result = (int)(arg1)->GetY();
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 resultobj = SWIG_From_int(static_cast< int >(result));
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7427 PyObject *resultobj = 0;
7428 wxMouseState *arg1 = (wxMouseState *) 0 ;
7429 bool result;
7430 void *argp1 = 0 ;
7431 int res1 = 0 ;
7432 PyObject *swig_obj[1] ;
7433
7434 if (!args) SWIG_fail;
7435 swig_obj[0] = args;
7436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7437 if (!SWIG_IsOK(res1)) {
7438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7439 }
7440 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7441 {
7442 PyThreadState* __tstate = wxPyBeginAllowThreads();
7443 result = (bool)(arg1)->LeftDown();
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 {
7448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7449 }
7450 return resultobj;
7451 fail:
7452 return NULL;
7453 }
7454
7455
7456 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7457 PyObject *resultobj = 0;
7458 wxMouseState *arg1 = (wxMouseState *) 0 ;
7459 bool result;
7460 void *argp1 = 0 ;
7461 int res1 = 0 ;
7462 PyObject *swig_obj[1] ;
7463
7464 if (!args) SWIG_fail;
7465 swig_obj[0] = args;
7466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7467 if (!SWIG_IsOK(res1)) {
7468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7469 }
7470 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (bool)(arg1)->MiddleDown();
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 {
7478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7479 }
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7487 PyObject *resultobj = 0;
7488 wxMouseState *arg1 = (wxMouseState *) 0 ;
7489 bool result;
7490 void *argp1 = 0 ;
7491 int res1 = 0 ;
7492 PyObject *swig_obj[1] ;
7493
7494 if (!args) SWIG_fail;
7495 swig_obj[0] = args;
7496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7497 if (!SWIG_IsOK(res1)) {
7498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7499 }
7500 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 result = (bool)(arg1)->RightDown();
7504 wxPyEndAllowThreads(__tstate);
7505 if (PyErr_Occurred()) SWIG_fail;
7506 }
7507 {
7508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7509 }
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7517 PyObject *resultobj = 0;
7518 wxMouseState *arg1 = (wxMouseState *) 0 ;
7519 bool result;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 PyObject *swig_obj[1] ;
7523
7524 if (!args) SWIG_fail;
7525 swig_obj[0] = args;
7526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7527 if (!SWIG_IsOK(res1)) {
7528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7529 }
7530 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 result = (bool)(arg1)->ControlDown();
7534 wxPyEndAllowThreads(__tstate);
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 {
7538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7539 }
7540 return resultobj;
7541 fail:
7542 return NULL;
7543 }
7544
7545
7546 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7547 PyObject *resultobj = 0;
7548 wxMouseState *arg1 = (wxMouseState *) 0 ;
7549 bool result;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 PyObject *swig_obj[1] ;
7553
7554 if (!args) SWIG_fail;
7555 swig_obj[0] = args;
7556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7557 if (!SWIG_IsOK(res1)) {
7558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7559 }
7560 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (bool)(arg1)->ShiftDown();
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 {
7568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7569 }
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7577 PyObject *resultobj = 0;
7578 wxMouseState *arg1 = (wxMouseState *) 0 ;
7579 bool result;
7580 void *argp1 = 0 ;
7581 int res1 = 0 ;
7582 PyObject *swig_obj[1] ;
7583
7584 if (!args) SWIG_fail;
7585 swig_obj[0] = args;
7586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7587 if (!SWIG_IsOK(res1)) {
7588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7589 }
7590 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (bool)(arg1)->AltDown();
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7607 PyObject *resultobj = 0;
7608 wxMouseState *arg1 = (wxMouseState *) 0 ;
7609 bool result;
7610 void *argp1 = 0 ;
7611 int res1 = 0 ;
7612 PyObject *swig_obj[1] ;
7613
7614 if (!args) SWIG_fail;
7615 swig_obj[0] = args;
7616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7617 if (!SWIG_IsOK(res1)) {
7618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7619 }
7620 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7621 {
7622 PyThreadState* __tstate = wxPyBeginAllowThreads();
7623 result = (bool)(arg1)->MetaDown();
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 {
7628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7629 }
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *resultobj = 0;
7638 wxMouseState *arg1 = (wxMouseState *) 0 ;
7639 bool result;
7640 void *argp1 = 0 ;
7641 int res1 = 0 ;
7642 PyObject *swig_obj[1] ;
7643
7644 if (!args) SWIG_fail;
7645 swig_obj[0] = args;
7646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7647 if (!SWIG_IsOK(res1)) {
7648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7649 }
7650 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (bool)(arg1)->CmdDown();
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7659 }
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj = 0;
7668 wxMouseState *arg1 = (wxMouseState *) 0 ;
7669 int arg2 ;
7670 void *argp1 = 0 ;
7671 int res1 = 0 ;
7672 int val2 ;
7673 int ecode2 = 0 ;
7674 PyObject * obj0 = 0 ;
7675 PyObject * obj1 = 0 ;
7676 char * kwnames[] = {
7677 (char *) "self",(char *) "x", NULL
7678 };
7679
7680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7684 }
7685 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7686 ecode2 = SWIG_AsVal_int(obj1, &val2);
7687 if (!SWIG_IsOK(ecode2)) {
7688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7689 }
7690 arg2 = static_cast< int >(val2);
7691 {
7692 PyThreadState* __tstate = wxPyBeginAllowThreads();
7693 (arg1)->SetX(arg2);
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 resultobj = SWIG_Py_Void();
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj = 0;
7706 wxMouseState *arg1 = (wxMouseState *) 0 ;
7707 int arg2 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 PyObject * obj0 = 0 ;
7713 PyObject * obj1 = 0 ;
7714 char * kwnames[] = {
7715 (char *) "self",(char *) "y", NULL
7716 };
7717
7718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7722 }
7723 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7724 ecode2 = SWIG_AsVal_int(obj1, &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 (arg1)->SetY(arg2);
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 resultobj = SWIG_Py_Void();
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj = 0;
7744 wxMouseState *arg1 = (wxMouseState *) 0 ;
7745 bool arg2 ;
7746 void *argp1 = 0 ;
7747 int res1 = 0 ;
7748 bool val2 ;
7749 int ecode2 = 0 ;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char * kwnames[] = {
7753 (char *) "self",(char *) "down", NULL
7754 };
7755
7756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7760 }
7761 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7763 if (!SWIG_IsOK(ecode2)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7765 }
7766 arg2 = static_cast< bool >(val2);
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 (arg1)->SetLeftDown(arg2);
7770 wxPyEndAllowThreads(__tstate);
7771 if (PyErr_Occurred()) SWIG_fail;
7772 }
7773 resultobj = SWIG_Py_Void();
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj = 0;
7782 wxMouseState *arg1 = (wxMouseState *) 0 ;
7783 bool arg2 ;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 bool val2 ;
7787 int ecode2 = 0 ;
7788 PyObject * obj0 = 0 ;
7789 PyObject * obj1 = 0 ;
7790 char * kwnames[] = {
7791 (char *) "self",(char *) "down", NULL
7792 };
7793
7794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7798 }
7799 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7800 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7801 if (!SWIG_IsOK(ecode2)) {
7802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7803 }
7804 arg2 = static_cast< bool >(val2);
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 (arg1)->SetMiddleDown(arg2);
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 resultobj = SWIG_Py_Void();
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7819 PyObject *resultobj = 0;
7820 wxMouseState *arg1 = (wxMouseState *) 0 ;
7821 bool arg2 ;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 bool val2 ;
7825 int ecode2 = 0 ;
7826 PyObject * obj0 = 0 ;
7827 PyObject * obj1 = 0 ;
7828 char * kwnames[] = {
7829 (char *) "self",(char *) "down", NULL
7830 };
7831
7832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7834 if (!SWIG_IsOK(res1)) {
7835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7836 }
7837 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7839 if (!SWIG_IsOK(ecode2)) {
7840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7841 }
7842 arg2 = static_cast< bool >(val2);
7843 {
7844 PyThreadState* __tstate = wxPyBeginAllowThreads();
7845 (arg1)->SetRightDown(arg2);
7846 wxPyEndAllowThreads(__tstate);
7847 if (PyErr_Occurred()) SWIG_fail;
7848 }
7849 resultobj = SWIG_Py_Void();
7850 return resultobj;
7851 fail:
7852 return NULL;
7853 }
7854
7855
7856 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj = 0;
7858 wxMouseState *arg1 = (wxMouseState *) 0 ;
7859 bool arg2 ;
7860 void *argp1 = 0 ;
7861 int res1 = 0 ;
7862 bool val2 ;
7863 int ecode2 = 0 ;
7864 PyObject * obj0 = 0 ;
7865 PyObject * obj1 = 0 ;
7866 char * kwnames[] = {
7867 (char *) "self",(char *) "down", NULL
7868 };
7869
7870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7872 if (!SWIG_IsOK(res1)) {
7873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7874 }
7875 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7877 if (!SWIG_IsOK(ecode2)) {
7878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7879 }
7880 arg2 = static_cast< bool >(val2);
7881 {
7882 PyThreadState* __tstate = wxPyBeginAllowThreads();
7883 (arg1)->SetControlDown(arg2);
7884 wxPyEndAllowThreads(__tstate);
7885 if (PyErr_Occurred()) SWIG_fail;
7886 }
7887 resultobj = SWIG_Py_Void();
7888 return resultobj;
7889 fail:
7890 return NULL;
7891 }
7892
7893
7894 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7895 PyObject *resultobj = 0;
7896 wxMouseState *arg1 = (wxMouseState *) 0 ;
7897 bool arg2 ;
7898 void *argp1 = 0 ;
7899 int res1 = 0 ;
7900 bool val2 ;
7901 int ecode2 = 0 ;
7902 PyObject * obj0 = 0 ;
7903 PyObject * obj1 = 0 ;
7904 char * kwnames[] = {
7905 (char *) "self",(char *) "down", NULL
7906 };
7907
7908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7910 if (!SWIG_IsOK(res1)) {
7911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7912 }
7913 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7914 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7915 if (!SWIG_IsOK(ecode2)) {
7916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7917 }
7918 arg2 = static_cast< bool >(val2);
7919 {
7920 PyThreadState* __tstate = wxPyBeginAllowThreads();
7921 (arg1)->SetShiftDown(arg2);
7922 wxPyEndAllowThreads(__tstate);
7923 if (PyErr_Occurred()) SWIG_fail;
7924 }
7925 resultobj = SWIG_Py_Void();
7926 return resultobj;
7927 fail:
7928 return NULL;
7929 }
7930
7931
7932 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7933 PyObject *resultobj = 0;
7934 wxMouseState *arg1 = (wxMouseState *) 0 ;
7935 bool arg2 ;
7936 void *argp1 = 0 ;
7937 int res1 = 0 ;
7938 bool val2 ;
7939 int ecode2 = 0 ;
7940 PyObject * obj0 = 0 ;
7941 PyObject * obj1 = 0 ;
7942 char * kwnames[] = {
7943 (char *) "self",(char *) "down", NULL
7944 };
7945
7946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7948 if (!SWIG_IsOK(res1)) {
7949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7950 }
7951 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7953 if (!SWIG_IsOK(ecode2)) {
7954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7955 }
7956 arg2 = static_cast< bool >(val2);
7957 {
7958 PyThreadState* __tstate = wxPyBeginAllowThreads();
7959 (arg1)->SetAltDown(arg2);
7960 wxPyEndAllowThreads(__tstate);
7961 if (PyErr_Occurred()) SWIG_fail;
7962 }
7963 resultobj = SWIG_Py_Void();
7964 return resultobj;
7965 fail:
7966 return NULL;
7967 }
7968
7969
7970 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7971 PyObject *resultobj = 0;
7972 wxMouseState *arg1 = (wxMouseState *) 0 ;
7973 bool arg2 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976 bool val2 ;
7977 int ecode2 = 0 ;
7978 PyObject * obj0 = 0 ;
7979 PyObject * obj1 = 0 ;
7980 char * kwnames[] = {
7981 (char *) "self",(char *) "down", NULL
7982 };
7983
7984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7986 if (!SWIG_IsOK(res1)) {
7987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7988 }
7989 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7991 if (!SWIG_IsOK(ecode2)) {
7992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7993 }
7994 arg2 = static_cast< bool >(val2);
7995 {
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 (arg1)->SetMetaDown(arg2);
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 resultobj = SWIG_Py_Void();
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8009 PyObject *obj;
8010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8011 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8012 return SWIG_Py_Void();
8013 }
8014
8015 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 return SWIG_Python_InitShadowInstance(args);
8017 }
8018
8019 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8020 PyObject *resultobj = 0;
8021 wxMouseState result;
8022
8023 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = wxGetMouseState();
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8038 PyObject *resultobj = 0;
8039
8040 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8041 {
8042 if (!wxPyCheckForApp()) SWIG_fail;
8043 PyThreadState* __tstate = wxPyBeginAllowThreads();
8044 wxWakeUpMainThread();
8045 wxPyEndAllowThreads(__tstate);
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 resultobj = SWIG_Py_Void();
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8056 PyObject *resultobj = 0;
8057
8058 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 wxMutexGuiEnter();
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = SWIG_Py_Void();
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8074 PyObject *resultobj = 0;
8075
8076 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8077 {
8078 if (!wxPyCheckForApp()) SWIG_fail;
8079 PyThreadState* __tstate = wxPyBeginAllowThreads();
8080 wxMutexGuiLeave();
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 resultobj = SWIG_Py_Void();
8085 return resultobj;
8086 fail:
8087 return NULL;
8088 }
8089
8090
8091 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8092 PyObject *resultobj = 0;
8093 wxMutexGuiLocker *result = 0 ;
8094
8095 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8096 {
8097 if (!wxPyCheckForApp()) SWIG_fail;
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8111 PyObject *resultobj = 0;
8112 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8113 void *argp1 = 0 ;
8114 int res1 = 0 ;
8115 PyObject *swig_obj[1] ;
8116
8117 if (!args) SWIG_fail;
8118 swig_obj[0] = args;
8119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8120 if (!SWIG_IsOK(res1)) {
8121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8122 }
8123 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 delete arg1;
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 resultobj = SWIG_Py_Void();
8132 return resultobj;
8133 fail:
8134 return NULL;
8135 }
8136
8137
8138 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8139 PyObject *obj;
8140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8141 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8142 return SWIG_Py_Void();
8143 }
8144
8145 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 return SWIG_Python_InitShadowInstance(args);
8147 }
8148
8149 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 PyObject *resultobj = 0;
8151 bool result;
8152
8153 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8154 {
8155 PyThreadState* __tstate = wxPyBeginAllowThreads();
8156 result = (bool)wxThread_IsMain();
8157 wxPyEndAllowThreads(__tstate);
8158 if (PyErr_Occurred()) SWIG_fail;
8159 }
8160 {
8161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8162 }
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8170 PyObject *resultobj = 0;
8171 wxString *arg1 = 0 ;
8172 wxToolTip *result = 0 ;
8173 bool temp1 = false ;
8174 PyObject * obj0 = 0 ;
8175 char * kwnames[] = {
8176 (char *) "tip", NULL
8177 };
8178
8179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8180 {
8181 arg1 = wxString_in_helper(obj0);
8182 if (arg1 == NULL) SWIG_fail;
8183 temp1 = true;
8184 }
8185 {
8186 if (!wxPyCheckForApp()) SWIG_fail;
8187 PyThreadState* __tstate = wxPyBeginAllowThreads();
8188 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8189 wxPyEndAllowThreads(__tstate);
8190 if (PyErr_Occurred()) SWIG_fail;
8191 }
8192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8193 {
8194 if (temp1)
8195 delete arg1;
8196 }
8197 return resultobj;
8198 fail:
8199 {
8200 if (temp1)
8201 delete arg1;
8202 }
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8208 PyObject *resultobj = 0;
8209 wxToolTip *arg1 = (wxToolTip *) 0 ;
8210 void *argp1 = 0 ;
8211 int res1 = 0 ;
8212 PyObject *swig_obj[1] ;
8213
8214 if (!args) SWIG_fail;
8215 swig_obj[0] = args;
8216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8219 }
8220 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 delete arg1;
8224
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 resultobj = SWIG_Py_Void();
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8236 PyObject *resultobj = 0;
8237 wxToolTip *arg1 = (wxToolTip *) 0 ;
8238 wxString *arg2 = 0 ;
8239 void *argp1 = 0 ;
8240 int res1 = 0 ;
8241 bool temp2 = false ;
8242 PyObject * obj0 = 0 ;
8243 PyObject * obj1 = 0 ;
8244 char * kwnames[] = {
8245 (char *) "self",(char *) "tip", NULL
8246 };
8247
8248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8252 }
8253 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8254 {
8255 arg2 = wxString_in_helper(obj1);
8256 if (arg2 == NULL) SWIG_fail;
8257 temp2 = true;
8258 }
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 (arg1)->SetTip((wxString const &)*arg2);
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_Py_Void();
8266 {
8267 if (temp2)
8268 delete arg2;
8269 }
8270 return resultobj;
8271 fail:
8272 {
8273 if (temp2)
8274 delete arg2;
8275 }
8276 return NULL;
8277 }
8278
8279
8280 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8281 PyObject *resultobj = 0;
8282 wxToolTip *arg1 = (wxToolTip *) 0 ;
8283 wxString result;
8284 void *argp1 = 0 ;
8285 int res1 = 0 ;
8286 PyObject *swig_obj[1] ;
8287
8288 if (!args) SWIG_fail;
8289 swig_obj[0] = args;
8290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8291 if (!SWIG_IsOK(res1)) {
8292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8293 }
8294 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = (arg1)->GetTip();
8298 wxPyEndAllowThreads(__tstate);
8299 if (PyErr_Occurred()) SWIG_fail;
8300 }
8301 {
8302 #if wxUSE_UNICODE
8303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8304 #else
8305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8306 #endif
8307 }
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8315 PyObject *resultobj = 0;
8316 wxToolTip *arg1 = (wxToolTip *) 0 ;
8317 wxWindow *result = 0 ;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 PyObject *swig_obj[1] ;
8321
8322 if (!args) SWIG_fail;
8323 swig_obj[0] = args;
8324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8327 }
8328 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8329 {
8330 PyThreadState* __tstate = wxPyBeginAllowThreads();
8331 result = (wxWindow *)(arg1)->GetWindow();
8332 wxPyEndAllowThreads(__tstate);
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 {
8336 resultobj = wxPyMake_wxObject(result, 0);
8337 }
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj = 0;
8346 bool arg1 ;
8347 bool val1 ;
8348 int ecode1 = 0 ;
8349 PyObject * obj0 = 0 ;
8350 char * kwnames[] = {
8351 (char *) "flag", NULL
8352 };
8353
8354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8355 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8356 if (!SWIG_IsOK(ecode1)) {
8357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8358 }
8359 arg1 = static_cast< bool >(val1);
8360 {
8361 PyThreadState* __tstate = wxPyBeginAllowThreads();
8362 wxToolTip::Enable(arg1);
8363 wxPyEndAllowThreads(__tstate);
8364 if (PyErr_Occurred()) SWIG_fail;
8365 }
8366 resultobj = SWIG_Py_Void();
8367 return resultobj;
8368 fail:
8369 return NULL;
8370 }
8371
8372
8373 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8374 PyObject *resultobj = 0;
8375 long arg1 ;
8376 long val1 ;
8377 int ecode1 = 0 ;
8378 PyObject * obj0 = 0 ;
8379 char * kwnames[] = {
8380 (char *) "milliseconds", NULL
8381 };
8382
8383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8384 ecode1 = SWIG_AsVal_long(obj0, &val1);
8385 if (!SWIG_IsOK(ecode1)) {
8386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8387 }
8388 arg1 = static_cast< long >(val1);
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 wxToolTip::SetDelay(arg1);
8392 wxPyEndAllowThreads(__tstate);
8393 if (PyErr_Occurred()) SWIG_fail;
8394 }
8395 resultobj = SWIG_Py_Void();
8396 return resultobj;
8397 fail:
8398 return NULL;
8399 }
8400
8401
8402 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8403 PyObject *obj;
8404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8405 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8406 return SWIG_Py_Void();
8407 }
8408
8409 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8410 return SWIG_Python_InitShadowInstance(args);
8411 }
8412
8413 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj = 0;
8415 wxWindow *arg1 = (wxWindow *) 0 ;
8416 wxSize *arg2 = 0 ;
8417 wxCaret *result = 0 ;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 wxSize temp2 ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 char * kwnames[] = {
8424 (char *) "window",(char *) "size", NULL
8425 };
8426
8427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8431 }
8432 arg1 = reinterpret_cast< wxWindow * >(argp1);
8433 {
8434 arg2 = &temp2;
8435 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8436 }
8437 {
8438 if (!wxPyCheckForApp()) SWIG_fail;
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8445 return resultobj;
8446 fail:
8447 return NULL;
8448 }
8449
8450
8451 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8452 PyObject *resultobj = 0;
8453 wxCaret *arg1 = (wxCaret *) 0 ;
8454 void *argp1 = 0 ;
8455 int res1 = 0 ;
8456 PyObject *swig_obj[1] ;
8457
8458 if (!args) SWIG_fail;
8459 swig_obj[0] = args;
8460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8461 if (!SWIG_IsOK(res1)) {
8462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8463 }
8464 arg1 = reinterpret_cast< wxCaret * >(argp1);
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 delete arg1;
8468
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 resultobj = SWIG_Py_Void();
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8480 PyObject *resultobj = 0;
8481 wxCaret *arg1 = (wxCaret *) 0 ;
8482 void *argp1 = 0 ;
8483 int res1 = 0 ;
8484 PyObject *swig_obj[1] ;
8485
8486 if (!args) SWIG_fail;
8487 swig_obj[0] = args;
8488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8489 if (!SWIG_IsOK(res1)) {
8490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8491 }
8492 arg1 = reinterpret_cast< wxCaret * >(argp1);
8493 {
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 wxCaret_Destroy(arg1);
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 resultobj = SWIG_Py_Void();
8500 return resultobj;
8501 fail:
8502 return NULL;
8503 }
8504
8505
8506 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8507 PyObject *resultobj = 0;
8508 wxCaret *arg1 = (wxCaret *) 0 ;
8509 bool result;
8510 void *argp1 = 0 ;
8511 int res1 = 0 ;
8512 PyObject *swig_obj[1] ;
8513
8514 if (!args) SWIG_fail;
8515 swig_obj[0] = args;
8516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8517 if (!SWIG_IsOK(res1)) {
8518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8519 }
8520 arg1 = reinterpret_cast< wxCaret * >(argp1);
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 result = (bool)(arg1)->IsOk();
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 {
8528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8529 }
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8537 PyObject *resultobj = 0;
8538 wxCaret *arg1 = (wxCaret *) 0 ;
8539 bool result;
8540 void *argp1 = 0 ;
8541 int res1 = 0 ;
8542 PyObject *swig_obj[1] ;
8543
8544 if (!args) SWIG_fail;
8545 swig_obj[0] = args;
8546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8547 if (!SWIG_IsOK(res1)) {
8548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8549 }
8550 arg1 = reinterpret_cast< wxCaret * >(argp1);
8551 {
8552 PyThreadState* __tstate = wxPyBeginAllowThreads();
8553 result = (bool)(arg1)->IsVisible();
8554 wxPyEndAllowThreads(__tstate);
8555 if (PyErr_Occurred()) SWIG_fail;
8556 }
8557 {
8558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8559 }
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8567 PyObject *resultobj = 0;
8568 wxCaret *arg1 = (wxCaret *) 0 ;
8569 wxPoint result;
8570 void *argp1 = 0 ;
8571 int res1 = 0 ;
8572 PyObject *swig_obj[1] ;
8573
8574 if (!args) SWIG_fail;
8575 swig_obj[0] = args;
8576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8577 if (!SWIG_IsOK(res1)) {
8578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8579 }
8580 arg1 = reinterpret_cast< wxCaret * >(argp1);
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (arg1)->GetPosition();
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8588 return resultobj;
8589 fail:
8590 return NULL;
8591 }
8592
8593
8594 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8595 PyObject *resultobj = 0;
8596 wxCaret *arg1 = (wxCaret *) 0 ;
8597 int *arg2 = (int *) 0 ;
8598 int *arg3 = (int *) 0 ;
8599 void *argp1 = 0 ;
8600 int res1 = 0 ;
8601 int temp2 ;
8602 int res2 = SWIG_TMPOBJ ;
8603 int temp3 ;
8604 int res3 = SWIG_TMPOBJ ;
8605 PyObject *swig_obj[1] ;
8606
8607 arg2 = &temp2;
8608 arg3 = &temp3;
8609 if (!args) SWIG_fail;
8610 swig_obj[0] = args;
8611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8614 }
8615 arg1 = reinterpret_cast< wxCaret * >(argp1);
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 (arg1)->GetPosition(arg2,arg3);
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 resultobj = SWIG_Py_Void();
8623 if (SWIG_IsTmpObj(res2)) {
8624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8625 } else {
8626 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8628 }
8629 if (SWIG_IsTmpObj(res3)) {
8630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8631 } else {
8632 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8634 }
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8642 PyObject *resultobj = 0;
8643 wxCaret *arg1 = (wxCaret *) 0 ;
8644 wxSize result;
8645 void *argp1 = 0 ;
8646 int res1 = 0 ;
8647 PyObject *swig_obj[1] ;
8648
8649 if (!args) SWIG_fail;
8650 swig_obj[0] = args;
8651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8652 if (!SWIG_IsOK(res1)) {
8653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8654 }
8655 arg1 = reinterpret_cast< wxCaret * >(argp1);
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (arg1)->GetSize();
8659 wxPyEndAllowThreads(__tstate);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8670 PyObject *resultobj = 0;
8671 wxCaret *arg1 = (wxCaret *) 0 ;
8672 int *arg2 = (int *) 0 ;
8673 int *arg3 = (int *) 0 ;
8674 void *argp1 = 0 ;
8675 int res1 = 0 ;
8676 int temp2 ;
8677 int res2 = SWIG_TMPOBJ ;
8678 int temp3 ;
8679 int res3 = SWIG_TMPOBJ ;
8680 PyObject *swig_obj[1] ;
8681
8682 arg2 = &temp2;
8683 arg3 = &temp3;
8684 if (!args) SWIG_fail;
8685 swig_obj[0] = args;
8686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8687 if (!SWIG_IsOK(res1)) {
8688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8689 }
8690 arg1 = reinterpret_cast< wxCaret * >(argp1);
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 (arg1)->GetSize(arg2,arg3);
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 resultobj = SWIG_Py_Void();
8698 if (SWIG_IsTmpObj(res2)) {
8699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8700 } else {
8701 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8703 }
8704 if (SWIG_IsTmpObj(res3)) {
8705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8706 } else {
8707 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8709 }
8710 return resultobj;
8711 fail:
8712 return NULL;
8713 }
8714
8715
8716 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8717 PyObject *resultobj = 0;
8718 wxCaret *arg1 = (wxCaret *) 0 ;
8719 wxWindow *result = 0 ;
8720 void *argp1 = 0 ;
8721 int res1 = 0 ;
8722 PyObject *swig_obj[1] ;
8723
8724 if (!args) SWIG_fail;
8725 swig_obj[0] = args;
8726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8727 if (!SWIG_IsOK(res1)) {
8728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8729 }
8730 arg1 = reinterpret_cast< wxCaret * >(argp1);
8731 {
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 result = (wxWindow *)(arg1)->GetWindow();
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 {
8738 resultobj = wxPyMake_wxObject(result, 0);
8739 }
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj = 0;
8748 wxCaret *arg1 = (wxCaret *) 0 ;
8749 int arg2 ;
8750 int arg3 ;
8751 void *argp1 = 0 ;
8752 int res1 = 0 ;
8753 int val2 ;
8754 int ecode2 = 0 ;
8755 int val3 ;
8756 int ecode3 = 0 ;
8757 PyObject * obj0 = 0 ;
8758 PyObject * obj1 = 0 ;
8759 PyObject * obj2 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "x",(char *) "y", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8768 }
8769 arg1 = reinterpret_cast< wxCaret * >(argp1);
8770 ecode2 = SWIG_AsVal_int(obj1, &val2);
8771 if (!SWIG_IsOK(ecode2)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8773 }
8774 arg2 = static_cast< int >(val2);
8775 ecode3 = SWIG_AsVal_int(obj2, &val3);
8776 if (!SWIG_IsOK(ecode3)) {
8777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8778 }
8779 arg3 = static_cast< int >(val3);
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 (arg1)->Move(arg2,arg3);
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_Py_Void();
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj = 0;
8795 wxCaret *arg1 = (wxCaret *) 0 ;
8796 wxPoint *arg2 = 0 ;
8797 void *argp1 = 0 ;
8798 int res1 = 0 ;
8799 wxPoint temp2 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "pt", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8810 }
8811 arg1 = reinterpret_cast< wxCaret * >(argp1);
8812 {
8813 arg2 = &temp2;
8814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8815 }
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 (arg1)->Move((wxPoint const &)*arg2);
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj = 0;
8831 wxCaret *arg1 = (wxCaret *) 0 ;
8832 int arg2 ;
8833 int arg3 ;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 int val2 ;
8837 int ecode2 = 0 ;
8838 int val3 ;
8839 int ecode3 = 0 ;
8840 PyObject * obj0 = 0 ;
8841 PyObject * obj1 = 0 ;
8842 PyObject * obj2 = 0 ;
8843 char * kwnames[] = {
8844 (char *) "self",(char *) "width",(char *) "height", NULL
8845 };
8846
8847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8851 }
8852 arg1 = reinterpret_cast< wxCaret * >(argp1);
8853 ecode2 = SWIG_AsVal_int(obj1, &val2);
8854 if (!SWIG_IsOK(ecode2)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8856 }
8857 arg2 = static_cast< int >(val2);
8858 ecode3 = SWIG_AsVal_int(obj2, &val3);
8859 if (!SWIG_IsOK(ecode3)) {
8860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8861 }
8862 arg3 = static_cast< int >(val3);
8863 {
8864 PyThreadState* __tstate = wxPyBeginAllowThreads();
8865 (arg1)->SetSize(arg2,arg3);
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 resultobj = SWIG_Py_Void();
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj = 0;
8878 wxCaret *arg1 = (wxCaret *) 0 ;
8879 wxSize *arg2 = 0 ;
8880 void *argp1 = 0 ;
8881 int res1 = 0 ;
8882 wxSize temp2 ;
8883 PyObject * obj0 = 0 ;
8884 PyObject * obj1 = 0 ;
8885 char * kwnames[] = {
8886 (char *) "self",(char *) "size", NULL
8887 };
8888
8889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8891 if (!SWIG_IsOK(res1)) {
8892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8893 }
8894 arg1 = reinterpret_cast< wxCaret * >(argp1);
8895 {
8896 arg2 = &temp2;
8897 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 (arg1)->SetSize((wxSize const &)*arg2);
8902 wxPyEndAllowThreads(__tstate);
8903 if (PyErr_Occurred()) SWIG_fail;
8904 }
8905 resultobj = SWIG_Py_Void();
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj = 0;
8914 wxCaret *arg1 = (wxCaret *) 0 ;
8915 int arg2 = (int) true ;
8916 void *argp1 = 0 ;
8917 int res1 = 0 ;
8918 int val2 ;
8919 int ecode2 = 0 ;
8920 PyObject * obj0 = 0 ;
8921 PyObject * obj1 = 0 ;
8922 char * kwnames[] = {
8923 (char *) "self",(char *) "show", NULL
8924 };
8925
8926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8928 if (!SWIG_IsOK(res1)) {
8929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8930 }
8931 arg1 = reinterpret_cast< wxCaret * >(argp1);
8932 if (obj1) {
8933 ecode2 = SWIG_AsVal_int(obj1, &val2);
8934 if (!SWIG_IsOK(ecode2)) {
8935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8936 }
8937 arg2 = static_cast< int >(val2);
8938 }
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 (arg1)->Show(arg2);
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 resultobj = SWIG_Py_Void();
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8953 PyObject *resultobj = 0;
8954 wxCaret *arg1 = (wxCaret *) 0 ;
8955 void *argp1 = 0 ;
8956 int res1 = 0 ;
8957 PyObject *swig_obj[1] ;
8958
8959 if (!args) SWIG_fail;
8960 swig_obj[0] = args;
8961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8962 if (!SWIG_IsOK(res1)) {
8963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8964 }
8965 arg1 = reinterpret_cast< wxCaret * >(argp1);
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 (arg1)->Hide();
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 resultobj = SWIG_Py_Void();
8973 return resultobj;
8974 fail:
8975 return NULL;
8976 }
8977
8978
8979 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8980 PyObject *resultobj = 0;
8981 int result;
8982
8983 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 result = (int)wxCaret::GetBlinkTime();
8987 wxPyEndAllowThreads(__tstate);
8988 if (PyErr_Occurred()) SWIG_fail;
8989 }
8990 resultobj = SWIG_From_int(static_cast< int >(result));
8991 return resultobj;
8992 fail:
8993 return NULL;
8994 }
8995
8996
8997 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8998 PyObject *resultobj = 0;
8999 int arg1 ;
9000 int val1 ;
9001 int ecode1 = 0 ;
9002 PyObject * obj0 = 0 ;
9003 char * kwnames[] = {
9004 (char *) "milliseconds", NULL
9005 };
9006
9007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9008 ecode1 = SWIG_AsVal_int(obj0, &val1);
9009 if (!SWIG_IsOK(ecode1)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9011 }
9012 arg1 = static_cast< int >(val1);
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 wxCaret::SetBlinkTime(arg1);
9016 wxPyEndAllowThreads(__tstate);
9017 if (PyErr_Occurred()) SWIG_fail;
9018 }
9019 resultobj = SWIG_Py_Void();
9020 return resultobj;
9021 fail:
9022 return NULL;
9023 }
9024
9025
9026 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9027 PyObject *obj;
9028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9029 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9030 return SWIG_Py_Void();
9031 }
9032
9033 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 return SWIG_Python_InitShadowInstance(args);
9035 }
9036
9037 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj = 0;
9039 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9040 wxBusyCursor *result = 0 ;
9041 void *argp1 = 0 ;
9042 int res1 = 0 ;
9043 PyObject * obj0 = 0 ;
9044 char * kwnames[] = {
9045 (char *) "cursor", NULL
9046 };
9047
9048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9049 if (obj0) {
9050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9051 if (!SWIG_IsOK(res1)) {
9052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9053 }
9054 arg1 = reinterpret_cast< wxCursor * >(argp1);
9055 }
9056 {
9057 if (!wxPyCheckForApp()) SWIG_fail;
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9060 wxPyEndAllowThreads(__tstate);
9061 if (PyErr_Occurred()) SWIG_fail;
9062 }
9063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9064 return resultobj;
9065 fail:
9066 return NULL;
9067 }
9068
9069
9070 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9071 PyObject *resultobj = 0;
9072 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9073 void *argp1 = 0 ;
9074 int res1 = 0 ;
9075 PyObject *swig_obj[1] ;
9076
9077 if (!args) SWIG_fail;
9078 swig_obj[0] = args;
9079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9080 if (!SWIG_IsOK(res1)) {
9081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9082 }
9083 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 delete arg1;
9087
9088 wxPyEndAllowThreads(__tstate);
9089 if (PyErr_Occurred()) SWIG_fail;
9090 }
9091 resultobj = SWIG_Py_Void();
9092 return resultobj;
9093 fail:
9094 return NULL;
9095 }
9096
9097
9098 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9099 PyObject *obj;
9100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9101 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9102 return SWIG_Py_Void();
9103 }
9104
9105 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 return SWIG_Python_InitShadowInstance(args);
9107 }
9108
9109 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9110 PyObject *resultobj = 0;
9111 wxWindow *arg1 = (wxWindow *) NULL ;
9112 wxWindowDisabler *result = 0 ;
9113 void *argp1 = 0 ;
9114 int res1 = 0 ;
9115 PyObject * obj0 = 0 ;
9116 char * kwnames[] = {
9117 (char *) "winToSkip", NULL
9118 };
9119
9120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9121 if (obj0) {
9122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9123 if (!SWIG_IsOK(res1)) {
9124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9125 }
9126 arg1 = reinterpret_cast< wxWindow * >(argp1);
9127 }
9128 {
9129 if (!wxPyCheckForApp()) SWIG_fail;
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9143 PyObject *resultobj = 0;
9144 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9145 void *argp1 = 0 ;
9146 int res1 = 0 ;
9147 PyObject *swig_obj[1] ;
9148
9149 if (!args) SWIG_fail;
9150 swig_obj[0] = args;
9151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9152 if (!SWIG_IsOK(res1)) {
9153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9154 }
9155 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9156 {
9157 PyThreadState* __tstate = wxPyBeginAllowThreads();
9158 delete arg1;
9159
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 resultobj = SWIG_Py_Void();
9164 return resultobj;
9165 fail:
9166 return NULL;
9167 }
9168
9169
9170 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9171 PyObject *obj;
9172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9173 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9174 return SWIG_Py_Void();
9175 }
9176
9177 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9178 return SWIG_Python_InitShadowInstance(args);
9179 }
9180
9181 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj = 0;
9183 wxString *arg1 = 0 ;
9184 wxBusyInfo *result = 0 ;
9185 bool temp1 = false ;
9186 PyObject * obj0 = 0 ;
9187 char * kwnames[] = {
9188 (char *) "message", NULL
9189 };
9190
9191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9192 {
9193 arg1 = wxString_in_helper(obj0);
9194 if (arg1 == NULL) SWIG_fail;
9195 temp1 = true;
9196 }
9197 {
9198 if (!wxPyCheckForApp()) SWIG_fail;
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9201 wxPyEndAllowThreads(__tstate);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9205 {
9206 if (temp1)
9207 delete arg1;
9208 }
9209 return resultobj;
9210 fail:
9211 {
9212 if (temp1)
9213 delete arg1;
9214 }
9215 return NULL;
9216 }
9217
9218
9219 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9220 PyObject *resultobj = 0;
9221 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9222 void *argp1 = 0 ;
9223 int res1 = 0 ;
9224 PyObject *swig_obj[1] ;
9225
9226 if (!args) SWIG_fail;
9227 swig_obj[0] = args;
9228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9231 }
9232 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 delete arg1;
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 resultobj = SWIG_Py_Void();
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9248 PyObject *obj;
9249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9250 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9251 return SWIG_Py_Void();
9252 }
9253
9254 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 return SWIG_Python_InitShadowInstance(args);
9256 }
9257
9258 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxStopWatch *result = 0 ;
9261
9262 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9263 {
9264 PyThreadState* __tstate = wxPyBeginAllowThreads();
9265 result = (wxStopWatch *)new wxStopWatch();
9266 wxPyEndAllowThreads(__tstate);
9267 if (PyErr_Occurred()) SWIG_fail;
9268 }
9269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9270 return resultobj;
9271 fail:
9272 return NULL;
9273 }
9274
9275
9276 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9277 PyObject *resultobj = 0;
9278 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9279 void *argp1 = 0 ;
9280 int res1 = 0 ;
9281 PyObject *swig_obj[1] ;
9282
9283 if (!args) SWIG_fail;
9284 swig_obj[0] = args;
9285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9286 if (!SWIG_IsOK(res1)) {
9287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9288 }
9289 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 delete arg1;
9293
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 resultobj = SWIG_Py_Void();
9298 return resultobj;
9299 fail:
9300 return NULL;
9301 }
9302
9303
9304 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9305 PyObject *resultobj = 0;
9306 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9307 long arg2 = (long) 0 ;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 long val2 ;
9311 int ecode2 = 0 ;
9312 PyObject * obj0 = 0 ;
9313 PyObject * obj1 = 0 ;
9314 char * kwnames[] = {
9315 (char *) "self",(char *) "t0", NULL
9316 };
9317
9318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9322 }
9323 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9324 if (obj1) {
9325 ecode2 = SWIG_AsVal_long(obj1, &val2);
9326 if (!SWIG_IsOK(ecode2)) {
9327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9328 }
9329 arg2 = static_cast< long >(val2);
9330 }
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 (arg1)->Start(arg2);
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 resultobj = SWIG_Py_Void();
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9345 PyObject *resultobj = 0;
9346 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9347 void *argp1 = 0 ;
9348 int res1 = 0 ;
9349 PyObject *swig_obj[1] ;
9350
9351 if (!args) SWIG_fail;
9352 swig_obj[0] = args;
9353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9354 if (!SWIG_IsOK(res1)) {
9355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9356 }
9357 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 (arg1)->Pause();
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 resultobj = SWIG_Py_Void();
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9372 PyObject *resultobj = 0;
9373 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 PyObject *swig_obj[1] ;
9377
9378 if (!args) SWIG_fail;
9379 swig_obj[0] = args;
9380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9383 }
9384 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 (arg1)->Resume();
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 resultobj = SWIG_Py_Void();
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9399 PyObject *resultobj = 0;
9400 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9401 long result;
9402 void *argp1 = 0 ;
9403 int res1 = 0 ;
9404 PyObject *swig_obj[1] ;
9405
9406 if (!args) SWIG_fail;
9407 swig_obj[0] = args;
9408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9409 if (!SWIG_IsOK(res1)) {
9410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9411 }
9412 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 result = (long)((wxStopWatch const *)arg1)->Time();
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 resultobj = SWIG_From_long(static_cast< long >(result));
9420 return resultobj;
9421 fail:
9422 return NULL;
9423 }
9424
9425
9426 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9427 PyObject *obj;
9428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9429 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9430 return SWIG_Py_Void();
9431 }
9432
9433 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9434 return SWIG_Python_InitShadowInstance(args);
9435 }
9436
9437 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj = 0;
9439 int arg1 = (int) 9 ;
9440 int arg2 = (int) wxID_FILE1 ;
9441 wxFileHistory *result = 0 ;
9442 int val1 ;
9443 int ecode1 = 0 ;
9444 int val2 ;
9445 int ecode2 = 0 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char * kwnames[] = {
9449 (char *) "maxFiles",(char *) "idBase", NULL
9450 };
9451
9452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9453 if (obj0) {
9454 ecode1 = SWIG_AsVal_int(obj0, &val1);
9455 if (!SWIG_IsOK(ecode1)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9457 }
9458 arg1 = static_cast< int >(val1);
9459 }
9460 if (obj1) {
9461 ecode2 = SWIG_AsVal_int(obj1, &val2);
9462 if (!SWIG_IsOK(ecode2)) {
9463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9464 }
9465 arg2 = static_cast< int >(val2);
9466 }
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *resultobj = 0;
9482 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9483 void *argp1 = 0 ;
9484 int res1 = 0 ;
9485 PyObject *swig_obj[1] ;
9486
9487 if (!args) SWIG_fail;
9488 swig_obj[0] = args;
9489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9490 if (!SWIG_IsOK(res1)) {
9491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9492 }
9493 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9494 {
9495 PyThreadState* __tstate = wxPyBeginAllowThreads();
9496 delete arg1;
9497
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 resultobj = SWIG_Py_Void();
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj = 0;
9510 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9511 wxString *arg2 = 0 ;
9512 void *argp1 = 0 ;
9513 int res1 = 0 ;
9514 bool temp2 = false ;
9515 PyObject * obj0 = 0 ;
9516 PyObject * obj1 = 0 ;
9517 char * kwnames[] = {
9518 (char *) "self",(char *) "file", NULL
9519 };
9520
9521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9523 if (!SWIG_IsOK(res1)) {
9524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9525 }
9526 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9527 {
9528 arg2 = wxString_in_helper(obj1);
9529 if (arg2 == NULL) SWIG_fail;
9530 temp2 = true;
9531 }
9532 {
9533 PyThreadState* __tstate = wxPyBeginAllowThreads();
9534 (arg1)->AddFileToHistory((wxString const &)*arg2);
9535 wxPyEndAllowThreads(__tstate);
9536 if (PyErr_Occurred()) SWIG_fail;
9537 }
9538 resultobj = SWIG_Py_Void();
9539 {
9540 if (temp2)
9541 delete arg2;
9542 }
9543 return resultobj;
9544 fail:
9545 {
9546 if (temp2)
9547 delete arg2;
9548 }
9549 return NULL;
9550 }
9551
9552
9553 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9554 PyObject *resultobj = 0;
9555 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9556 int arg2 ;
9557 void *argp1 = 0 ;
9558 int res1 = 0 ;
9559 int val2 ;
9560 int ecode2 = 0 ;
9561 PyObject * obj0 = 0 ;
9562 PyObject * obj1 = 0 ;
9563 char * kwnames[] = {
9564 (char *) "self",(char *) "i", NULL
9565 };
9566
9567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9569 if (!SWIG_IsOK(res1)) {
9570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9571 }
9572 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9573 ecode2 = SWIG_AsVal_int(obj1, &val2);
9574 if (!SWIG_IsOK(ecode2)) {
9575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9576 }
9577 arg2 = static_cast< int >(val2);
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 (arg1)->RemoveFileFromHistory(arg2);
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 resultobj = SWIG_Py_Void();
9585 return resultobj;
9586 fail:
9587 return NULL;
9588 }
9589
9590
9591 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9592 PyObject *resultobj = 0;
9593 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9594 int result;
9595 void *argp1 = 0 ;
9596 int res1 = 0 ;
9597 PyObject *swig_obj[1] ;
9598
9599 if (!args) SWIG_fail;
9600 swig_obj[0] = args;
9601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9602 if (!SWIG_IsOK(res1)) {
9603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9604 }
9605 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 resultobj = SWIG_From_int(static_cast< int >(result));
9613 return resultobj;
9614 fail:
9615 return NULL;
9616 }
9617
9618
9619 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj = 0;
9621 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9622 wxMenu *arg2 = (wxMenu *) 0 ;
9623 void *argp1 = 0 ;
9624 int res1 = 0 ;
9625 void *argp2 = 0 ;
9626 int res2 = 0 ;
9627 PyObject * obj0 = 0 ;
9628 PyObject * obj1 = 0 ;
9629 char * kwnames[] = {
9630 (char *) "self",(char *) "menu", NULL
9631 };
9632
9633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9635 if (!SWIG_IsOK(res1)) {
9636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9637 }
9638 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9640 if (!SWIG_IsOK(res2)) {
9641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9642 }
9643 arg2 = reinterpret_cast< wxMenu * >(argp2);
9644 {
9645 PyThreadState* __tstate = wxPyBeginAllowThreads();
9646 (arg1)->UseMenu(arg2);
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_Py_Void();
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj = 0;
9659 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9660 wxMenu *arg2 = (wxMenu *) 0 ;
9661 void *argp1 = 0 ;
9662 int res1 = 0 ;
9663 void *argp2 = 0 ;
9664 int res2 = 0 ;
9665 PyObject * obj0 = 0 ;
9666 PyObject * obj1 = 0 ;
9667 char * kwnames[] = {
9668 (char *) "self",(char *) "menu", NULL
9669 };
9670
9671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9673 if (!SWIG_IsOK(res1)) {
9674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9675 }
9676 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9678 if (!SWIG_IsOK(res2)) {
9679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9680 }
9681 arg2 = reinterpret_cast< wxMenu * >(argp2);
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 (arg1)->RemoveMenu(arg2);
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_Py_Void();
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9696 PyObject *resultobj = 0;
9697 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9698 wxConfigBase *arg2 = 0 ;
9699 void *argp1 = 0 ;
9700 int res1 = 0 ;
9701 void *argp2 = 0 ;
9702 int res2 = 0 ;
9703 PyObject * obj0 = 0 ;
9704 PyObject * obj1 = 0 ;
9705 char * kwnames[] = {
9706 (char *) "self",(char *) "config", NULL
9707 };
9708
9709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9711 if (!SWIG_IsOK(res1)) {
9712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9713 }
9714 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9716 if (!SWIG_IsOK(res2)) {
9717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9718 }
9719 if (!argp2) {
9720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9721 }
9722 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 (arg1)->Load(*arg2);
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 resultobj = SWIG_Py_Void();
9730 return resultobj;
9731 fail:
9732 return NULL;
9733 }
9734
9735
9736 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9737 PyObject *resultobj = 0;
9738 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9739 wxConfigBase *arg2 = 0 ;
9740 void *argp1 = 0 ;
9741 int res1 = 0 ;
9742 void *argp2 = 0 ;
9743 int res2 = 0 ;
9744 PyObject * obj0 = 0 ;
9745 PyObject * obj1 = 0 ;
9746 char * kwnames[] = {
9747 (char *) "self",(char *) "config", NULL
9748 };
9749
9750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9752 if (!SWIG_IsOK(res1)) {
9753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9754 }
9755 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9757 if (!SWIG_IsOK(res2)) {
9758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9759 }
9760 if (!argp2) {
9761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9762 }
9763 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 (arg1)->Save(*arg2);
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 resultobj = SWIG_Py_Void();
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9778 PyObject *resultobj = 0;
9779 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9780 void *argp1 = 0 ;
9781 int res1 = 0 ;
9782 PyObject *swig_obj[1] ;
9783
9784 if (!args) SWIG_fail;
9785 swig_obj[0] = args;
9786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9789 }
9790 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 (arg1)->AddFilesToMenu();
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 resultobj = SWIG_Py_Void();
9798 return resultobj;
9799 fail:
9800 return NULL;
9801 }
9802
9803
9804 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9805 PyObject *resultobj = 0;
9806 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9807 wxMenu *arg2 = (wxMenu *) 0 ;
9808 void *argp1 = 0 ;
9809 int res1 = 0 ;
9810 void *argp2 = 0 ;
9811 int res2 = 0 ;
9812 PyObject * obj0 = 0 ;
9813 PyObject * obj1 = 0 ;
9814 char * kwnames[] = {
9815 (char *) "self",(char *) "menu", NULL
9816 };
9817
9818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9820 if (!SWIG_IsOK(res1)) {
9821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9822 }
9823 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9825 if (!SWIG_IsOK(res2)) {
9826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9827 }
9828 arg2 = reinterpret_cast< wxMenu * >(argp2);
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 (arg1)->AddFilesToMenu(arg2);
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 resultobj = SWIG_Py_Void();
9836 return resultobj;
9837 fail:
9838 return NULL;
9839 }
9840
9841
9842 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9843 PyObject *resultobj = 0;
9844 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9845 int arg2 ;
9846 wxString result;
9847 void *argp1 = 0 ;
9848 int res1 = 0 ;
9849 int val2 ;
9850 int ecode2 = 0 ;
9851 PyObject * obj0 = 0 ;
9852 PyObject * obj1 = 0 ;
9853 char * kwnames[] = {
9854 (char *) "self",(char *) "i", NULL
9855 };
9856
9857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9859 if (!SWIG_IsOK(res1)) {
9860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9861 }
9862 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9863 ecode2 = SWIG_AsVal_int(obj1, &val2);
9864 if (!SWIG_IsOK(ecode2)) {
9865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9866 }
9867 arg2 = static_cast< int >(val2);
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 {
9875 #if wxUSE_UNICODE
9876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9877 #else
9878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9879 #endif
9880 }
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9888 PyObject *resultobj = 0;
9889 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9890 int result;
9891 void *argp1 = 0 ;
9892 int res1 = 0 ;
9893 PyObject *swig_obj[1] ;
9894
9895 if (!args) SWIG_fail;
9896 swig_obj[0] = args;
9897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9898 if (!SWIG_IsOK(res1)) {
9899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9900 }
9901 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (int)((wxFileHistory const *)arg1)->GetCount();
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_From_int(static_cast< int >(result));
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9916 PyObject *obj;
9917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9918 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9919 return SWIG_Py_Void();
9920 }
9921
9922 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9923 return SWIG_Python_InitShadowInstance(args);
9924 }
9925
9926 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9927 PyObject *resultobj = 0;
9928 wxString *arg1 = 0 ;
9929 wxString const &arg2_defvalue = wxPyEmptyString ;
9930 wxString *arg2 = (wxString *) &arg2_defvalue ;
9931 wxSingleInstanceChecker *result = 0 ;
9932 bool temp1 = false ;
9933 bool temp2 = false ;
9934 PyObject * obj0 = 0 ;
9935 PyObject * obj1 = 0 ;
9936 char * kwnames[] = {
9937 (char *) "name",(char *) "path", NULL
9938 };
9939
9940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9941 {
9942 arg1 = wxString_in_helper(obj0);
9943 if (arg1 == NULL) SWIG_fail;
9944 temp1 = true;
9945 }
9946 if (obj1) {
9947 {
9948 arg2 = wxString_in_helper(obj1);
9949 if (arg2 == NULL) SWIG_fail;
9950 temp2 = true;
9951 }
9952 }
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9960 {
9961 if (temp1)
9962 delete arg1;
9963 }
9964 {
9965 if (temp2)
9966 delete arg2;
9967 }
9968 return resultobj;
9969 fail:
9970 {
9971 if (temp1)
9972 delete arg1;
9973 }
9974 {
9975 if (temp2)
9976 delete arg2;
9977 }
9978 return NULL;
9979 }
9980
9981
9982 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9983 PyObject *resultobj = 0;
9984 wxSingleInstanceChecker *result = 0 ;
9985
9986 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9987 {
9988 PyThreadState* __tstate = wxPyBeginAllowThreads();
9989 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9990 wxPyEndAllowThreads(__tstate);
9991 if (PyErr_Occurred()) SWIG_fail;
9992 }
9993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9994 return resultobj;
9995 fail:
9996 return NULL;
9997 }
9998
9999
10000 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10001 PyObject *resultobj = 0;
10002 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10003 void *argp1 = 0 ;
10004 int res1 = 0 ;
10005 PyObject *swig_obj[1] ;
10006
10007 if (!args) SWIG_fail;
10008 swig_obj[0] = args;
10009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10010 if (!SWIG_IsOK(res1)) {
10011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10012 }
10013 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 delete arg1;
10017
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 resultobj = SWIG_Py_Void();
10022 return resultobj;
10023 fail:
10024 return NULL;
10025 }
10026
10027
10028 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10029 PyObject *resultobj = 0;
10030 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10031 wxString *arg2 = 0 ;
10032 wxString const &arg3_defvalue = wxPyEmptyString ;
10033 wxString *arg3 = (wxString *) &arg3_defvalue ;
10034 bool result;
10035 void *argp1 = 0 ;
10036 int res1 = 0 ;
10037 bool temp2 = false ;
10038 bool temp3 = false ;
10039 PyObject * obj0 = 0 ;
10040 PyObject * obj1 = 0 ;
10041 PyObject * obj2 = 0 ;
10042 char * kwnames[] = {
10043 (char *) "self",(char *) "name",(char *) "path", NULL
10044 };
10045
10046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10048 if (!SWIG_IsOK(res1)) {
10049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10050 }
10051 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10052 {
10053 arg2 = wxString_in_helper(obj1);
10054 if (arg2 == NULL) SWIG_fail;
10055 temp2 = true;
10056 }
10057 if (obj2) {
10058 {
10059 arg3 = wxString_in_helper(obj2);
10060 if (arg3 == NULL) SWIG_fail;
10061 temp3 = true;
10062 }
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10067 wxPyEndAllowThreads(__tstate);
10068 if (PyErr_Occurred()) SWIG_fail;
10069 }
10070 {
10071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10072 }
10073 {
10074 if (temp2)
10075 delete arg2;
10076 }
10077 {
10078 if (temp3)
10079 delete arg3;
10080 }
10081 return resultobj;
10082 fail:
10083 {
10084 if (temp2)
10085 delete arg2;
10086 }
10087 {
10088 if (temp3)
10089 delete arg3;
10090 }
10091 return NULL;
10092 }
10093
10094
10095 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10096 PyObject *resultobj = 0;
10097 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10098 bool result;
10099 void *argp1 = 0 ;
10100 int res1 = 0 ;
10101 PyObject *swig_obj[1] ;
10102
10103 if (!args) SWIG_fail;
10104 swig_obj[0] = args;
10105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10106 if (!SWIG_IsOK(res1)) {
10107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10108 }
10109 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10110 {
10111 PyThreadState* __tstate = wxPyBeginAllowThreads();
10112 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10113 wxPyEndAllowThreads(__tstate);
10114 if (PyErr_Occurred()) SWIG_fail;
10115 }
10116 {
10117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10118 }
10119 return resultobj;
10120 fail:
10121 return NULL;
10122 }
10123
10124
10125 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10126 PyObject *obj;
10127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10128 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10129 return SWIG_Py_Void();
10130 }
10131
10132 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10133 return SWIG_Python_InitShadowInstance(args);
10134 }
10135
10136 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10137 PyObject *resultobj = 0;
10138 wxPlatformInfo *result = 0 ;
10139
10140 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10141 {
10142 PyThreadState* __tstate = wxPyBeginAllowThreads();
10143 result = (wxPlatformInfo *)new wxPlatformInfo();
10144 wxPyEndAllowThreads(__tstate);
10145 if (PyErr_Occurred()) SWIG_fail;
10146 }
10147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10148 return resultobj;
10149 fail:
10150 return NULL;
10151 }
10152
10153
10154 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10155 PyObject *resultobj = 0;
10156 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10157 wxPlatformInfo *arg2 = 0 ;
10158 bool result;
10159 void *argp1 = 0 ;
10160 int res1 = 0 ;
10161 void *argp2 = 0 ;
10162 int res2 = 0 ;
10163 PyObject * obj0 = 0 ;
10164 PyObject * obj1 = 0 ;
10165 char * kwnames[] = {
10166 (char *) "self",(char *) "t", NULL
10167 };
10168
10169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10173 }
10174 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10176 if (!SWIG_IsOK(res2)) {
10177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10178 }
10179 if (!argp2) {
10180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10181 }
10182 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10183 {
10184 PyThreadState* __tstate = wxPyBeginAllowThreads();
10185 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 {
10190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10191 }
10192 return resultobj;
10193 fail:
10194 return NULL;
10195 }
10196
10197
10198 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10199 PyObject *resultobj = 0;
10200 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10201 wxPlatformInfo *arg2 = 0 ;
10202 bool result;
10203 void *argp1 = 0 ;
10204 int res1 = 0 ;
10205 void *argp2 = 0 ;
10206 int res2 = 0 ;
10207 PyObject * obj0 = 0 ;
10208 PyObject * obj1 = 0 ;
10209 char * kwnames[] = {
10210 (char *) "self",(char *) "t", NULL
10211 };
10212
10213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10215 if (!SWIG_IsOK(res1)) {
10216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10217 }
10218 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10219 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10220 if (!SWIG_IsOK(res2)) {
10221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10222 }
10223 if (!argp2) {
10224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10225 }
10226 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 {
10234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10235 }
10236 return resultobj;
10237 fail:
10238 return NULL;
10239 }
10240
10241
10242 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10243 PyObject *resultobj = 0;
10244 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10245 int result;
10246 void *argp1 = 0 ;
10247 int res1 = 0 ;
10248 PyObject *swig_obj[1] ;
10249
10250 if (!args) SWIG_fail;
10251 swig_obj[0] = args;
10252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10253 if (!SWIG_IsOK(res1)) {
10254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10255 }
10256 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10257 {
10258 PyThreadState* __tstate = wxPyBeginAllowThreads();
10259 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10260 wxPyEndAllowThreads(__tstate);
10261 if (PyErr_Occurred()) SWIG_fail;
10262 }
10263 resultobj = SWIG_From_int(static_cast< int >(result));
10264 return resultobj;
10265 fail:
10266 return NULL;
10267 }
10268
10269
10270 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10271 PyObject *resultobj = 0;
10272 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10273 int result;
10274 void *argp1 = 0 ;
10275 int res1 = 0 ;
10276 PyObject *swig_obj[1] ;
10277
10278 if (!args) SWIG_fail;
10279 swig_obj[0] = args;
10280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10283 }
10284 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10285 {
10286 PyThreadState* __tstate = wxPyBeginAllowThreads();
10287 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10288 wxPyEndAllowThreads(__tstate);
10289 if (PyErr_Occurred()) SWIG_fail;
10290 }
10291 resultobj = SWIG_From_int(static_cast< int >(result));
10292 return resultobj;
10293 fail:
10294 return NULL;
10295 }
10296
10297
10298 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj = 0;
10300 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10301 int arg2 ;
10302 int arg3 ;
10303 bool result;
10304 void *argp1 = 0 ;
10305 int res1 = 0 ;
10306 int val2 ;
10307 int ecode2 = 0 ;
10308 int val3 ;
10309 int ecode3 = 0 ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 PyObject * obj2 = 0 ;
10313 char * kwnames[] = {
10314 (char *) "self",(char *) "major",(char *) "minor", NULL
10315 };
10316
10317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10319 if (!SWIG_IsOK(res1)) {
10320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10321 }
10322 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10323 ecode2 = SWIG_AsVal_int(obj1, &val2);
10324 if (!SWIG_IsOK(ecode2)) {
10325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10326 }
10327 arg2 = static_cast< int >(val2);
10328 ecode3 = SWIG_AsVal_int(obj2, &val3);
10329 if (!SWIG_IsOK(ecode3)) {
10330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10331 }
10332 arg3 = static_cast< int >(val3);
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 {
10340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10341 }
10342 return resultobj;
10343 fail:
10344 return NULL;
10345 }
10346
10347
10348 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10349 PyObject *resultobj = 0;
10350 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10351 int result;
10352 void *argp1 = 0 ;
10353 int res1 = 0 ;
10354 PyObject *swig_obj[1] ;
10355
10356 if (!args) SWIG_fail;
10357 swig_obj[0] = args;
10358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10359 if (!SWIG_IsOK(res1)) {
10360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10361 }
10362 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 resultobj = SWIG_From_int(static_cast< int >(result));
10370 return resultobj;
10371 fail:
10372 return NULL;
10373 }
10374
10375
10376 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10377 PyObject *resultobj = 0;
10378 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10379 int result;
10380 void *argp1 = 0 ;
10381 int res1 = 0 ;
10382 PyObject *swig_obj[1] ;
10383
10384 if (!args) SWIG_fail;
10385 swig_obj[0] = args;
10386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10387 if (!SWIG_IsOK(res1)) {
10388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10389 }
10390 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10391 {
10392 PyThreadState* __tstate = wxPyBeginAllowThreads();
10393 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 resultobj = SWIG_From_int(static_cast< int >(result));
10398 return resultobj;
10399 fail:
10400 return NULL;
10401 }
10402
10403
10404 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10405 PyObject *resultobj = 0;
10406 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10407 int arg2 ;
10408 int arg3 ;
10409 bool result;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 int val2 ;
10413 int ecode2 = 0 ;
10414 int val3 ;
10415 int ecode3 = 0 ;
10416 PyObject * obj0 = 0 ;
10417 PyObject * obj1 = 0 ;
10418 PyObject * obj2 = 0 ;
10419 char * kwnames[] = {
10420 (char *) "self",(char *) "major",(char *) "minor", NULL
10421 };
10422
10423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10425 if (!SWIG_IsOK(res1)) {
10426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10427 }
10428 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10429 ecode2 = SWIG_AsVal_int(obj1, &val2);
10430 if (!SWIG_IsOK(ecode2)) {
10431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10432 }
10433 arg2 = static_cast< int >(val2);
10434 ecode3 = SWIG_AsVal_int(obj2, &val3);
10435 if (!SWIG_IsOK(ecode3)) {
10436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10437 }
10438 arg3 = static_cast< int >(val3);
10439 {
10440 PyThreadState* __tstate = wxPyBeginAllowThreads();
10441 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10442 wxPyEndAllowThreads(__tstate);
10443 if (PyErr_Occurred()) SWIG_fail;
10444 }
10445 {
10446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10447 }
10448 return resultobj;
10449 fail:
10450 return NULL;
10451 }
10452
10453
10454 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10455 PyObject *resultobj = 0;
10456 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10457 bool result;
10458 void *argp1 = 0 ;
10459 int res1 = 0 ;
10460 PyObject *swig_obj[1] ;
10461
10462 if (!args) SWIG_fail;
10463 swig_obj[0] = args;
10464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10465 if (!SWIG_IsOK(res1)) {
10466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10467 }
10468 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10469 {
10470 PyThreadState* __tstate = wxPyBeginAllowThreads();
10471 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 {
10476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10477 }
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10487 wxOperatingSystemId result;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 PyObject *swig_obj[1] ;
10491
10492 if (!args) SWIG_fail;
10493 swig_obj[0] = args;
10494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10497 }
10498 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 resultobj = SWIG_From_int(static_cast< int >(result));
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10513 PyObject *resultobj = 0;
10514 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10515 wxPortId result;
10516 void *argp1 = 0 ;
10517 int res1 = 0 ;
10518 PyObject *swig_obj[1] ;
10519
10520 if (!args) SWIG_fail;
10521 swig_obj[0] = args;
10522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10523 if (!SWIG_IsOK(res1)) {
10524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10525 }
10526 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10527 {
10528 PyThreadState* __tstate = wxPyBeginAllowThreads();
10529 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10530 wxPyEndAllowThreads(__tstate);
10531 if (PyErr_Occurred()) SWIG_fail;
10532 }
10533 resultobj = SWIG_From_int(static_cast< int >(result));
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10541 PyObject *resultobj = 0;
10542 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10543 wxArchitecture result;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 PyObject *swig_obj[1] ;
10547
10548 if (!args) SWIG_fail;
10549 swig_obj[0] = args;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10553 }
10554 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_From_int(static_cast< int >(result));
10562 return resultobj;
10563 fail:
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *resultobj = 0;
10570 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10571 wxEndianness result;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 PyObject *swig_obj[1] ;
10575
10576 if (!args) SWIG_fail;
10577 swig_obj[0] = args;
10578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10579 if (!SWIG_IsOK(res1)) {
10580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10581 }
10582 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 resultobj = SWIG_From_int(static_cast< int >(result));
10590 return resultobj;
10591 fail:
10592 return NULL;
10593 }
10594
10595
10596 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10597 PyObject *resultobj = 0;
10598 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10599 wxString result;
10600 void *argp1 = 0 ;
10601 int res1 = 0 ;
10602 PyObject *swig_obj[1] ;
10603
10604 if (!args) SWIG_fail;
10605 swig_obj[0] = args;
10606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10607 if (!SWIG_IsOK(res1)) {
10608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10609 }
10610 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 #if wxUSE_UNICODE
10619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10620 #else
10621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10622 #endif
10623 }
10624 return resultobj;
10625 fail:
10626 return NULL;
10627 }
10628
10629
10630 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10631 PyObject *resultobj = 0;
10632 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10633 wxString result;
10634 void *argp1 = 0 ;
10635 int res1 = 0 ;
10636 PyObject *swig_obj[1] ;
10637
10638 if (!args) SWIG_fail;
10639 swig_obj[0] = args;
10640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10641 if (!SWIG_IsOK(res1)) {
10642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10643 }
10644 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10645 {
10646 PyThreadState* __tstate = wxPyBeginAllowThreads();
10647 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10648 wxPyEndAllowThreads(__tstate);
10649 if (PyErr_Occurred()) SWIG_fail;
10650 }
10651 {
10652 #if wxUSE_UNICODE
10653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10654 #else
10655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10656 #endif
10657 }
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10665 PyObject *resultobj = 0;
10666 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10667 wxString result;
10668 void *argp1 = 0 ;
10669 int res1 = 0 ;
10670 PyObject *swig_obj[1] ;
10671
10672 if (!args) SWIG_fail;
10673 swig_obj[0] = args;
10674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10677 }
10678 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10679 {
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10682 wxPyEndAllowThreads(__tstate);
10683 if (PyErr_Occurred()) SWIG_fail;
10684 }
10685 {
10686 #if wxUSE_UNICODE
10687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10688 #else
10689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10690 #endif
10691 }
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10699 PyObject *resultobj = 0;
10700 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10701 wxString result;
10702 void *argp1 = 0 ;
10703 int res1 = 0 ;
10704 PyObject *swig_obj[1] ;
10705
10706 if (!args) SWIG_fail;
10707 swig_obj[0] = args;
10708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10709 if (!SWIG_IsOK(res1)) {
10710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10711 }
10712 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 {
10720 #if wxUSE_UNICODE
10721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10722 #else
10723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10724 #endif
10725 }
10726 return resultobj;
10727 fail:
10728 return NULL;
10729 }
10730
10731
10732 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10733 PyObject *resultobj = 0;
10734 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10735 wxString result;
10736 void *argp1 = 0 ;
10737 int res1 = 0 ;
10738 PyObject *swig_obj[1] ;
10739
10740 if (!args) SWIG_fail;
10741 swig_obj[0] = args;
10742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10743 if (!SWIG_IsOK(res1)) {
10744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10745 }
10746 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10747 {
10748 PyThreadState* __tstate = wxPyBeginAllowThreads();
10749 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10750 wxPyEndAllowThreads(__tstate);
10751 if (PyErr_Occurred()) SWIG_fail;
10752 }
10753 {
10754 #if wxUSE_UNICODE
10755 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10756 #else
10757 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10758 #endif
10759 }
10760 return resultobj;
10761 fail:
10762 return NULL;
10763 }
10764
10765
10766 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10767 PyObject *resultobj = 0;
10768 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10769 wxString result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 PyObject *swig_obj[1] ;
10773
10774 if (!args) SWIG_fail;
10775 swig_obj[0] = args;
10776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10777 if (!SWIG_IsOK(res1)) {
10778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10779 }
10780 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10781 {
10782 PyThreadState* __tstate = wxPyBeginAllowThreads();
10783 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 {
10788 #if wxUSE_UNICODE
10789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10790 #else
10791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10792 #endif
10793 }
10794 return resultobj;
10795 fail:
10796 return NULL;
10797 }
10798
10799
10800 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj = 0;
10802 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10803 int arg2 ;
10804 int arg3 ;
10805 void *argp1 = 0 ;
10806 int res1 = 0 ;
10807 int val2 ;
10808 int ecode2 = 0 ;
10809 int val3 ;
10810 int ecode3 = 0 ;
10811 PyObject * obj0 = 0 ;
10812 PyObject * obj1 = 0 ;
10813 PyObject * obj2 = 0 ;
10814 char * kwnames[] = {
10815 (char *) "self",(char *) "major",(char *) "minor", NULL
10816 };
10817
10818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10820 if (!SWIG_IsOK(res1)) {
10821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10822 }
10823 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10824 ecode2 = SWIG_AsVal_int(obj1, &val2);
10825 if (!SWIG_IsOK(ecode2)) {
10826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10827 }
10828 arg2 = static_cast< int >(val2);
10829 ecode3 = SWIG_AsVal_int(obj2, &val3);
10830 if (!SWIG_IsOK(ecode3)) {
10831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10832 }
10833 arg3 = static_cast< int >(val3);
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 (arg1)->SetOSVersion(arg2,arg3);
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_Py_Void();
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj = 0;
10849 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10850 int arg2 ;
10851 int arg3 ;
10852 void *argp1 = 0 ;
10853 int res1 = 0 ;
10854 int val2 ;
10855 int ecode2 = 0 ;
10856 int val3 ;
10857 int ecode3 = 0 ;
10858 PyObject * obj0 = 0 ;
10859 PyObject * obj1 = 0 ;
10860 PyObject * obj2 = 0 ;
10861 char * kwnames[] = {
10862 (char *) "self",(char *) "major",(char *) "minor", NULL
10863 };
10864
10865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10867 if (!SWIG_IsOK(res1)) {
10868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10869 }
10870 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10871 ecode2 = SWIG_AsVal_int(obj1, &val2);
10872 if (!SWIG_IsOK(ecode2)) {
10873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10874 }
10875 arg2 = static_cast< int >(val2);
10876 ecode3 = SWIG_AsVal_int(obj2, &val3);
10877 if (!SWIG_IsOK(ecode3)) {
10878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10879 }
10880 arg3 = static_cast< int >(val3);
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 (arg1)->SetToolkitVersion(arg2,arg3);
10884 wxPyEndAllowThreads(__tstate);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 resultobj = SWIG_Py_Void();
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10895 PyObject *resultobj = 0;
10896 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10897 wxOperatingSystemId arg2 ;
10898 void *argp1 = 0 ;
10899 int res1 = 0 ;
10900 int val2 ;
10901 int ecode2 = 0 ;
10902 PyObject * obj0 = 0 ;
10903 PyObject * obj1 = 0 ;
10904 char * kwnames[] = {
10905 (char *) "self",(char *) "n", NULL
10906 };
10907
10908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10910 if (!SWIG_IsOK(res1)) {
10911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10912 }
10913 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10914 ecode2 = SWIG_AsVal_int(obj1, &val2);
10915 if (!SWIG_IsOK(ecode2)) {
10916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10917 }
10918 arg2 = static_cast< wxOperatingSystemId >(val2);
10919 {
10920 PyThreadState* __tstate = wxPyBeginAllowThreads();
10921 (arg1)->SetOperatingSystemId(arg2);
10922 wxPyEndAllowThreads(__tstate);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 resultobj = SWIG_Py_Void();
10926 return resultobj;
10927 fail:
10928 return NULL;
10929 }
10930
10931
10932 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10933 PyObject *resultobj = 0;
10934 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10935 wxPortId arg2 ;
10936 void *argp1 = 0 ;
10937 int res1 = 0 ;
10938 int val2 ;
10939 int ecode2 = 0 ;
10940 PyObject * obj0 = 0 ;
10941 PyObject * obj1 = 0 ;
10942 char * kwnames[] = {
10943 (char *) "self",(char *) "n", NULL
10944 };
10945
10946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10948 if (!SWIG_IsOK(res1)) {
10949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10950 }
10951 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10952 ecode2 = SWIG_AsVal_int(obj1, &val2);
10953 if (!SWIG_IsOK(ecode2)) {
10954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10955 }
10956 arg2 = static_cast< wxPortId >(val2);
10957 {
10958 PyThreadState* __tstate = wxPyBeginAllowThreads();
10959 (arg1)->SetPortId(arg2);
10960 wxPyEndAllowThreads(__tstate);
10961 if (PyErr_Occurred()) SWIG_fail;
10962 }
10963 resultobj = SWIG_Py_Void();
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10971 PyObject *resultobj = 0;
10972 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10973 wxArchitecture arg2 ;
10974 void *argp1 = 0 ;
10975 int res1 = 0 ;
10976 int val2 ;
10977 int ecode2 = 0 ;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 char * kwnames[] = {
10981 (char *) "self",(char *) "n", NULL
10982 };
10983
10984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10986 if (!SWIG_IsOK(res1)) {
10987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10988 }
10989 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10990 ecode2 = SWIG_AsVal_int(obj1, &val2);
10991 if (!SWIG_IsOK(ecode2)) {
10992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10993 }
10994 arg2 = static_cast< wxArchitecture >(val2);
10995 {
10996 PyThreadState* __tstate = wxPyBeginAllowThreads();
10997 (arg1)->SetArchitecture(arg2);
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 resultobj = SWIG_Py_Void();
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11009 PyObject *resultobj = 0;
11010 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11011 wxEndianness arg2 ;
11012 void *argp1 = 0 ;
11013 int res1 = 0 ;
11014 int val2 ;
11015 int ecode2 = 0 ;
11016 PyObject * obj0 = 0 ;
11017 PyObject * obj1 = 0 ;
11018 char * kwnames[] = {
11019 (char *) "self",(char *) "n", NULL
11020 };
11021
11022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11024 if (!SWIG_IsOK(res1)) {
11025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11026 }
11027 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11028 ecode2 = SWIG_AsVal_int(obj1, &val2);
11029 if (!SWIG_IsOK(ecode2)) {
11030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11031 }
11032 arg2 = static_cast< wxEndianness >(val2);
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 (arg1)->SetEndianness(arg2);
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 resultobj = SWIG_Py_Void();
11040 return resultobj;
11041 fail:
11042 return NULL;
11043 }
11044
11045
11046 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11047 PyObject *resultobj = 0;
11048 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11049 bool result;
11050 void *argp1 = 0 ;
11051 int res1 = 0 ;
11052 PyObject *swig_obj[1] ;
11053
11054 if (!args) SWIG_fail;
11055 swig_obj[0] = args;
11056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11057 if (!SWIG_IsOK(res1)) {
11058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11059 }
11060 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11061 {
11062 PyThreadState* __tstate = wxPyBeginAllowThreads();
11063 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 {
11068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11069 }
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11077 PyObject *obj;
11078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11080 return SWIG_Py_Void();
11081 }
11082
11083 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11084 return SWIG_Python_InitShadowInstance(args);
11085 }
11086
11087 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11088 PyObject *resultobj = 0;
11089 wxWindow *arg1 = (wxWindow *) 0 ;
11090 wxDC *arg2 = 0 ;
11091 bool result;
11092 void *argp1 = 0 ;
11093 int res1 = 0 ;
11094 void *argp2 = 0 ;
11095 int res2 = 0 ;
11096 PyObject * obj0 = 0 ;
11097 PyObject * obj1 = 0 ;
11098 char * kwnames[] = {
11099 (char *) "window",(char *) "dc", NULL
11100 };
11101
11102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11104 if (!SWIG_IsOK(res1)) {
11105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11106 }
11107 arg1 = reinterpret_cast< wxWindow * >(argp1);
11108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11109 if (!SWIG_IsOK(res2)) {
11110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11111 }
11112 if (!argp2) {
11113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11114 }
11115 arg2 = reinterpret_cast< wxDC * >(argp2);
11116 {
11117 PyThreadState* __tstate = wxPyBeginAllowThreads();
11118 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11119 wxPyEndAllowThreads(__tstate);
11120 if (PyErr_Occurred()) SWIG_fail;
11121 }
11122 {
11123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11124 }
11125 return resultobj;
11126 fail:
11127 return NULL;
11128 }
11129
11130
11131 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132 PyObject *resultobj = 0;
11133 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11134 void *argp1 = 0 ;
11135 int res1 = 0 ;
11136 PyObject *swig_obj[1] ;
11137
11138 if (!args) SWIG_fail;
11139 swig_obj[0] = args;
11140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11141 if (!SWIG_IsOK(res1)) {
11142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11143 }
11144 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 delete arg1;
11148
11149 wxPyEndAllowThreads(__tstate);
11150 if (PyErr_Occurred()) SWIG_fail;
11151 }
11152 resultobj = SWIG_Py_Void();
11153 return resultobj;
11154 fail:
11155 return NULL;
11156 }
11157
11158
11159 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11160 PyObject *resultobj = 0;
11161 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11162 wxString result;
11163 void *argp1 = 0 ;
11164 int res1 = 0 ;
11165 PyObject *swig_obj[1] ;
11166
11167 if (!args) SWIG_fail;
11168 swig_obj[0] = args;
11169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11170 if (!SWIG_IsOK(res1)) {
11171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11172 }
11173 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11174 {
11175 PyThreadState* __tstate = wxPyBeginAllowThreads();
11176 result = (arg1)->GetTip();
11177 wxPyEndAllowThreads(__tstate);
11178 if (PyErr_Occurred()) SWIG_fail;
11179 }
11180 {
11181 #if wxUSE_UNICODE
11182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11183 #else
11184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11185 #endif
11186 }
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11194 PyObject *resultobj = 0;
11195 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11196 size_t result;
11197 void *argp1 = 0 ;
11198 int res1 = 0 ;
11199 PyObject *swig_obj[1] ;
11200
11201 if (!args) SWIG_fail;
11202 swig_obj[0] = args;
11203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11204 if (!SWIG_IsOK(res1)) {
11205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11206 }
11207 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11208 {
11209 PyThreadState* __tstate = wxPyBeginAllowThreads();
11210 result = (size_t)(arg1)->GetCurrentTip();
11211 wxPyEndAllowThreads(__tstate);
11212 if (PyErr_Occurred()) SWIG_fail;
11213 }
11214 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj = 0;
11223 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11224 wxString *arg2 = 0 ;
11225 wxString result;
11226 void *argp1 = 0 ;
11227 int res1 = 0 ;
11228 bool temp2 = false ;
11229 PyObject * obj0 = 0 ;
11230 PyObject * obj1 = 0 ;
11231 char * kwnames[] = {
11232 (char *) "self",(char *) "tip", NULL
11233 };
11234
11235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11237 if (!SWIG_IsOK(res1)) {
11238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11239 }
11240 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11241 {
11242 arg2 = wxString_in_helper(obj1);
11243 if (arg2 == NULL) SWIG_fail;
11244 temp2 = true;
11245 }
11246 {
11247 PyThreadState* __tstate = wxPyBeginAllowThreads();
11248 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11249 wxPyEndAllowThreads(__tstate);
11250 if (PyErr_Occurred()) SWIG_fail;
11251 }
11252 {
11253 #if wxUSE_UNICODE
11254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11255 #else
11256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11257 #endif
11258 }
11259 {
11260 if (temp2)
11261 delete arg2;
11262 }
11263 return resultobj;
11264 fail:
11265 {
11266 if (temp2)
11267 delete arg2;
11268 }
11269 return NULL;
11270 }
11271
11272
11273 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11274 PyObject *obj;
11275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11276 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11277 return SWIG_Py_Void();
11278 }
11279
11280 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11281 PyObject *resultobj = 0;
11282 size_t arg1 ;
11283 wxPyTipProvider *result = 0 ;
11284 size_t val1 ;
11285 int ecode1 = 0 ;
11286 PyObject * obj0 = 0 ;
11287 char * kwnames[] = {
11288 (char *) "currentTip", NULL
11289 };
11290
11291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11292 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11293 if (!SWIG_IsOK(ecode1)) {
11294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11295 }
11296 arg1 = static_cast< size_t >(val1);
11297 {
11298 PyThreadState* __tstate = wxPyBeginAllowThreads();
11299 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11300 wxPyEndAllowThreads(__tstate);
11301 if (PyErr_Occurred()) SWIG_fail;
11302 }
11303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11311 PyObject *resultobj = 0;
11312 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11313 PyObject *arg2 = (PyObject *) 0 ;
11314 PyObject *arg3 = (PyObject *) 0 ;
11315 void *argp1 = 0 ;
11316 int res1 = 0 ;
11317 PyObject * obj0 = 0 ;
11318 PyObject * obj1 = 0 ;
11319 PyObject * obj2 = 0 ;
11320 char * kwnames[] = {
11321 (char *) "self",(char *) "self",(char *) "_class", NULL
11322 };
11323
11324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11326 if (!SWIG_IsOK(res1)) {
11327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11328 }
11329 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11330 arg2 = obj1;
11331 arg3 = obj2;
11332 {
11333 PyThreadState* __tstate = wxPyBeginAllowThreads();
11334 (arg1)->_setCallbackInfo(arg2,arg3);
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 resultobj = SWIG_Py_Void();
11339 return resultobj;
11340 fail:
11341 return NULL;
11342 }
11343
11344
11345 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11346 PyObject *obj;
11347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11348 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11349 return SWIG_Py_Void();
11350 }
11351
11352 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11353 return SWIG_Python_InitShadowInstance(args);
11354 }
11355
11356 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxWindow *arg1 = (wxWindow *) 0 ;
11359 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11360 bool arg3 = (bool) true ;
11361 bool result;
11362 void *argp1 = 0 ;
11363 int res1 = 0 ;
11364 void *argp2 = 0 ;
11365 int res2 = 0 ;
11366 bool val3 ;
11367 int ecode3 = 0 ;
11368 PyObject * obj0 = 0 ;
11369 PyObject * obj1 = 0 ;
11370 PyObject * obj2 = 0 ;
11371 char * kwnames[] = {
11372 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11373 };
11374
11375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11377 if (!SWIG_IsOK(res1)) {
11378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11379 }
11380 arg1 = reinterpret_cast< wxWindow * >(argp1);
11381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11382 if (!SWIG_IsOK(res2)) {
11383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11384 }
11385 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11386 if (obj2) {
11387 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11388 if (!SWIG_IsOK(ecode3)) {
11389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11390 }
11391 arg3 = static_cast< bool >(val3);
11392 }
11393 {
11394 if (!wxPyCheckForApp()) SWIG_fail;
11395 PyThreadState* __tstate = wxPyBeginAllowThreads();
11396 result = (bool)wxShowTip(arg1,arg2,arg3);
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 {
11401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj = 0;
11411 wxString *arg1 = 0 ;
11412 size_t arg2 ;
11413 wxTipProvider *result = 0 ;
11414 bool temp1 = false ;
11415 size_t val2 ;
11416 int ecode2 = 0 ;
11417 PyObject * obj0 = 0 ;
11418 PyObject * obj1 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "filename",(char *) "currentTip", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11424 {
11425 arg1 = wxString_in_helper(obj0);
11426 if (arg1 == NULL) SWIG_fail;
11427 temp1 = true;
11428 }
11429 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11430 if (!SWIG_IsOK(ecode2)) {
11431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11432 }
11433 arg2 = static_cast< size_t >(val2);
11434 {
11435 if (!wxPyCheckForApp()) SWIG_fail;
11436 PyThreadState* __tstate = wxPyBeginAllowThreads();
11437 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11438 wxPyEndAllowThreads(__tstate);
11439 if (PyErr_Occurred()) SWIG_fail;
11440 }
11441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11442 {
11443 if (temp1)
11444 delete arg1;
11445 }
11446 return resultobj;
11447 fail:
11448 {
11449 if (temp1)
11450 delete arg1;
11451 }
11452 return NULL;
11453 }
11454
11455
11456 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11457 PyObject *resultobj = 0;
11458 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11459 int arg2 = (int) wxID_ANY ;
11460 wxPyTimer *result = 0 ;
11461 void *argp1 = 0 ;
11462 int res1 = 0 ;
11463 int val2 ;
11464 int ecode2 = 0 ;
11465 PyObject * obj0 = 0 ;
11466 PyObject * obj1 = 0 ;
11467 char * kwnames[] = {
11468 (char *) "owner",(char *) "id", NULL
11469 };
11470
11471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11472 if (obj0) {
11473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11474 if (!SWIG_IsOK(res1)) {
11475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11476 }
11477 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11478 }
11479 if (obj1) {
11480 ecode2 = SWIG_AsVal_int(obj1, &val2);
11481 if (!SWIG_IsOK(ecode2)) {
11482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11483 }
11484 arg2 = static_cast< int >(val2);
11485 }
11486 {
11487 if (!wxPyCheckForApp()) SWIG_fail;
11488 PyThreadState* __tstate = wxPyBeginAllowThreads();
11489 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11490 wxPyEndAllowThreads(__tstate);
11491 if (PyErr_Occurred()) SWIG_fail;
11492 }
11493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11501 PyObject *resultobj = 0;
11502 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11503 void *argp1 = 0 ;
11504 int res1 = 0 ;
11505 PyObject *swig_obj[1] ;
11506
11507 if (!args) SWIG_fail;
11508 swig_obj[0] = args;
11509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11510 if (!SWIG_IsOK(res1)) {
11511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11512 }
11513 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11514 {
11515 PyThreadState* __tstate = wxPyBeginAllowThreads();
11516 delete arg1;
11517
11518 wxPyEndAllowThreads(__tstate);
11519 if (PyErr_Occurred()) SWIG_fail;
11520 }
11521 resultobj = SWIG_Py_Void();
11522 return resultobj;
11523 fail:
11524 return NULL;
11525 }
11526
11527
11528 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11529 PyObject *resultobj = 0;
11530 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11531 PyObject *arg2 = (PyObject *) 0 ;
11532 PyObject *arg3 = (PyObject *) 0 ;
11533 int arg4 = (int) 1 ;
11534 void *argp1 = 0 ;
11535 int res1 = 0 ;
11536 int val4 ;
11537 int ecode4 = 0 ;
11538 PyObject * obj0 = 0 ;
11539 PyObject * obj1 = 0 ;
11540 PyObject * obj2 = 0 ;
11541 PyObject * obj3 = 0 ;
11542 char * kwnames[] = {
11543 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11544 };
11545
11546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11548 if (!SWIG_IsOK(res1)) {
11549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11550 }
11551 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11552 arg2 = obj1;
11553 arg3 = obj2;
11554 if (obj3) {
11555 ecode4 = SWIG_AsVal_int(obj3, &val4);
11556 if (!SWIG_IsOK(ecode4)) {
11557 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11558 }
11559 arg4 = static_cast< int >(val4);
11560 }
11561 {
11562 PyThreadState* __tstate = wxPyBeginAllowThreads();
11563 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 resultobj = SWIG_Py_Void();
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj = 0;
11576 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11577 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11578 int arg3 = (int) wxID_ANY ;
11579 void *argp1 = 0 ;
11580 int res1 = 0 ;
11581 void *argp2 = 0 ;
11582 int res2 = 0 ;
11583 int val3 ;
11584 int ecode3 = 0 ;
11585 PyObject * obj0 = 0 ;
11586 PyObject * obj1 = 0 ;
11587 PyObject * obj2 = 0 ;
11588 char * kwnames[] = {
11589 (char *) "self",(char *) "owner",(char *) "id", NULL
11590 };
11591
11592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11594 if (!SWIG_IsOK(res1)) {
11595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11596 }
11597 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11599 if (!SWIG_IsOK(res2)) {
11600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11601 }
11602 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11603 if (obj2) {
11604 ecode3 = SWIG_AsVal_int(obj2, &val3);
11605 if (!SWIG_IsOK(ecode3)) {
11606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11607 }
11608 arg3 = static_cast< int >(val3);
11609 }
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 (arg1)->SetOwner(arg2,arg3);
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 resultobj = SWIG_Py_Void();
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11624 PyObject *resultobj = 0;
11625 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11626 wxEvtHandler *result = 0 ;
11627 void *argp1 = 0 ;
11628 int res1 = 0 ;
11629 PyObject *swig_obj[1] ;
11630
11631 if (!args) SWIG_fail;
11632 swig_obj[0] = args;
11633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11634 if (!SWIG_IsOK(res1)) {
11635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11636 }
11637 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11638 {
11639 PyThreadState* __tstate = wxPyBeginAllowThreads();
11640 result = (wxEvtHandler *)(arg1)->GetOwner();
11641 wxPyEndAllowThreads(__tstate);
11642 if (PyErr_Occurred()) SWIG_fail;
11643 }
11644 {
11645 resultobj = wxPyMake_wxObject(result, 0);
11646 }
11647 return resultobj;
11648 fail:
11649 return NULL;
11650 }
11651
11652
11653 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11654 PyObject *resultobj = 0;
11655 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11656 int arg2 = (int) -1 ;
11657 bool arg3 = (bool) false ;
11658 bool result;
11659 void *argp1 = 0 ;
11660 int res1 = 0 ;
11661 int val2 ;
11662 int ecode2 = 0 ;
11663 bool val3 ;
11664 int ecode3 = 0 ;
11665 PyObject * obj0 = 0 ;
11666 PyObject * obj1 = 0 ;
11667 PyObject * obj2 = 0 ;
11668 char * kwnames[] = {
11669 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11670 };
11671
11672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11674 if (!SWIG_IsOK(res1)) {
11675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11676 }
11677 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11678 if (obj1) {
11679 ecode2 = SWIG_AsVal_int(obj1, &val2);
11680 if (!SWIG_IsOK(ecode2)) {
11681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11682 }
11683 arg2 = static_cast< int >(val2);
11684 }
11685 if (obj2) {
11686 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11687 if (!SWIG_IsOK(ecode3)) {
11688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11689 }
11690 arg3 = static_cast< bool >(val3);
11691 }
11692 {
11693 PyThreadState* __tstate = wxPyBeginAllowThreads();
11694 result = (bool)(arg1)->Start(arg2,arg3);
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 {
11699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11700 }
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11708 PyObject *resultobj = 0;
11709 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11710 void *argp1 = 0 ;
11711 int res1 = 0 ;
11712 PyObject *swig_obj[1] ;
11713
11714 if (!args) SWIG_fail;
11715 swig_obj[0] = args;
11716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11717 if (!SWIG_IsOK(res1)) {
11718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11719 }
11720 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11721 {
11722 PyThreadState* __tstate = wxPyBeginAllowThreads();
11723 (arg1)->Stop();
11724 wxPyEndAllowThreads(__tstate);
11725 if (PyErr_Occurred()) SWIG_fail;
11726 }
11727 resultobj = SWIG_Py_Void();
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 PyObject *resultobj = 0;
11736 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 PyObject *swig_obj[1] ;
11740
11741 if (!args) SWIG_fail;
11742 swig_obj[0] = args;
11743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11746 }
11747 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 (arg1)->Notify();
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 resultobj = SWIG_Py_Void();
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11762 PyObject *resultobj = 0;
11763 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11764 bool result;
11765 void *argp1 = 0 ;
11766 int res1 = 0 ;
11767 PyObject *swig_obj[1] ;
11768
11769 if (!args) SWIG_fail;
11770 swig_obj[0] = args;
11771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11772 if (!SWIG_IsOK(res1)) {
11773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11774 }
11775 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 {
11783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11784 }
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11792 PyObject *resultobj = 0;
11793 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11794 int result;
11795 void *argp1 = 0 ;
11796 int res1 = 0 ;
11797 PyObject *swig_obj[1] ;
11798
11799 if (!args) SWIG_fail;
11800 swig_obj[0] = args;
11801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11802 if (!SWIG_IsOK(res1)) {
11803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11804 }
11805 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 resultobj = SWIG_From_int(static_cast< int >(result));
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820 PyObject *resultobj = 0;
11821 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11822 int result;
11823 void *argp1 = 0 ;
11824 int res1 = 0 ;
11825 PyObject *swig_obj[1] ;
11826
11827 if (!args) SWIG_fail;
11828 swig_obj[0] = args;
11829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11832 }
11833 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (int)((wxPyTimer const *)arg1)->GetId();
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 resultobj = SWIG_From_int(static_cast< int >(result));
11841 return resultobj;
11842 fail:
11843 return NULL;
11844 }
11845
11846
11847 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11848 PyObject *resultobj = 0;
11849 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11850 bool result;
11851 void *argp1 = 0 ;
11852 int res1 = 0 ;
11853 PyObject *swig_obj[1] ;
11854
11855 if (!args) SWIG_fail;
11856 swig_obj[0] = args;
11857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11858 if (!SWIG_IsOK(res1)) {
11859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11860 }
11861 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11862 {
11863 PyThreadState* __tstate = wxPyBeginAllowThreads();
11864 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 {
11869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11870 }
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11878 PyObject *obj;
11879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11880 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11881 return SWIG_Py_Void();
11882 }
11883
11884 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11885 return SWIG_Python_InitShadowInstance(args);
11886 }
11887
11888 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj = 0;
11890 int arg1 = (int) 0 ;
11891 int arg2 = (int) 0 ;
11892 wxTimerEvent *result = 0 ;
11893 int val1 ;
11894 int ecode1 = 0 ;
11895 int val2 ;
11896 int ecode2 = 0 ;
11897 PyObject * obj0 = 0 ;
11898 PyObject * obj1 = 0 ;
11899 char * kwnames[] = {
11900 (char *) "timerid",(char *) "interval", NULL
11901 };
11902
11903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11904 if (obj0) {
11905 ecode1 = SWIG_AsVal_int(obj0, &val1);
11906 if (!SWIG_IsOK(ecode1)) {
11907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11908 }
11909 arg1 = static_cast< int >(val1);
11910 }
11911 if (obj1) {
11912 ecode2 = SWIG_AsVal_int(obj1, &val2);
11913 if (!SWIG_IsOK(ecode2)) {
11914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11915 }
11916 arg2 = static_cast< int >(val2);
11917 }
11918 {
11919 PyThreadState* __tstate = wxPyBeginAllowThreads();
11920 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11932 PyObject *resultobj = 0;
11933 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11934 int result;
11935 void *argp1 = 0 ;
11936 int res1 = 0 ;
11937 PyObject *swig_obj[1] ;
11938
11939 if (!args) SWIG_fail;
11940 swig_obj[0] = args;
11941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11942 if (!SWIG_IsOK(res1)) {
11943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11944 }
11945 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11946 {
11947 PyThreadState* __tstate = wxPyBeginAllowThreads();
11948 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11949 wxPyEndAllowThreads(__tstate);
11950 if (PyErr_Occurred()) SWIG_fail;
11951 }
11952 resultobj = SWIG_From_int(static_cast< int >(result));
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11960 PyObject *obj;
11961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11962 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11963 return SWIG_Py_Void();
11964 }
11965
11966 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11967 return SWIG_Python_InitShadowInstance(args);
11968 }
11969
11970 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11971 PyObject *resultobj = 0;
11972 wxTimer *arg1 = 0 ;
11973 wxTimerRunner *result = 0 ;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976
11977 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11979 if (!SWIG_IsOK(res1)) {
11980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11981 }
11982 if (!argp1) {
11983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11984 }
11985 arg1 = reinterpret_cast< wxTimer * >(argp1);
11986 {
11987 if (!wxPyCheckForApp()) SWIG_fail;
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12001 PyObject *resultobj = 0;
12002 wxTimer *arg1 = 0 ;
12003 int arg2 ;
12004 bool arg3 = (bool) false ;
12005 wxTimerRunner *result = 0 ;
12006 void *argp1 = 0 ;
12007 int res1 = 0 ;
12008 int val2 ;
12009 int ecode2 = 0 ;
12010 bool val3 ;
12011 int ecode3 = 0 ;
12012
12013 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12015 if (!SWIG_IsOK(res1)) {
12016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12017 }
12018 if (!argp1) {
12019 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12020 }
12021 arg1 = reinterpret_cast< wxTimer * >(argp1);
12022 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12023 if (!SWIG_IsOK(ecode2)) {
12024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12025 }
12026 arg2 = static_cast< int >(val2);
12027 if (swig_obj[2]) {
12028 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12029 if (!SWIG_IsOK(ecode3)) {
12030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12031 }
12032 arg3 = static_cast< bool >(val3);
12033 }
12034 {
12035 if (!wxPyCheckForApp()) SWIG_fail;
12036 PyThreadState* __tstate = wxPyBeginAllowThreads();
12037 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12038 wxPyEndAllowThreads(__tstate);
12039 if (PyErr_Occurred()) SWIG_fail;
12040 }
12041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12042 return resultobj;
12043 fail:
12044 return NULL;
12045 }
12046
12047
12048 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12049 int argc;
12050 PyObject *argv[4];
12051
12052 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12053 --argc;
12054 if (argc == 1) {
12055 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12056 }
12057 if ((argc >= 2) && (argc <= 3)) {
12058 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12059 }
12060
12061 fail:
12062 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12063 return NULL;
12064 }
12065
12066
12067 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12068 PyObject *resultobj = 0;
12069 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12070 void *argp1 = 0 ;
12071 int res1 = 0 ;
12072 PyObject *swig_obj[1] ;
12073
12074 if (!args) SWIG_fail;
12075 swig_obj[0] = args;
12076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12077 if (!SWIG_IsOK(res1)) {
12078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12079 }
12080 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12081 {
12082 PyThreadState* __tstate = wxPyBeginAllowThreads();
12083 delete arg1;
12084
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 resultobj = SWIG_Py_Void();
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12096 PyObject *resultobj = 0;
12097 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12098 int arg2 ;
12099 bool arg3 = (bool) false ;
12100 void *argp1 = 0 ;
12101 int res1 = 0 ;
12102 int val2 ;
12103 int ecode2 = 0 ;
12104 bool val3 ;
12105 int ecode3 = 0 ;
12106 PyObject * obj0 = 0 ;
12107 PyObject * obj1 = 0 ;
12108 PyObject * obj2 = 0 ;
12109 char * kwnames[] = {
12110 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12111 };
12112
12113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12115 if (!SWIG_IsOK(res1)) {
12116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12117 }
12118 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12119 ecode2 = SWIG_AsVal_int(obj1, &val2);
12120 if (!SWIG_IsOK(ecode2)) {
12121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12122 }
12123 arg2 = static_cast< int >(val2);
12124 if (obj2) {
12125 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12126 if (!SWIG_IsOK(ecode3)) {
12127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12128 }
12129 arg3 = static_cast< bool >(val3);
12130 }
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 (arg1)->Start(arg2,arg3);
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 resultobj = SWIG_Py_Void();
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *obj;
12146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12147 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12148 return SWIG_Py_Void();
12149 }
12150
12151 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152 return SWIG_Python_InitShadowInstance(args);
12153 }
12154
12155 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12156 PyObject *resultobj = 0;
12157 wxLog *result = 0 ;
12158
12159 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12160 {
12161 PyThreadState* __tstate = wxPyBeginAllowThreads();
12162 result = (wxLog *)new wxLog();
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12167 return resultobj;
12168 fail:
12169 return NULL;
12170 }
12171
12172
12173 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12174 PyObject *resultobj = 0;
12175 wxLog *arg1 = (wxLog *) 0 ;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 PyObject *swig_obj[1] ;
12179
12180 if (!args) SWIG_fail;
12181 swig_obj[0] = args;
12182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12183 if (!SWIG_IsOK(res1)) {
12184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12185 }
12186 arg1 = reinterpret_cast< wxLog * >(argp1);
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 delete arg1;
12190
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 resultobj = SWIG_Py_Void();
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12202 PyObject *resultobj = 0;
12203 bool result;
12204
12205 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 result = (bool)wxLog::IsEnabled();
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 {
12213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12214 }
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj = 0;
12223 bool arg1 = (bool) true ;
12224 bool result;
12225 bool val1 ;
12226 int ecode1 = 0 ;
12227 PyObject * obj0 = 0 ;
12228 char * kwnames[] = {
12229 (char *) "doIt", NULL
12230 };
12231
12232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12233 if (obj0) {
12234 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12235 if (!SWIG_IsOK(ecode1)) {
12236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12237 }
12238 arg1 = static_cast< bool >(val1);
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 result = (bool)wxLog::EnableLogging(arg1);
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 {
12247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj = 0;
12257 wxLogLevel arg1 ;
12258 wxChar *arg2 = (wxChar *) 0 ;
12259 time_t arg3 ;
12260 unsigned long val1 ;
12261 int ecode1 = 0 ;
12262 void *argp2 = 0 ;
12263 int res2 = 0 ;
12264 unsigned int val3 ;
12265 int ecode3 = 0 ;
12266 PyObject * obj0 = 0 ;
12267 PyObject * obj1 = 0 ;
12268 PyObject * obj2 = 0 ;
12269 char * kwnames[] = {
12270 (char *) "level",(char *) "szString",(char *) "t", NULL
12271 };
12272
12273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12274 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12275 if (!SWIG_IsOK(ecode1)) {
12276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12277 }
12278 arg1 = static_cast< wxLogLevel >(val1);
12279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12280 if (!SWIG_IsOK(res2)) {
12281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12282 }
12283 arg2 = reinterpret_cast< wxChar * >(argp2);
12284 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12285 if (!SWIG_IsOK(ecode3)) {
12286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12287 }
12288 arg3 = static_cast< time_t >(val3);
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = SWIG_Py_Void();
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12303 PyObject *resultobj = 0;
12304 wxLog *arg1 = (wxLog *) 0 ;
12305 void *argp1 = 0 ;
12306 int res1 = 0 ;
12307 PyObject *swig_obj[1] ;
12308
12309 if (!args) SWIG_fail;
12310 swig_obj[0] = args;
12311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12312 if (!SWIG_IsOK(res1)) {
12313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12314 }
12315 arg1 = reinterpret_cast< wxLog * >(argp1);
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 (arg1)->Flush();
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 resultobj = SWIG_Py_Void();
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12330 PyObject *resultobj = 0;
12331
12332 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 wxLog::FlushActive();
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_Py_Void();
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12347 PyObject *resultobj = 0;
12348 wxLog *result = 0 ;
12349
12350 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (wxLog *)wxLog::GetActiveTarget();
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12358 return resultobj;
12359 fail:
12360 return NULL;
12361 }
12362
12363
12364 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12365 PyObject *resultobj = 0;
12366 wxLog *arg1 = (wxLog *) 0 ;
12367 wxLog *result = 0 ;
12368 int res1 = 0 ;
12369 PyObject * obj0 = 0 ;
12370 char * kwnames[] = {
12371 (char *) "pLogger", NULL
12372 };
12373
12374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12375 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12376 if (!SWIG_IsOK(res1)) {
12377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12378 }
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12386 return resultobj;
12387 fail:
12388 return NULL;
12389 }
12390
12391
12392 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12393 PyObject *resultobj = 0;
12394
12395 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 wxLog::Suspend();
12399 wxPyEndAllowThreads(__tstate);
12400 if (PyErr_Occurred()) SWIG_fail;
12401 }
12402 resultobj = SWIG_Py_Void();
12403 return resultobj;
12404 fail:
12405 return NULL;
12406 }
12407
12408
12409 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12410 PyObject *resultobj = 0;
12411
12412 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12413 {
12414 PyThreadState* __tstate = wxPyBeginAllowThreads();
12415 wxLog::Resume();
12416 wxPyEndAllowThreads(__tstate);
12417 if (PyErr_Occurred()) SWIG_fail;
12418 }
12419 resultobj = SWIG_Py_Void();
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12427 PyObject *resultobj = 0;
12428 bool arg1 = (bool) true ;
12429 bool val1 ;
12430 int ecode1 = 0 ;
12431 PyObject * obj0 = 0 ;
12432 char * kwnames[] = {
12433 (char *) "bVerbose", NULL
12434 };
12435
12436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12437 if (obj0) {
12438 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12439 if (!SWIG_IsOK(ecode1)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12441 }
12442 arg1 = static_cast< bool >(val1);
12443 }
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 wxLog::SetVerbose(arg1);
12447 wxPyEndAllowThreads(__tstate);
12448 if (PyErr_Occurred()) SWIG_fail;
12449 }
12450 resultobj = SWIG_Py_Void();
12451 return resultobj;
12452 fail:
12453 return NULL;
12454 }
12455
12456
12457 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12458 PyObject *resultobj = 0;
12459 wxLogLevel arg1 ;
12460 unsigned long val1 ;
12461 int ecode1 = 0 ;
12462 PyObject * obj0 = 0 ;
12463 char * kwnames[] = {
12464 (char *) "logLevel", NULL
12465 };
12466
12467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12468 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12469 if (!SWIG_IsOK(ecode1)) {
12470 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12471 }
12472 arg1 = static_cast< wxLogLevel >(val1);
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 wxLog::SetLogLevel(arg1);
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 resultobj = SWIG_Py_Void();
12480 return resultobj;
12481 fail:
12482 return NULL;
12483 }
12484
12485
12486 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12487 PyObject *resultobj = 0;
12488
12489 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 wxLog::DontCreateOnDemand();
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 resultobj = SWIG_Py_Void();
12497 return resultobj;
12498 fail:
12499 return NULL;
12500 }
12501
12502
12503 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12504 PyObject *resultobj = 0;
12505 bool arg1 = (bool) true ;
12506 bool val1 ;
12507 int ecode1 = 0 ;
12508 PyObject * obj0 = 0 ;
12509 char * kwnames[] = {
12510 (char *) "bRepetCounting", NULL
12511 };
12512
12513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12514 if (obj0) {
12515 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12516 if (!SWIG_IsOK(ecode1)) {
12517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12518 }
12519 arg1 = static_cast< bool >(val1);
12520 }
12521 {
12522 PyThreadState* __tstate = wxPyBeginAllowThreads();
12523 wxLog::SetRepetitionCounting(arg1);
12524 wxPyEndAllowThreads(__tstate);
12525 if (PyErr_Occurred()) SWIG_fail;
12526 }
12527 resultobj = SWIG_Py_Void();
12528 return resultobj;
12529 fail:
12530 return NULL;
12531 }
12532
12533
12534 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12535 PyObject *resultobj = 0;
12536 bool result;
12537
12538 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 result = (bool)wxLog::GetRepetitionCounting();
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 {
12546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12547 }
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj = 0;
12556 wxTraceMask arg1 ;
12557 unsigned long val1 ;
12558 int ecode1 = 0 ;
12559 PyObject * obj0 = 0 ;
12560 char * kwnames[] = {
12561 (char *) "ulMask", NULL
12562 };
12563
12564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12565 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12566 if (!SWIG_IsOK(ecode1)) {
12567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12568 }
12569 arg1 = static_cast< wxTraceMask >(val1);
12570 {
12571 PyThreadState* __tstate = wxPyBeginAllowThreads();
12572 wxLog::SetTraceMask(arg1);
12573 wxPyEndAllowThreads(__tstate);
12574 if (PyErr_Occurred()) SWIG_fail;
12575 }
12576 resultobj = SWIG_Py_Void();
12577 return resultobj;
12578 fail:
12579 return NULL;
12580 }
12581
12582
12583 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj = 0;
12585 wxString *arg1 = 0 ;
12586 bool temp1 = false ;
12587 PyObject * obj0 = 0 ;
12588 char * kwnames[] = {
12589 (char *) "str", NULL
12590 };
12591
12592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12593 {
12594 arg1 = wxString_in_helper(obj0);
12595 if (arg1 == NULL) SWIG_fail;
12596 temp1 = true;
12597 }
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 wxLog::AddTraceMask((wxString const &)*arg1);
12601 wxPyEndAllowThreads(__tstate);
12602 if (PyErr_Occurred()) SWIG_fail;
12603 }
12604 resultobj = SWIG_Py_Void();
12605 {
12606 if (temp1)
12607 delete arg1;
12608 }
12609 return resultobj;
12610 fail:
12611 {
12612 if (temp1)
12613 delete arg1;
12614 }
12615 return NULL;
12616 }
12617
12618
12619 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj = 0;
12621 wxString *arg1 = 0 ;
12622 bool temp1 = false ;
12623 PyObject * obj0 = 0 ;
12624 char * kwnames[] = {
12625 (char *) "str", NULL
12626 };
12627
12628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12629 {
12630 arg1 = wxString_in_helper(obj0);
12631 if (arg1 == NULL) SWIG_fail;
12632 temp1 = true;
12633 }
12634 {
12635 PyThreadState* __tstate = wxPyBeginAllowThreads();
12636 wxLog::RemoveTraceMask((wxString const &)*arg1);
12637 wxPyEndAllowThreads(__tstate);
12638 if (PyErr_Occurred()) SWIG_fail;
12639 }
12640 resultobj = SWIG_Py_Void();
12641 {
12642 if (temp1)
12643 delete arg1;
12644 }
12645 return resultobj;
12646 fail:
12647 {
12648 if (temp1)
12649 delete arg1;
12650 }
12651 return NULL;
12652 }
12653
12654
12655 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12656 PyObject *resultobj = 0;
12657
12658 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 wxLog::ClearTraceMasks();
12662 wxPyEndAllowThreads(__tstate);
12663 if (PyErr_Occurred()) SWIG_fail;
12664 }
12665 resultobj = SWIG_Py_Void();
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12673 PyObject *resultobj = 0;
12674 wxArrayString *result = 0 ;
12675
12676 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12677 {
12678 PyThreadState* __tstate = wxPyBeginAllowThreads();
12679 {
12680 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12681 result = (wxArrayString *) &_result_ref;
12682 }
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 resultobj = wxArrayString2PyList_helper(*result);
12688 }
12689 return resultobj;
12690 fail:
12691 return NULL;
12692 }
12693
12694
12695 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12696 PyObject *resultobj = 0;
12697 wxChar *arg1 = (wxChar *) 0 ;
12698 void *argp1 = 0 ;
12699 int res1 = 0 ;
12700 PyObject * obj0 = 0 ;
12701 char * kwnames[] = {
12702 (char *) "ts", NULL
12703 };
12704
12705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12707 if (!SWIG_IsOK(res1)) {
12708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12709 }
12710 arg1 = reinterpret_cast< wxChar * >(argp1);
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 wxLog::SetTimestamp((wxChar const *)arg1);
12714 wxPyEndAllowThreads(__tstate);
12715 if (PyErr_Occurred()) SWIG_fail;
12716 }
12717 resultobj = SWIG_Py_Void();
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12725 PyObject *resultobj = 0;
12726 bool result;
12727
12728 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12729 {
12730 PyThreadState* __tstate = wxPyBeginAllowThreads();
12731 result = (bool)wxLog::GetVerbose();
12732 wxPyEndAllowThreads(__tstate);
12733 if (PyErr_Occurred()) SWIG_fail;
12734 }
12735 {
12736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12737 }
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12745 PyObject *resultobj = 0;
12746 wxTraceMask result;
12747
12748 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 result = (wxTraceMask)wxLog::GetTraceMask();
12752 wxPyEndAllowThreads(__tstate);
12753 if (PyErr_Occurred()) SWIG_fail;
12754 }
12755 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12756 return resultobj;
12757 fail:
12758 return NULL;
12759 }
12760
12761
12762 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12763 PyObject *resultobj = 0;
12764 wxChar *arg1 = (wxChar *) 0 ;
12765 bool result;
12766 void *argp1 = 0 ;
12767 int res1 = 0 ;
12768 PyObject * obj0 = 0 ;
12769 char * kwnames[] = {
12770 (char *) "mask", NULL
12771 };
12772
12773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12775 if (!SWIG_IsOK(res1)) {
12776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12777 }
12778 arg1 = reinterpret_cast< wxChar * >(argp1);
12779 {
12780 PyThreadState* __tstate = wxPyBeginAllowThreads();
12781 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12782 wxPyEndAllowThreads(__tstate);
12783 if (PyErr_Occurred()) SWIG_fail;
12784 }
12785 {
12786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12787 }
12788 return resultobj;
12789 fail:
12790 return NULL;
12791 }
12792
12793
12794 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12795 PyObject *resultobj = 0;
12796 wxLogLevel result;
12797
12798 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (wxLogLevel)wxLog::GetLogLevel();
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12813 PyObject *resultobj = 0;
12814 wxChar *result = 0 ;
12815
12816 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 result = (wxChar *)wxLog::GetTimestamp();
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12824 return resultobj;
12825 fail:
12826 return NULL;
12827 }
12828
12829
12830 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12831 PyObject *resultobj = 0;
12832 wxString result;
12833
12834 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12835 {
12836 PyThreadState* __tstate = wxPyBeginAllowThreads();
12837 result = wxLog_TimeStamp();
12838 wxPyEndAllowThreads(__tstate);
12839 if (PyErr_Occurred()) SWIG_fail;
12840 }
12841 {
12842 #if wxUSE_UNICODE
12843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12844 #else
12845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12846 #endif
12847 }
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 PyObject *resultobj = 0;
12856 wxLog *arg1 = (wxLog *) 0 ;
12857 void *argp1 = 0 ;
12858 int res1 = 0 ;
12859 PyObject *swig_obj[1] ;
12860
12861 if (!args) SWIG_fail;
12862 swig_obj[0] = args;
12863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12864 if (!SWIG_IsOK(res1)) {
12865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12866 }
12867 arg1 = reinterpret_cast< wxLog * >(argp1);
12868 {
12869 PyThreadState* __tstate = wxPyBeginAllowThreads();
12870 wxLog_Destroy(arg1);
12871 wxPyEndAllowThreads(__tstate);
12872 if (PyErr_Occurred()) SWIG_fail;
12873 }
12874 resultobj = SWIG_Py_Void();
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 PyObject *obj;
12883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12884 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12885 return SWIG_Py_Void();
12886 }
12887
12888 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12889 return SWIG_Python_InitShadowInstance(args);
12890 }
12891
12892 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12893 PyObject *resultobj = 0;
12894 wxLogStderr *result = 0 ;
12895
12896 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12897 {
12898 PyThreadState* __tstate = wxPyBeginAllowThreads();
12899 result = (wxLogStderr *)new wxLogStderr();
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12911 PyObject *obj;
12912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12913 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12914 return SWIG_Py_Void();
12915 }
12916
12917 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12918 return SWIG_Python_InitShadowInstance(args);
12919 }
12920
12921 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12922 PyObject *resultobj = 0;
12923 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12924 wxLogTextCtrl *result = 0 ;
12925 void *argp1 = 0 ;
12926 int res1 = 0 ;
12927 PyObject * obj0 = 0 ;
12928 char * kwnames[] = {
12929 (char *) "pTextCtrl", NULL
12930 };
12931
12932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12934 if (!SWIG_IsOK(res1)) {
12935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12936 }
12937 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12938 {
12939 PyThreadState* __tstate = wxPyBeginAllowThreads();
12940 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12941 wxPyEndAllowThreads(__tstate);
12942 if (PyErr_Occurred()) SWIG_fail;
12943 }
12944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12945 return resultobj;
12946 fail:
12947 return NULL;
12948 }
12949
12950
12951 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12952 PyObject *obj;
12953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12954 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12955 return SWIG_Py_Void();
12956 }
12957
12958 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12959 return SWIG_Python_InitShadowInstance(args);
12960 }
12961
12962 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 PyObject *resultobj = 0;
12964 wxLogGui *result = 0 ;
12965
12966 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (wxLogGui *)new wxLogGui();
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12974 return resultobj;
12975 fail:
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12981 PyObject *obj;
12982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12983 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12984 return SWIG_Py_Void();
12985 }
12986
12987 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12988 return SWIG_Python_InitShadowInstance(args);
12989 }
12990
12991 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj = 0;
12993 wxFrame *arg1 = (wxFrame *) 0 ;
12994 wxString *arg2 = 0 ;
12995 bool arg3 = (bool) true ;
12996 bool arg4 = (bool) true ;
12997 wxLogWindow *result = 0 ;
12998 void *argp1 = 0 ;
12999 int res1 = 0 ;
13000 bool temp2 = false ;
13001 bool val3 ;
13002 int ecode3 = 0 ;
13003 bool val4 ;
13004 int ecode4 = 0 ;
13005 PyObject * obj0 = 0 ;
13006 PyObject * obj1 = 0 ;
13007 PyObject * obj2 = 0 ;
13008 PyObject * obj3 = 0 ;
13009 char * kwnames[] = {
13010 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13011 };
13012
13013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13015 if (!SWIG_IsOK(res1)) {
13016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13017 }
13018 arg1 = reinterpret_cast< wxFrame * >(argp1);
13019 {
13020 arg2 = wxString_in_helper(obj1);
13021 if (arg2 == NULL) SWIG_fail;
13022 temp2 = true;
13023 }
13024 if (obj2) {
13025 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13026 if (!SWIG_IsOK(ecode3)) {
13027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13028 }
13029 arg3 = static_cast< bool >(val3);
13030 }
13031 if (obj3) {
13032 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13033 if (!SWIG_IsOK(ecode4)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13035 }
13036 arg4 = static_cast< bool >(val4);
13037 }
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13045 {
13046 if (temp2)
13047 delete arg2;
13048 }
13049 return resultobj;
13050 fail:
13051 {
13052 if (temp2)
13053 delete arg2;
13054 }
13055 return NULL;
13056 }
13057
13058
13059 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj = 0;
13061 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13062 bool arg2 = (bool) true ;
13063 void *argp1 = 0 ;
13064 int res1 = 0 ;
13065 bool val2 ;
13066 int ecode2 = 0 ;
13067 PyObject * obj0 = 0 ;
13068 PyObject * obj1 = 0 ;
13069 char * kwnames[] = {
13070 (char *) "self",(char *) "bShow", NULL
13071 };
13072
13073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13075 if (!SWIG_IsOK(res1)) {
13076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13077 }
13078 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13079 if (obj1) {
13080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13081 if (!SWIG_IsOK(ecode2)) {
13082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13083 }
13084 arg2 = static_cast< bool >(val2);
13085 }
13086 {
13087 PyThreadState* __tstate = wxPyBeginAllowThreads();
13088 (arg1)->Show(arg2);
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 resultobj = SWIG_Py_Void();
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13100 PyObject *resultobj = 0;
13101 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13102 wxFrame *result = 0 ;
13103 void *argp1 = 0 ;
13104 int res1 = 0 ;
13105 PyObject *swig_obj[1] ;
13106
13107 if (!args) SWIG_fail;
13108 swig_obj[0] = args;
13109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13110 if (!SWIG_IsOK(res1)) {
13111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13112 }
13113 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 {
13121 resultobj = wxPyMake_wxObject(result, (bool)0);
13122 }
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13130 PyObject *resultobj = 0;
13131 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13132 wxLog *result = 0 ;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 PyObject *swig_obj[1] ;
13136
13137 if (!args) SWIG_fail;
13138 swig_obj[0] = args;
13139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13140 if (!SWIG_IsOK(res1)) {
13141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13142 }
13143 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13144 {
13145 PyThreadState* __tstate = wxPyBeginAllowThreads();
13146 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13151 return resultobj;
13152 fail:
13153 return NULL;
13154 }
13155
13156
13157 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13158 PyObject *resultobj = 0;
13159 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13160 bool result;
13161 void *argp1 = 0 ;
13162 int res1 = 0 ;
13163 PyObject *swig_obj[1] ;
13164
13165 if (!args) SWIG_fail;
13166 swig_obj[0] = args;
13167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13168 if (!SWIG_IsOK(res1)) {
13169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13170 }
13171 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 {
13179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13180 }
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj = 0;
13189 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13190 bool arg2 ;
13191 void *argp1 = 0 ;
13192 int res1 = 0 ;
13193 bool val2 ;
13194 int ecode2 = 0 ;
13195 PyObject * obj0 = 0 ;
13196 PyObject * obj1 = 0 ;
13197 char * kwnames[] = {
13198 (char *) "self",(char *) "bDoPass", NULL
13199 };
13200
13201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13203 if (!SWIG_IsOK(res1)) {
13204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13205 }
13206 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13208 if (!SWIG_IsOK(ecode2)) {
13209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13210 }
13211 arg2 = static_cast< bool >(val2);
13212 {
13213 PyThreadState* __tstate = wxPyBeginAllowThreads();
13214 (arg1)->PassMessages(arg2);
13215 wxPyEndAllowThreads(__tstate);
13216 if (PyErr_Occurred()) SWIG_fail;
13217 }
13218 resultobj = SWIG_Py_Void();
13219 return resultobj;
13220 fail:
13221 return NULL;
13222 }
13223
13224
13225 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13226 PyObject *obj;
13227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13228 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13229 return SWIG_Py_Void();
13230 }
13231
13232 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13233 return SWIG_Python_InitShadowInstance(args);
13234 }
13235
13236 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13237 PyObject *resultobj = 0;
13238 wxLog *arg1 = (wxLog *) 0 ;
13239 wxLogChain *result = 0 ;
13240 void *argp1 = 0 ;
13241 int res1 = 0 ;
13242 PyObject * obj0 = 0 ;
13243 char * kwnames[] = {
13244 (char *) "logger", NULL
13245 };
13246
13247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13249 if (!SWIG_IsOK(res1)) {
13250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13251 }
13252 arg1 = reinterpret_cast< wxLog * >(argp1);
13253 {
13254 PyThreadState* __tstate = wxPyBeginAllowThreads();
13255 result = (wxLogChain *)new wxLogChain(arg1);
13256 wxPyEndAllowThreads(__tstate);
13257 if (PyErr_Occurred()) SWIG_fail;
13258 }
13259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj = 0;
13268 wxLogChain *arg1 = (wxLogChain *) 0 ;
13269 wxLog *arg2 = (wxLog *) 0 ;
13270 void *argp1 = 0 ;
13271 int res1 = 0 ;
13272 void *argp2 = 0 ;
13273 int res2 = 0 ;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 char * kwnames[] = {
13277 (char *) "self",(char *) "logger", NULL
13278 };
13279
13280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13282 if (!SWIG_IsOK(res1)) {
13283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13284 }
13285 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13287 if (!SWIG_IsOK(res2)) {
13288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13289 }
13290 arg2 = reinterpret_cast< wxLog * >(argp2);
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 (arg1)->SetLog(arg2);
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 resultobj = SWIG_Py_Void();
13298 return resultobj;
13299 fail:
13300 return NULL;
13301 }
13302
13303
13304 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13305 PyObject *resultobj = 0;
13306 wxLogChain *arg1 = (wxLogChain *) 0 ;
13307 bool arg2 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 bool val2 ;
13311 int ecode2 = 0 ;
13312 PyObject * obj0 = 0 ;
13313 PyObject * obj1 = 0 ;
13314 char * kwnames[] = {
13315 (char *) "self",(char *) "bDoPass", NULL
13316 };
13317
13318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13320 if (!SWIG_IsOK(res1)) {
13321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13322 }
13323 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13324 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13325 if (!SWIG_IsOK(ecode2)) {
13326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13327 }
13328 arg2 = static_cast< bool >(val2);
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 (arg1)->PassMessages(arg2);
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 resultobj = SWIG_Py_Void();
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13343 PyObject *resultobj = 0;
13344 wxLogChain *arg1 = (wxLogChain *) 0 ;
13345 bool result;
13346 void *argp1 = 0 ;
13347 int res1 = 0 ;
13348 PyObject *swig_obj[1] ;
13349
13350 if (!args) SWIG_fail;
13351 swig_obj[0] = args;
13352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13353 if (!SWIG_IsOK(res1)) {
13354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13355 }
13356 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13357 {
13358 PyThreadState* __tstate = wxPyBeginAllowThreads();
13359 result = (bool)(arg1)->IsPassingMessages();
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 {
13364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13365 }
13366 return resultobj;
13367 fail:
13368 return NULL;
13369 }
13370
13371
13372 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13373 PyObject *resultobj = 0;
13374 wxLogChain *arg1 = (wxLogChain *) 0 ;
13375 wxLog *result = 0 ;
13376 void *argp1 = 0 ;
13377 int res1 = 0 ;
13378 PyObject *swig_obj[1] ;
13379
13380 if (!args) SWIG_fail;
13381 swig_obj[0] = args;
13382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13383 if (!SWIG_IsOK(res1)) {
13384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13385 }
13386 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13387 {
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 result = (wxLog *)(arg1)->GetOldLog();
13390 wxPyEndAllowThreads(__tstate);
13391 if (PyErr_Occurred()) SWIG_fail;
13392 }
13393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13394 return resultobj;
13395 fail:
13396 return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13401 PyObject *obj;
13402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13403 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13404 return SWIG_Py_Void();
13405 }
13406
13407 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13408 return SWIG_Python_InitShadowInstance(args);
13409 }
13410
13411 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13412 PyObject *resultobj = 0;
13413 wxLogBuffer *result = 0 ;
13414
13415 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13416 {
13417 PyThreadState* __tstate = wxPyBeginAllowThreads();
13418 result = (wxLogBuffer *)new wxLogBuffer();
13419 wxPyEndAllowThreads(__tstate);
13420 if (PyErr_Occurred()) SWIG_fail;
13421 }
13422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13423 return resultobj;
13424 fail:
13425 return NULL;
13426 }
13427
13428
13429 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13430 PyObject *resultobj = 0;
13431 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13432 wxString *result = 0 ;
13433 void *argp1 = 0 ;
13434 int res1 = 0 ;
13435 PyObject *swig_obj[1] ;
13436
13437 if (!args) SWIG_fail;
13438 swig_obj[0] = args;
13439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13440 if (!SWIG_IsOK(res1)) {
13441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13442 }
13443 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13444 {
13445 PyThreadState* __tstate = wxPyBeginAllowThreads();
13446 {
13447 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13448 result = (wxString *) &_result_ref;
13449 }
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 {
13454 #if wxUSE_UNICODE
13455 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13456 #else
13457 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13458 #endif
13459 }
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13467 PyObject *obj;
13468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13469 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13470 return SWIG_Py_Void();
13471 }
13472
13473 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13474 return SWIG_Python_InitShadowInstance(args);
13475 }
13476
13477 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13478 PyObject *resultobj = 0;
13479 unsigned long result;
13480
13481 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = (unsigned long)wxSysErrorCode();
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13489 return resultobj;
13490 fail:
13491 return NULL;
13492 }
13493
13494
13495 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13496 PyObject *resultobj = 0;
13497 unsigned long arg1 = (unsigned long) 0 ;
13498 wxString result;
13499 unsigned long val1 ;
13500 int ecode1 = 0 ;
13501 PyObject * obj0 = 0 ;
13502 char * kwnames[] = {
13503 (char *) "nErrCode", NULL
13504 };
13505
13506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13507 if (obj0) {
13508 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13509 if (!SWIG_IsOK(ecode1)) {
13510 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13511 }
13512 arg1 = static_cast< unsigned long >(val1);
13513 }
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = wxSysErrorMsg(arg1);
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 {
13521 #if wxUSE_UNICODE
13522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13523 #else
13524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13525 #endif
13526 }
13527 return resultobj;
13528 fail:
13529 return NULL;
13530 }
13531
13532
13533 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13534 PyObject *resultobj = 0;
13535 wxString *arg1 = 0 ;
13536 bool temp1 = false ;
13537 PyObject * obj0 = 0 ;
13538 char * kwnames[] = {
13539 (char *) "msg", NULL
13540 };
13541
13542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13543 {
13544 arg1 = wxString_in_helper(obj0);
13545 if (arg1 == NULL) SWIG_fail;
13546 temp1 = true;
13547 }
13548 {
13549 PyThreadState* __tstate = wxPyBeginAllowThreads();
13550 wxPyLogFatalError((wxString const &)*arg1);
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 resultobj = SWIG_Py_Void();
13555 {
13556 if (temp1)
13557 delete arg1;
13558 }
13559 return resultobj;
13560 fail:
13561 {
13562 if (temp1)
13563 delete arg1;
13564 }
13565 return NULL;
13566 }
13567
13568
13569 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj = 0;
13571 wxString *arg1 = 0 ;
13572 bool temp1 = false ;
13573 PyObject * obj0 = 0 ;
13574 char * kwnames[] = {
13575 (char *) "msg", NULL
13576 };
13577
13578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13579 {
13580 arg1 = wxString_in_helper(obj0);
13581 if (arg1 == NULL) SWIG_fail;
13582 temp1 = true;
13583 }
13584 {
13585 PyThreadState* __tstate = wxPyBeginAllowThreads();
13586 wxPyLogError((wxString const &)*arg1);
13587 wxPyEndAllowThreads(__tstate);
13588 if (PyErr_Occurred()) SWIG_fail;
13589 }
13590 resultobj = SWIG_Py_Void();
13591 {
13592 if (temp1)
13593 delete arg1;
13594 }
13595 return resultobj;
13596 fail:
13597 {
13598 if (temp1)
13599 delete arg1;
13600 }
13601 return NULL;
13602 }
13603
13604
13605 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13606 PyObject *resultobj = 0;
13607 wxString *arg1 = 0 ;
13608 bool temp1 = false ;
13609 PyObject * obj0 = 0 ;
13610 char * kwnames[] = {
13611 (char *) "msg", NULL
13612 };
13613
13614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13615 {
13616 arg1 = wxString_in_helper(obj0);
13617 if (arg1 == NULL) SWIG_fail;
13618 temp1 = true;
13619 }
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 wxPyLogWarning((wxString const &)*arg1);
13623 wxPyEndAllowThreads(__tstate);
13624 if (PyErr_Occurred()) SWIG_fail;
13625 }
13626 resultobj = SWIG_Py_Void();
13627 {
13628 if (temp1)
13629 delete arg1;
13630 }
13631 return resultobj;
13632 fail:
13633 {
13634 if (temp1)
13635 delete arg1;
13636 }
13637 return NULL;
13638 }
13639
13640
13641 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj = 0;
13643 wxString *arg1 = 0 ;
13644 bool temp1 = false ;
13645 PyObject * obj0 = 0 ;
13646 char * kwnames[] = {
13647 (char *) "msg", NULL
13648 };
13649
13650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13651 {
13652 arg1 = wxString_in_helper(obj0);
13653 if (arg1 == NULL) SWIG_fail;
13654 temp1 = true;
13655 }
13656 {
13657 PyThreadState* __tstate = wxPyBeginAllowThreads();
13658 wxPyLogMessage((wxString const &)*arg1);
13659 wxPyEndAllowThreads(__tstate);
13660 if (PyErr_Occurred()) SWIG_fail;
13661 }
13662 resultobj = SWIG_Py_Void();
13663 {
13664 if (temp1)
13665 delete arg1;
13666 }
13667 return resultobj;
13668 fail:
13669 {
13670 if (temp1)
13671 delete arg1;
13672 }
13673 return NULL;
13674 }
13675
13676
13677 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13678 PyObject *resultobj = 0;
13679 wxString *arg1 = 0 ;
13680 bool temp1 = false ;
13681 PyObject * obj0 = 0 ;
13682 char * kwnames[] = {
13683 (char *) "msg", NULL
13684 };
13685
13686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13687 {
13688 arg1 = wxString_in_helper(obj0);
13689 if (arg1 == NULL) SWIG_fail;
13690 temp1 = true;
13691 }
13692 {
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 wxPyLogInfo((wxString const &)*arg1);
13695 wxPyEndAllowThreads(__tstate);
13696 if (PyErr_Occurred()) SWIG_fail;
13697 }
13698 resultobj = SWIG_Py_Void();
13699 {
13700 if (temp1)
13701 delete arg1;
13702 }
13703 return resultobj;
13704 fail:
13705 {
13706 if (temp1)
13707 delete arg1;
13708 }
13709 return NULL;
13710 }
13711
13712
13713 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj = 0;
13715 wxString *arg1 = 0 ;
13716 bool temp1 = false ;
13717 PyObject * obj0 = 0 ;
13718 char * kwnames[] = {
13719 (char *) "msg", NULL
13720 };
13721
13722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13723 {
13724 arg1 = wxString_in_helper(obj0);
13725 if (arg1 == NULL) SWIG_fail;
13726 temp1 = true;
13727 }
13728 {
13729 PyThreadState* __tstate = wxPyBeginAllowThreads();
13730 wxPyLogDebug((wxString const &)*arg1);
13731 wxPyEndAllowThreads(__tstate);
13732 if (PyErr_Occurred()) SWIG_fail;
13733 }
13734 resultobj = SWIG_Py_Void();
13735 {
13736 if (temp1)
13737 delete arg1;
13738 }
13739 return resultobj;
13740 fail:
13741 {
13742 if (temp1)
13743 delete arg1;
13744 }
13745 return NULL;
13746 }
13747
13748
13749 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13750 PyObject *resultobj = 0;
13751 wxString *arg1 = 0 ;
13752 bool temp1 = false ;
13753 PyObject * obj0 = 0 ;
13754 char * kwnames[] = {
13755 (char *) "msg", NULL
13756 };
13757
13758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13759 {
13760 arg1 = wxString_in_helper(obj0);
13761 if (arg1 == NULL) SWIG_fail;
13762 temp1 = true;
13763 }
13764 {
13765 PyThreadState* __tstate = wxPyBeginAllowThreads();
13766 wxPyLogVerbose((wxString const &)*arg1);
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 resultobj = SWIG_Py_Void();
13771 {
13772 if (temp1)
13773 delete arg1;
13774 }
13775 return resultobj;
13776 fail:
13777 {
13778 if (temp1)
13779 delete arg1;
13780 }
13781 return NULL;
13782 }
13783
13784
13785 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj = 0;
13787 wxString *arg1 = 0 ;
13788 bool temp1 = false ;
13789 PyObject * obj0 = 0 ;
13790 char * kwnames[] = {
13791 (char *) "msg", NULL
13792 };
13793
13794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13795 {
13796 arg1 = wxString_in_helper(obj0);
13797 if (arg1 == NULL) SWIG_fail;
13798 temp1 = true;
13799 }
13800 {
13801 PyThreadState* __tstate = wxPyBeginAllowThreads();
13802 wxPyLogStatus((wxString const &)*arg1);
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 resultobj = SWIG_Py_Void();
13807 {
13808 if (temp1)
13809 delete arg1;
13810 }
13811 return resultobj;
13812 fail:
13813 {
13814 if (temp1)
13815 delete arg1;
13816 }
13817 return NULL;
13818 }
13819
13820
13821 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13822 PyObject *resultobj = 0;
13823 wxFrame *arg1 = (wxFrame *) 0 ;
13824 wxString *arg2 = 0 ;
13825 void *argp1 = 0 ;
13826 int res1 = 0 ;
13827 bool temp2 = false ;
13828 PyObject * obj0 = 0 ;
13829 PyObject * obj1 = 0 ;
13830 char * kwnames[] = {
13831 (char *) "pFrame",(char *) "msg", NULL
13832 };
13833
13834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13836 if (!SWIG_IsOK(res1)) {
13837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13838 }
13839 arg1 = reinterpret_cast< wxFrame * >(argp1);
13840 {
13841 arg2 = wxString_in_helper(obj1);
13842 if (arg2 == NULL) SWIG_fail;
13843 temp2 = true;
13844 }
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_Py_Void();
13852 {
13853 if (temp2)
13854 delete arg2;
13855 }
13856 return resultobj;
13857 fail:
13858 {
13859 if (temp2)
13860 delete arg2;
13861 }
13862 return NULL;
13863 }
13864
13865
13866 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13867 PyObject *resultobj = 0;
13868 wxString *arg1 = 0 ;
13869 bool temp1 = false ;
13870 PyObject * obj0 = 0 ;
13871 char * kwnames[] = {
13872 (char *) "msg", NULL
13873 };
13874
13875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13876 {
13877 arg1 = wxString_in_helper(obj0);
13878 if (arg1 == NULL) SWIG_fail;
13879 temp1 = true;
13880 }
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 wxPyLogSysError((wxString const &)*arg1);
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 resultobj = SWIG_Py_Void();
13888 {
13889 if (temp1)
13890 delete arg1;
13891 }
13892 return resultobj;
13893 fail:
13894 {
13895 if (temp1)
13896 delete arg1;
13897 }
13898 return NULL;
13899 }
13900
13901
13902 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13903 PyObject *resultobj = 0;
13904 unsigned long arg1 ;
13905 wxString *arg2 = 0 ;
13906 unsigned long val1 ;
13907 int ecode1 = 0 ;
13908 bool temp2 = false ;
13909 PyObject * obj0 = 0 ;
13910 PyObject * obj1 = 0 ;
13911 char * kwnames[] = {
13912 (char *) "level",(char *) "msg", NULL
13913 };
13914
13915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13916 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13917 if (!SWIG_IsOK(ecode1)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13919 }
13920 arg1 = static_cast< unsigned long >(val1);
13921 {
13922 arg2 = wxString_in_helper(obj1);
13923 if (arg2 == NULL) SWIG_fail;
13924 temp2 = true;
13925 }
13926 {
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 resultobj = SWIG_Py_Void();
13933 {
13934 if (temp2)
13935 delete arg2;
13936 }
13937 return resultobj;
13938 fail:
13939 {
13940 if (temp2)
13941 delete arg2;
13942 }
13943 return NULL;
13944 }
13945
13946
13947 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13948 PyObject *resultobj = 0;
13949 unsigned long arg1 ;
13950 wxString *arg2 = 0 ;
13951 unsigned long val1 ;
13952 int ecode1 = 0 ;
13953 bool temp2 = false ;
13954
13955 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13956 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13957 if (!SWIG_IsOK(ecode1)) {
13958 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13959 }
13960 arg1 = static_cast< unsigned long >(val1);
13961 {
13962 arg2 = wxString_in_helper(swig_obj[1]);
13963 if (arg2 == NULL) SWIG_fail;
13964 temp2 = true;
13965 }
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 wxPyLogTrace(arg1,(wxString const &)*arg2);
13969 wxPyEndAllowThreads(__tstate);
13970 if (PyErr_Occurred()) SWIG_fail;
13971 }
13972 resultobj = SWIG_Py_Void();
13973 {
13974 if (temp2)
13975 delete arg2;
13976 }
13977 return resultobj;
13978 fail:
13979 {
13980 if (temp2)
13981 delete arg2;
13982 }
13983 return NULL;
13984 }
13985
13986
13987 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13988 PyObject *resultobj = 0;
13989 wxString *arg1 = 0 ;
13990 wxString *arg2 = 0 ;
13991 bool temp1 = false ;
13992 bool temp2 = false ;
13993
13994 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13995 {
13996 arg1 = wxString_in_helper(swig_obj[0]);
13997 if (arg1 == NULL) SWIG_fail;
13998 temp1 = true;
13999 }
14000 {
14001 arg2 = wxString_in_helper(swig_obj[1]);
14002 if (arg2 == NULL) SWIG_fail;
14003 temp2 = true;
14004 }
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_Py_Void();
14012 {
14013 if (temp1)
14014 delete arg1;
14015 }
14016 {
14017 if (temp2)
14018 delete arg2;
14019 }
14020 return resultobj;
14021 fail:
14022 {
14023 if (temp1)
14024 delete arg1;
14025 }
14026 {
14027 if (temp2)
14028 delete arg2;
14029 }
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14035 int argc;
14036 PyObject *argv[3];
14037
14038 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14039 --argc;
14040 if (argc == 2) {
14041 int _v = 0;
14042 {
14043 {
14044 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14045 }
14046 }
14047 if (!_v) goto check_1;
14048 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14049 }
14050 check_1:
14051
14052 if (argc == 2) {
14053 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14054 }
14055
14056 fail:
14057 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14058 return NULL;
14059 }
14060
14061
14062 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14063 PyObject *resultobj = 0;
14064 wxString *arg1 = 0 ;
14065 wxString *arg2 = 0 ;
14066 bool temp1 = false ;
14067 bool temp2 = false ;
14068 PyObject * obj0 = 0 ;
14069 PyObject * obj1 = 0 ;
14070 char * kwnames[] = {
14071 (char *) "title",(char *) "text", NULL
14072 };
14073
14074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14075 {
14076 arg1 = wxString_in_helper(obj0);
14077 if (arg1 == NULL) SWIG_fail;
14078 temp1 = true;
14079 }
14080 {
14081 arg2 = wxString_in_helper(obj1);
14082 if (arg2 == NULL) SWIG_fail;
14083 temp2 = true;
14084 }
14085 {
14086 PyThreadState* __tstate = wxPyBeginAllowThreads();
14087 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 resultobj = SWIG_Py_Void();
14092 {
14093 if (temp1)
14094 delete arg1;
14095 }
14096 {
14097 if (temp2)
14098 delete arg2;
14099 }
14100 return resultobj;
14101 fail:
14102 {
14103 if (temp1)
14104 delete arg1;
14105 }
14106 {
14107 if (temp2)
14108 delete arg2;
14109 }
14110 return NULL;
14111 }
14112
14113
14114 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14115 PyObject *resultobj = 0;
14116 wxLogNull *result = 0 ;
14117
14118 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 result = (wxLogNull *)new wxLogNull();
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14133 PyObject *resultobj = 0;
14134 wxLogNull *arg1 = (wxLogNull *) 0 ;
14135 void *argp1 = 0 ;
14136 int res1 = 0 ;
14137 PyObject *swig_obj[1] ;
14138
14139 if (!args) SWIG_fail;
14140 swig_obj[0] = args;
14141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14142 if (!SWIG_IsOK(res1)) {
14143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14144 }
14145 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 delete arg1;
14149
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 resultobj = SWIG_Py_Void();
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14161 PyObject *obj;
14162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14163 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14164 return SWIG_Py_Void();
14165 }
14166
14167 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14168 return SWIG_Python_InitShadowInstance(args);
14169 }
14170
14171 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14172 PyObject *resultobj = 0;
14173 wxPyLog *result = 0 ;
14174
14175 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 result = (wxPyLog *)new wxPyLog();
14179 wxPyEndAllowThreads(__tstate);
14180 if (PyErr_Occurred()) SWIG_fail;
14181 }
14182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14183 return resultobj;
14184 fail:
14185 return NULL;
14186 }
14187
14188
14189 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14190 PyObject *resultobj = 0;
14191 wxPyLog *arg1 = (wxPyLog *) 0 ;
14192 PyObject *arg2 = (PyObject *) 0 ;
14193 PyObject *arg3 = (PyObject *) 0 ;
14194 void *argp1 = 0 ;
14195 int res1 = 0 ;
14196 PyObject * obj0 = 0 ;
14197 PyObject * obj1 = 0 ;
14198 PyObject * obj2 = 0 ;
14199 char * kwnames[] = {
14200 (char *) "self",(char *) "self",(char *) "_class", NULL
14201 };
14202
14203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14205 if (!SWIG_IsOK(res1)) {
14206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14207 }
14208 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14209 arg2 = obj1;
14210 arg3 = obj2;
14211 {
14212 PyThreadState* __tstate = wxPyBeginAllowThreads();
14213 (arg1)->_setCallbackInfo(arg2,arg3);
14214 wxPyEndAllowThreads(__tstate);
14215 if (PyErr_Occurred()) SWIG_fail;
14216 }
14217 resultobj = SWIG_Py_Void();
14218 return resultobj;
14219 fail:
14220 return NULL;
14221 }
14222
14223
14224 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14225 PyObject *obj;
14226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14227 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14228 return SWIG_Py_Void();
14229 }
14230
14231 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14232 return SWIG_Python_InitShadowInstance(args);
14233 }
14234
14235 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj = 0;
14237 int arg1 ;
14238 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14239 int arg3 = (int) wxKILL_NOCHILDREN ;
14240 wxKillError result;
14241 int val1 ;
14242 int ecode1 = 0 ;
14243 int val2 ;
14244 int ecode2 = 0 ;
14245 int val3 ;
14246 int ecode3 = 0 ;
14247 PyObject * obj0 = 0 ;
14248 PyObject * obj1 = 0 ;
14249 PyObject * obj2 = 0 ;
14250 char * kwnames[] = {
14251 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14252 };
14253
14254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14255 ecode1 = SWIG_AsVal_int(obj0, &val1);
14256 if (!SWIG_IsOK(ecode1)) {
14257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14258 }
14259 arg1 = static_cast< int >(val1);
14260 if (obj1) {
14261 ecode2 = SWIG_AsVal_int(obj1, &val2);
14262 if (!SWIG_IsOK(ecode2)) {
14263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14264 }
14265 arg2 = static_cast< wxSignal >(val2);
14266 }
14267 if (obj2) {
14268 ecode3 = SWIG_AsVal_int(obj2, &val3);
14269 if (!SWIG_IsOK(ecode3)) {
14270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14271 }
14272 arg3 = static_cast< int >(val3);
14273 }
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14277 wxPyEndAllowThreads(__tstate);
14278 if (PyErr_Occurred()) SWIG_fail;
14279 }
14280 resultobj = SWIG_From_int(static_cast< int >(result));
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj = 0;
14289 int arg1 ;
14290 bool result;
14291 int val1 ;
14292 int ecode1 = 0 ;
14293 PyObject * obj0 = 0 ;
14294 char * kwnames[] = {
14295 (char *) "pid", NULL
14296 };
14297
14298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14299 ecode1 = SWIG_AsVal_int(obj0, &val1);
14300 if (!SWIG_IsOK(ecode1)) {
14301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14302 }
14303 arg1 = static_cast< int >(val1);
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 result = (bool)wxPyProcess::Exists(arg1);
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 {
14311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14312 }
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj = 0;
14321 wxString *arg1 = 0 ;
14322 int arg2 = (int) wxEXEC_ASYNC ;
14323 wxPyProcess *result = 0 ;
14324 bool temp1 = false ;
14325 int val2 ;
14326 int ecode2 = 0 ;
14327 PyObject * obj0 = 0 ;
14328 PyObject * obj1 = 0 ;
14329 char * kwnames[] = {
14330 (char *) "cmd",(char *) "flags", NULL
14331 };
14332
14333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14334 {
14335 arg1 = wxString_in_helper(obj0);
14336 if (arg1 == NULL) SWIG_fail;
14337 temp1 = true;
14338 }
14339 if (obj1) {
14340 ecode2 = SWIG_AsVal_int(obj1, &val2);
14341 if (!SWIG_IsOK(ecode2)) {
14342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14343 }
14344 arg2 = static_cast< int >(val2);
14345 }
14346 {
14347 PyThreadState* __tstate = wxPyBeginAllowThreads();
14348 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14349 wxPyEndAllowThreads(__tstate);
14350 if (PyErr_Occurred()) SWIG_fail;
14351 }
14352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14353 {
14354 if (temp1)
14355 delete arg1;
14356 }
14357 return resultobj;
14358 fail:
14359 {
14360 if (temp1)
14361 delete arg1;
14362 }
14363 return NULL;
14364 }
14365
14366
14367 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14368 PyObject *resultobj = 0;
14369 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14370 int arg2 = (int) -1 ;
14371 wxPyProcess *result = 0 ;
14372 void *argp1 = 0 ;
14373 int res1 = 0 ;
14374 int val2 ;
14375 int ecode2 = 0 ;
14376 PyObject * obj0 = 0 ;
14377 PyObject * obj1 = 0 ;
14378 char * kwnames[] = {
14379 (char *) "parent",(char *) "id", NULL
14380 };
14381
14382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14383 if (obj0) {
14384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14385 if (!SWIG_IsOK(res1)) {
14386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14387 }
14388 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14389 }
14390 if (obj1) {
14391 ecode2 = SWIG_AsVal_int(obj1, &val2);
14392 if (!SWIG_IsOK(ecode2)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14394 }
14395 arg2 = static_cast< int >(val2);
14396 }
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14411 PyObject *resultobj = 0;
14412 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14413 void *argp1 = 0 ;
14414 int res1 = 0 ;
14415 PyObject *swig_obj[1] ;
14416
14417 if (!args) SWIG_fail;
14418 swig_obj[0] = args;
14419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14420 if (!SWIG_IsOK(res1)) {
14421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14422 }
14423 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 delete arg1;
14427
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 resultobj = SWIG_Py_Void();
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14439 PyObject *resultobj = 0;
14440 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14441 long result;
14442 void *argp1 = 0 ;
14443 int res1 = 0 ;
14444 PyObject *swig_obj[1] ;
14445
14446 if (!args) SWIG_fail;
14447 swig_obj[0] = args;
14448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14449 if (!SWIG_IsOK(res1)) {
14450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14451 }
14452 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (long)((wxPyProcess const *)arg1)->GetPid();
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 resultobj = SWIG_From_long(static_cast< long >(result));
14460 return resultobj;
14461 fail:
14462 return NULL;
14463 }
14464
14465
14466 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14467 PyObject *resultobj = 0;
14468 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14469 PyObject *arg2 = (PyObject *) 0 ;
14470 PyObject *arg3 = (PyObject *) 0 ;
14471 void *argp1 = 0 ;
14472 int res1 = 0 ;
14473 PyObject * obj0 = 0 ;
14474 PyObject * obj1 = 0 ;
14475 PyObject * obj2 = 0 ;
14476 char * kwnames[] = {
14477 (char *) "self",(char *) "self",(char *) "_class", NULL
14478 };
14479
14480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14482 if (!SWIG_IsOK(res1)) {
14483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14484 }
14485 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14486 arg2 = obj1;
14487 arg3 = obj2;
14488 {
14489 PyThreadState* __tstate = wxPyBeginAllowThreads();
14490 (arg1)->_setCallbackInfo(arg2,arg3);
14491 wxPyEndAllowThreads(__tstate);
14492 if (PyErr_Occurred()) SWIG_fail;
14493 }
14494 resultobj = SWIG_Py_Void();
14495 return resultobj;
14496 fail:
14497 return NULL;
14498 }
14499
14500
14501 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14502 PyObject *resultobj = 0;
14503 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14504 int arg2 ;
14505 int arg3 ;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 int val2 ;
14509 int ecode2 = 0 ;
14510 int val3 ;
14511 int ecode3 = 0 ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 PyObject * obj2 = 0 ;
14515 char * kwnames[] = {
14516 (char *) "self",(char *) "pid",(char *) "status", NULL
14517 };
14518
14519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14521 if (!SWIG_IsOK(res1)) {
14522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14523 }
14524 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14525 ecode2 = SWIG_AsVal_int(obj1, &val2);
14526 if (!SWIG_IsOK(ecode2)) {
14527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14528 }
14529 arg2 = static_cast< int >(val2);
14530 ecode3 = SWIG_AsVal_int(obj2, &val3);
14531 if (!SWIG_IsOK(ecode3)) {
14532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14533 }
14534 arg3 = static_cast< int >(val3);
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 (arg1)->OnTerminate(arg2,arg3);
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 resultobj = SWIG_Py_Void();
14542 return resultobj;
14543 fail:
14544 return NULL;
14545 }
14546
14547
14548 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14549 PyObject *resultobj = 0;
14550 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14551 void *argp1 = 0 ;
14552 int res1 = 0 ;
14553 PyObject *swig_obj[1] ;
14554
14555 if (!args) SWIG_fail;
14556 swig_obj[0] = args;
14557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14558 if (!SWIG_IsOK(res1)) {
14559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14560 }
14561 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 (arg1)->Redirect();
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 resultobj = SWIG_Py_Void();
14569 return resultobj;
14570 fail:
14571 return NULL;
14572 }
14573
14574
14575 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14576 PyObject *resultobj = 0;
14577 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14578 bool result;
14579 void *argp1 = 0 ;
14580 int res1 = 0 ;
14581 PyObject *swig_obj[1] ;
14582
14583 if (!args) SWIG_fail;
14584 swig_obj[0] = args;
14585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14586 if (!SWIG_IsOK(res1)) {
14587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14588 }
14589 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (bool)(arg1)->IsRedirected();
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 {
14597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14598 }
14599 return resultobj;
14600 fail:
14601 return NULL;
14602 }
14603
14604
14605 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14606 PyObject *resultobj = 0;
14607 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14608 void *argp1 = 0 ;
14609 int res1 = 0 ;
14610 PyObject *swig_obj[1] ;
14611
14612 if (!args) SWIG_fail;
14613 swig_obj[0] = args;
14614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14615 if (!SWIG_IsOK(res1)) {
14616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14617 }
14618 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14619 {
14620 PyThreadState* __tstate = wxPyBeginAllowThreads();
14621 (arg1)->Detach();
14622 wxPyEndAllowThreads(__tstate);
14623 if (PyErr_Occurred()) SWIG_fail;
14624 }
14625 resultobj = SWIG_Py_Void();
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14633 PyObject *resultobj = 0;
14634 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14635 wxInputStream *result = 0 ;
14636 void *argp1 = 0 ;
14637 int res1 = 0 ;
14638 PyObject *swig_obj[1] ;
14639
14640 if (!args) SWIG_fail;
14641 swig_obj[0] = args;
14642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14643 if (!SWIG_IsOK(res1)) {
14644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14645 }
14646 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14647 {
14648 PyThreadState* __tstate = wxPyBeginAllowThreads();
14649 result = (wxInputStream *)(arg1)->GetInputStream();
14650 wxPyEndAllowThreads(__tstate);
14651 if (PyErr_Occurred()) SWIG_fail;
14652 }
14653 {
14654 wxPyInputStream * _ptr = NULL;
14655
14656 if (result) {
14657 _ptr = new wxPyInputStream(result);
14658 }
14659 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14660 }
14661 return resultobj;
14662 fail:
14663 return NULL;
14664 }
14665
14666
14667 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14668 PyObject *resultobj = 0;
14669 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14670 wxInputStream *result = 0 ;
14671 void *argp1 = 0 ;
14672 int res1 = 0 ;
14673 PyObject *swig_obj[1] ;
14674
14675 if (!args) SWIG_fail;
14676 swig_obj[0] = args;
14677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14678 if (!SWIG_IsOK(res1)) {
14679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14680 }
14681 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14682 {
14683 PyThreadState* __tstate = wxPyBeginAllowThreads();
14684 result = (wxInputStream *)(arg1)->GetErrorStream();
14685 wxPyEndAllowThreads(__tstate);
14686 if (PyErr_Occurred()) SWIG_fail;
14687 }
14688 {
14689 wxPyInputStream * _ptr = NULL;
14690
14691 if (result) {
14692 _ptr = new wxPyInputStream(result);
14693 }
14694 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14695 }
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14703 PyObject *resultobj = 0;
14704 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14705 wxOutputStream *result = 0 ;
14706 void *argp1 = 0 ;
14707 int res1 = 0 ;
14708 PyObject *swig_obj[1] ;
14709
14710 if (!args) SWIG_fail;
14711 swig_obj[0] = args;
14712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14713 if (!SWIG_IsOK(res1)) {
14714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14715 }
14716 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (wxOutputStream *)(arg1)->GetOutputStream();
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14724 return resultobj;
14725 fail:
14726 return NULL;
14727 }
14728
14729
14730 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14731 PyObject *resultobj = 0;
14732 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14733 void *argp1 = 0 ;
14734 int res1 = 0 ;
14735 PyObject *swig_obj[1] ;
14736
14737 if (!args) SWIG_fail;
14738 swig_obj[0] = args;
14739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14740 if (!SWIG_IsOK(res1)) {
14741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14742 }
14743 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 (arg1)->CloseOutput();
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 resultobj = SWIG_Py_Void();
14751 return resultobj;
14752 fail:
14753 return NULL;
14754 }
14755
14756
14757 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14758 PyObject *resultobj = 0;
14759 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14760 bool result;
14761 void *argp1 = 0 ;
14762 int res1 = 0 ;
14763 PyObject *swig_obj[1] ;
14764
14765 if (!args) SWIG_fail;
14766 swig_obj[0] = args;
14767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14768 if (!SWIG_IsOK(res1)) {
14769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14770 }
14771 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14775 wxPyEndAllowThreads(__tstate);
14776 if (PyErr_Occurred()) SWIG_fail;
14777 }
14778 {
14779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14780 }
14781 return resultobj;
14782 fail:
14783 return NULL;
14784 }
14785
14786
14787 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14788 PyObject *resultobj = 0;
14789 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14790 bool result;
14791 void *argp1 = 0 ;
14792 int res1 = 0 ;
14793 PyObject *swig_obj[1] ;
14794
14795 if (!args) SWIG_fail;
14796 swig_obj[0] = args;
14797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14798 if (!SWIG_IsOK(res1)) {
14799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14800 }
14801 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14802 {
14803 PyThreadState* __tstate = wxPyBeginAllowThreads();
14804 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14805 wxPyEndAllowThreads(__tstate);
14806 if (PyErr_Occurred()) SWIG_fail;
14807 }
14808 {
14809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14810 }
14811 return resultobj;
14812 fail:
14813 return NULL;
14814 }
14815
14816
14817 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14818 PyObject *resultobj = 0;
14819 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14820 bool result;
14821 void *argp1 = 0 ;
14822 int res1 = 0 ;
14823 PyObject *swig_obj[1] ;
14824
14825 if (!args) SWIG_fail;
14826 swig_obj[0] = args;
14827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14828 if (!SWIG_IsOK(res1)) {
14829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14830 }
14831 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14832 {
14833 PyThreadState* __tstate = wxPyBeginAllowThreads();
14834 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14835 wxPyEndAllowThreads(__tstate);
14836 if (PyErr_Occurred()) SWIG_fail;
14837 }
14838 {
14839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14840 }
14841 return resultobj;
14842 fail:
14843 return NULL;
14844 }
14845
14846
14847 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14848 PyObject *obj;
14849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14850 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14851 return SWIG_Py_Void();
14852 }
14853
14854 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14855 return SWIG_Python_InitShadowInstance(args);
14856 }
14857
14858 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14859 PyObject *resultobj = 0;
14860 int arg1 = (int) 0 ;
14861 int arg2 = (int) 0 ;
14862 int arg3 = (int) 0 ;
14863 wxProcessEvent *result = 0 ;
14864 int val1 ;
14865 int ecode1 = 0 ;
14866 int val2 ;
14867 int ecode2 = 0 ;
14868 int val3 ;
14869 int ecode3 = 0 ;
14870 PyObject * obj0 = 0 ;
14871 PyObject * obj1 = 0 ;
14872 PyObject * obj2 = 0 ;
14873 char * kwnames[] = {
14874 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14875 };
14876
14877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14878 if (obj0) {
14879 ecode1 = SWIG_AsVal_int(obj0, &val1);
14880 if (!SWIG_IsOK(ecode1)) {
14881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14882 }
14883 arg1 = static_cast< int >(val1);
14884 }
14885 if (obj1) {
14886 ecode2 = SWIG_AsVal_int(obj1, &val2);
14887 if (!SWIG_IsOK(ecode2)) {
14888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14889 }
14890 arg2 = static_cast< int >(val2);
14891 }
14892 if (obj2) {
14893 ecode3 = SWIG_AsVal_int(obj2, &val3);
14894 if (!SWIG_IsOK(ecode3)) {
14895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14896 }
14897 arg3 = static_cast< int >(val3);
14898 }
14899 {
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14902 wxPyEndAllowThreads(__tstate);
14903 if (PyErr_Occurred()) SWIG_fail;
14904 }
14905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14906 return resultobj;
14907 fail:
14908 return NULL;
14909 }
14910
14911
14912 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14913 PyObject *resultobj = 0;
14914 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14915 int result;
14916 void *argp1 = 0 ;
14917 int res1 = 0 ;
14918 PyObject *swig_obj[1] ;
14919
14920 if (!args) SWIG_fail;
14921 swig_obj[0] = args;
14922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14923 if (!SWIG_IsOK(res1)) {
14924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14925 }
14926 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14927 {
14928 PyThreadState* __tstate = wxPyBeginAllowThreads();
14929 result = (int)(arg1)->GetPid();
14930 wxPyEndAllowThreads(__tstate);
14931 if (PyErr_Occurred()) SWIG_fail;
14932 }
14933 resultobj = SWIG_From_int(static_cast< int >(result));
14934 return resultobj;
14935 fail:
14936 return NULL;
14937 }
14938
14939
14940 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14941 PyObject *resultobj = 0;
14942 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14943 int result;
14944 void *argp1 = 0 ;
14945 int res1 = 0 ;
14946 PyObject *swig_obj[1] ;
14947
14948 if (!args) SWIG_fail;
14949 swig_obj[0] = args;
14950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14951 if (!SWIG_IsOK(res1)) {
14952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14953 }
14954 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14955 {
14956 PyThreadState* __tstate = wxPyBeginAllowThreads();
14957 result = (int)(arg1)->GetExitCode();
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 resultobj = SWIG_From_int(static_cast< int >(result));
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14969 PyObject *resultobj = 0;
14970 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14971 int arg2 ;
14972 void *argp1 = 0 ;
14973 int res1 = 0 ;
14974 int val2 ;
14975 int ecode2 = 0 ;
14976 PyObject *swig_obj[2] ;
14977
14978 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14980 if (!SWIG_IsOK(res1)) {
14981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14982 }
14983 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14984 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14985 if (!SWIG_IsOK(ecode2)) {
14986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14987 }
14988 arg2 = static_cast< int >(val2);
14989 if (arg1) (arg1)->m_pid = arg2;
14990
14991 resultobj = SWIG_Py_Void();
14992 return resultobj;
14993 fail:
14994 return NULL;
14995 }
14996
14997
14998 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14999 PyObject *resultobj = 0;
15000 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15001 int result;
15002 void *argp1 = 0 ;
15003 int res1 = 0 ;
15004 PyObject *swig_obj[1] ;
15005
15006 if (!args) SWIG_fail;
15007 swig_obj[0] = args;
15008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15009 if (!SWIG_IsOK(res1)) {
15010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15011 }
15012 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15013 result = (int) ((arg1)->m_pid);
15014 resultobj = SWIG_From_int(static_cast< int >(result));
15015 return resultobj;
15016 fail:
15017 return NULL;
15018 }
15019
15020
15021 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15022 PyObject *resultobj = 0;
15023 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15024 int arg2 ;
15025 void *argp1 = 0 ;
15026 int res1 = 0 ;
15027 int val2 ;
15028 int ecode2 = 0 ;
15029 PyObject *swig_obj[2] ;
15030
15031 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15033 if (!SWIG_IsOK(res1)) {
15034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15035 }
15036 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15037 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15038 if (!SWIG_IsOK(ecode2)) {
15039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15040 }
15041 arg2 = static_cast< int >(val2);
15042 if (arg1) (arg1)->m_exitcode = arg2;
15043
15044 resultobj = SWIG_Py_Void();
15045 return resultobj;
15046 fail:
15047 return NULL;
15048 }
15049
15050
15051 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15052 PyObject *resultobj = 0;
15053 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15054 int result;
15055 void *argp1 = 0 ;
15056 int res1 = 0 ;
15057 PyObject *swig_obj[1] ;
15058
15059 if (!args) SWIG_fail;
15060 swig_obj[0] = args;
15061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15062 if (!SWIG_IsOK(res1)) {
15063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15064 }
15065 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15066 result = (int) ((arg1)->m_exitcode);
15067 resultobj = SWIG_From_int(static_cast< int >(result));
15068 return resultobj;
15069 fail:
15070 return NULL;
15071 }
15072
15073
15074 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15075 PyObject *obj;
15076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15077 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15078 return SWIG_Py_Void();
15079 }
15080
15081 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15082 return SWIG_Python_InitShadowInstance(args);
15083 }
15084
15085 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15086 PyObject *resultobj = 0;
15087 wxString *arg1 = 0 ;
15088 int arg2 = (int) wxEXEC_ASYNC ;
15089 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15090 long result;
15091 bool temp1 = false ;
15092 int val2 ;
15093 int ecode2 = 0 ;
15094 void *argp3 = 0 ;
15095 int res3 = 0 ;
15096 PyObject * obj0 = 0 ;
15097 PyObject * obj1 = 0 ;
15098 PyObject * obj2 = 0 ;
15099 char * kwnames[] = {
15100 (char *) "command",(char *) "flags",(char *) "process", NULL
15101 };
15102
15103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15104 {
15105 arg1 = wxString_in_helper(obj0);
15106 if (arg1 == NULL) SWIG_fail;
15107 temp1 = true;
15108 }
15109 if (obj1) {
15110 ecode2 = SWIG_AsVal_int(obj1, &val2);
15111 if (!SWIG_IsOK(ecode2)) {
15112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15113 }
15114 arg2 = static_cast< int >(val2);
15115 }
15116 if (obj2) {
15117 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15118 if (!SWIG_IsOK(res3)) {
15119 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15120 }
15121 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15122 }
15123 {
15124 if (!wxPyCheckForApp()) SWIG_fail;
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15127 wxPyEndAllowThreads(__tstate);
15128 if (PyErr_Occurred()) SWIG_fail;
15129 }
15130 resultobj = SWIG_From_long(static_cast< long >(result));
15131 {
15132 if (temp1)
15133 delete arg1;
15134 }
15135 return resultobj;
15136 fail:
15137 {
15138 if (temp1)
15139 delete arg1;
15140 }
15141 return NULL;
15142 }
15143
15144
15145 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15146 PyObject *resultobj = 0;
15147 long arg1 ;
15148 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15149 wxKillError *arg3 = (wxKillError *) 0 ;
15150 int arg4 = (int) wxKILL_NOCHILDREN ;
15151 int result;
15152 long val1 ;
15153 int ecode1 = 0 ;
15154 int val2 ;
15155 int ecode2 = 0 ;
15156 wxKillError temp3 ;
15157 int val4 ;
15158 int ecode4 = 0 ;
15159 PyObject * obj0 = 0 ;
15160 PyObject * obj1 = 0 ;
15161 PyObject * obj2 = 0 ;
15162 char * kwnames[] = {
15163 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15164 };
15165
15166 {
15167 arg3 = &temp3;
15168 }
15169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15170 ecode1 = SWIG_AsVal_long(obj0, &val1);
15171 if (!SWIG_IsOK(ecode1)) {
15172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15173 }
15174 arg1 = static_cast< long >(val1);
15175 if (obj1) {
15176 ecode2 = SWIG_AsVal_int(obj1, &val2);
15177 if (!SWIG_IsOK(ecode2)) {
15178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15179 }
15180 arg2 = static_cast< wxSignal >(val2);
15181 }
15182 if (obj2) {
15183 ecode4 = SWIG_AsVal_int(obj2, &val4);
15184 if (!SWIG_IsOK(ecode4)) {
15185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15186 }
15187 arg4 = static_cast< int >(val4);
15188 }
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 result = (int)wxKill(arg1,arg2,arg3,arg4);
15192 wxPyEndAllowThreads(__tstate);
15193 if (PyErr_Occurred()) SWIG_fail;
15194 }
15195 resultobj = SWIG_From_int(static_cast< int >(result));
15196 {
15197 PyObject* o;
15198 o = PyInt_FromLong((long) (*arg3));
15199
15200
15201
15202 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15203
15204 }
15205 return resultobj;
15206 fail:
15207 return NULL;
15208 }
15209
15210
15211 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15212 PyObject *resultobj = 0;
15213 int arg1 = (int) wxJOYSTICK1 ;
15214 wxJoystick *result = 0 ;
15215 int val1 ;
15216 int ecode1 = 0 ;
15217 PyObject * obj0 = 0 ;
15218 char * kwnames[] = {
15219 (char *) "joystick", NULL
15220 };
15221
15222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15223 if (obj0) {
15224 ecode1 = SWIG_AsVal_int(obj0, &val1);
15225 if (!SWIG_IsOK(ecode1)) {
15226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15227 }
15228 arg1 = static_cast< int >(val1);
15229 }
15230 {
15231 if (!wxPyCheckForApp()) SWIG_fail;
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 result = (wxJoystick *)new wxJoystick(arg1);
15234 wxPyEndAllowThreads(__tstate);
15235 if (PyErr_Occurred()) SWIG_fail;
15236 }
15237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15238 return resultobj;
15239 fail:
15240 return NULL;
15241 }
15242
15243
15244 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15245 PyObject *resultobj = 0;
15246 wxJoystick *arg1 = (wxJoystick *) 0 ;
15247 void *argp1 = 0 ;
15248 int res1 = 0 ;
15249 PyObject *swig_obj[1] ;
15250
15251 if (!args) SWIG_fail;
15252 swig_obj[0] = args;
15253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15254 if (!SWIG_IsOK(res1)) {
15255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15256 }
15257 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 delete arg1;
15261
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 resultobj = SWIG_Py_Void();
15266 return resultobj;
15267 fail:
15268 return NULL;
15269 }
15270
15271
15272 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15273 PyObject *resultobj = 0;
15274 wxJoystick *arg1 = (wxJoystick *) 0 ;
15275 wxPoint result;
15276 void *argp1 = 0 ;
15277 int res1 = 0 ;
15278 PyObject *swig_obj[1] ;
15279
15280 if (!args) SWIG_fail;
15281 swig_obj[0] = args;
15282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15283 if (!SWIG_IsOK(res1)) {
15284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15285 }
15286 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (arg1)->GetPosition();
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15301 PyObject *resultobj = 0;
15302 wxJoystick *arg1 = (wxJoystick *) 0 ;
15303 int result;
15304 void *argp1 = 0 ;
15305 int res1 = 0 ;
15306 PyObject *swig_obj[1] ;
15307
15308 if (!args) SWIG_fail;
15309 swig_obj[0] = args;
15310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15311 if (!SWIG_IsOK(res1)) {
15312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15313 }
15314 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15315 {
15316 PyThreadState* __tstate = wxPyBeginAllowThreads();
15317 result = (int)(arg1)->GetZPosition();
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 resultobj = SWIG_From_int(static_cast< int >(result));
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15329 PyObject *resultobj = 0;
15330 wxJoystick *arg1 = (wxJoystick *) 0 ;
15331 int result;
15332 void *argp1 = 0 ;
15333 int res1 = 0 ;
15334 PyObject *swig_obj[1] ;
15335
15336 if (!args) SWIG_fail;
15337 swig_obj[0] = args;
15338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15339 if (!SWIG_IsOK(res1)) {
15340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15341 }
15342 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (int)(arg1)->GetButtonState();
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 resultobj = SWIG_From_int(static_cast< int >(result));
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15357 PyObject *resultobj = 0;
15358 wxJoystick *arg1 = (wxJoystick *) 0 ;
15359 int result;
15360 void *argp1 = 0 ;
15361 int res1 = 0 ;
15362 PyObject *swig_obj[1] ;
15363
15364 if (!args) SWIG_fail;
15365 swig_obj[0] = args;
15366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15367 if (!SWIG_IsOK(res1)) {
15368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15369 }
15370 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15371 {
15372 PyThreadState* __tstate = wxPyBeginAllowThreads();
15373 result = (int)(arg1)->GetPOVPosition();
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 resultobj = SWIG_From_int(static_cast< int >(result));
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15385 PyObject *resultobj = 0;
15386 wxJoystick *arg1 = (wxJoystick *) 0 ;
15387 int result;
15388 void *argp1 = 0 ;
15389 int res1 = 0 ;
15390 PyObject *swig_obj[1] ;
15391
15392 if (!args) SWIG_fail;
15393 swig_obj[0] = args;
15394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15395 if (!SWIG_IsOK(res1)) {
15396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15397 }
15398 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (int)(arg1)->GetPOVCTSPosition();
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = SWIG_From_int(static_cast< int >(result));
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15413 PyObject *resultobj = 0;
15414 wxJoystick *arg1 = (wxJoystick *) 0 ;
15415 int result;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject *swig_obj[1] ;
15419
15420 if (!args) SWIG_fail;
15421 swig_obj[0] = args;
15422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15423 if (!SWIG_IsOK(res1)) {
15424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15425 }
15426 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (int)(arg1)->GetRudderPosition();
15430 wxPyEndAllowThreads(__tstate);
15431 if (PyErr_Occurred()) SWIG_fail;
15432 }
15433 resultobj = SWIG_From_int(static_cast< int >(result));
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15441 PyObject *resultobj = 0;
15442 wxJoystick *arg1 = (wxJoystick *) 0 ;
15443 int result;
15444 void *argp1 = 0 ;
15445 int res1 = 0 ;
15446 PyObject *swig_obj[1] ;
15447
15448 if (!args) SWIG_fail;
15449 swig_obj[0] = args;
15450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15451 if (!SWIG_IsOK(res1)) {
15452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15453 }
15454 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 result = (int)(arg1)->GetUPosition();
15458 wxPyEndAllowThreads(__tstate);
15459 if (PyErr_Occurred()) SWIG_fail;
15460 }
15461 resultobj = SWIG_From_int(static_cast< int >(result));
15462 return resultobj;
15463 fail:
15464 return NULL;
15465 }
15466
15467
15468 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15469 PyObject *resultobj = 0;
15470 wxJoystick *arg1 = (wxJoystick *) 0 ;
15471 int result;
15472 void *argp1 = 0 ;
15473 int res1 = 0 ;
15474 PyObject *swig_obj[1] ;
15475
15476 if (!args) SWIG_fail;
15477 swig_obj[0] = args;
15478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15479 if (!SWIG_IsOK(res1)) {
15480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15481 }
15482 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (int)(arg1)->GetVPosition();
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 resultobj = SWIG_From_int(static_cast< int >(result));
15490 return resultobj;
15491 fail:
15492 return NULL;
15493 }
15494
15495
15496 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15497 PyObject *resultobj = 0;
15498 wxJoystick *arg1 = (wxJoystick *) 0 ;
15499 int result;
15500 void *argp1 = 0 ;
15501 int res1 = 0 ;
15502 PyObject *swig_obj[1] ;
15503
15504 if (!args) SWIG_fail;
15505 swig_obj[0] = args;
15506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15507 if (!SWIG_IsOK(res1)) {
15508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15509 }
15510 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 result = (int)(arg1)->GetMovementThreshold();
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 resultobj = SWIG_From_int(static_cast< int >(result));
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15525 PyObject *resultobj = 0;
15526 wxJoystick *arg1 = (wxJoystick *) 0 ;
15527 int arg2 ;
15528 void *argp1 = 0 ;
15529 int res1 = 0 ;
15530 int val2 ;
15531 int ecode2 = 0 ;
15532 PyObject * obj0 = 0 ;
15533 PyObject * obj1 = 0 ;
15534 char * kwnames[] = {
15535 (char *) "self",(char *) "threshold", NULL
15536 };
15537
15538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15540 if (!SWIG_IsOK(res1)) {
15541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15542 }
15543 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15544 ecode2 = SWIG_AsVal_int(obj1, &val2);
15545 if (!SWIG_IsOK(ecode2)) {
15546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15547 }
15548 arg2 = static_cast< int >(val2);
15549 {
15550 PyThreadState* __tstate = wxPyBeginAllowThreads();
15551 (arg1)->SetMovementThreshold(arg2);
15552 wxPyEndAllowThreads(__tstate);
15553 if (PyErr_Occurred()) SWIG_fail;
15554 }
15555 resultobj = SWIG_Py_Void();
15556 return resultobj;
15557 fail:
15558 return NULL;
15559 }
15560
15561
15562 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15563 PyObject *resultobj = 0;
15564 wxJoystick *arg1 = (wxJoystick *) 0 ;
15565 bool result;
15566 void *argp1 = 0 ;
15567 int res1 = 0 ;
15568 PyObject *swig_obj[1] ;
15569
15570 if (!args) SWIG_fail;
15571 swig_obj[0] = args;
15572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15573 if (!SWIG_IsOK(res1)) {
15574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15575 }
15576 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15577 {
15578 PyThreadState* __tstate = wxPyBeginAllowThreads();
15579 result = (bool)(arg1)->IsOk();
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 {
15584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15585 }
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15593 PyObject *resultobj = 0;
15594 wxJoystick *arg1 = (wxJoystick *) 0 ;
15595 int result;
15596 void *argp1 = 0 ;
15597 int res1 = 0 ;
15598 PyObject *swig_obj[1] ;
15599
15600 if (!args) SWIG_fail;
15601 swig_obj[0] = args;
15602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15603 if (!SWIG_IsOK(res1)) {
15604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15605 }
15606 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15607 {
15608 PyThreadState* __tstate = wxPyBeginAllowThreads();
15609 result = (int)(arg1)->GetNumberJoysticks();
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 resultobj = SWIG_From_int(static_cast< int >(result));
15614 return resultobj;
15615 fail:
15616 return NULL;
15617 }
15618
15619
15620 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15621 PyObject *resultobj = 0;
15622 wxJoystick *arg1 = (wxJoystick *) 0 ;
15623 int result;
15624 void *argp1 = 0 ;
15625 int res1 = 0 ;
15626 PyObject *swig_obj[1] ;
15627
15628 if (!args) SWIG_fail;
15629 swig_obj[0] = args;
15630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15631 if (!SWIG_IsOK(res1)) {
15632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15633 }
15634 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15635 {
15636 PyThreadState* __tstate = wxPyBeginAllowThreads();
15637 result = (int)(arg1)->GetManufacturerId();
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 resultobj = SWIG_From_int(static_cast< int >(result));
15642 return resultobj;
15643 fail:
15644 return NULL;
15645 }
15646
15647
15648 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15649 PyObject *resultobj = 0;
15650 wxJoystick *arg1 = (wxJoystick *) 0 ;
15651 int result;
15652 void *argp1 = 0 ;
15653 int res1 = 0 ;
15654 PyObject *swig_obj[1] ;
15655
15656 if (!args) SWIG_fail;
15657 swig_obj[0] = args;
15658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15661 }
15662 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (int)(arg1)->GetProductId();
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 resultobj = SWIG_From_int(static_cast< int >(result));
15670 return resultobj;
15671 fail:
15672 return NULL;
15673 }
15674
15675
15676 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15677 PyObject *resultobj = 0;
15678 wxJoystick *arg1 = (wxJoystick *) 0 ;
15679 wxString result;
15680 void *argp1 = 0 ;
15681 int res1 = 0 ;
15682 PyObject *swig_obj[1] ;
15683
15684 if (!args) SWIG_fail;
15685 swig_obj[0] = args;
15686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15687 if (!SWIG_IsOK(res1)) {
15688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15689 }
15690 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15691 {
15692 PyThreadState* __tstate = wxPyBeginAllowThreads();
15693 result = (arg1)->GetProductName();
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 {
15698 #if wxUSE_UNICODE
15699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15700 #else
15701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15702 #endif
15703 }
15704 return resultobj;
15705 fail:
15706 return NULL;
15707 }
15708
15709
15710 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15711 PyObject *resultobj = 0;
15712 wxJoystick *arg1 = (wxJoystick *) 0 ;
15713 int result;
15714 void *argp1 = 0 ;
15715 int res1 = 0 ;
15716 PyObject *swig_obj[1] ;
15717
15718 if (!args) SWIG_fail;
15719 swig_obj[0] = args;
15720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15721 if (!SWIG_IsOK(res1)) {
15722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15723 }
15724 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = (int)(arg1)->GetXMin();
15728 wxPyEndAllowThreads(__tstate);
15729 if (PyErr_Occurred()) SWIG_fail;
15730 }
15731 resultobj = SWIG_From_int(static_cast< int >(result));
15732 return resultobj;
15733 fail:
15734 return NULL;
15735 }
15736
15737
15738 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15739 PyObject *resultobj = 0;
15740 wxJoystick *arg1 = (wxJoystick *) 0 ;
15741 int result;
15742 void *argp1 = 0 ;
15743 int res1 = 0 ;
15744 PyObject *swig_obj[1] ;
15745
15746 if (!args) SWIG_fail;
15747 swig_obj[0] = args;
15748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15751 }
15752 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (int)(arg1)->GetYMin();
15756 wxPyEndAllowThreads(__tstate);
15757 if (PyErr_Occurred()) SWIG_fail;
15758 }
15759 resultobj = SWIG_From_int(static_cast< int >(result));
15760 return resultobj;
15761 fail:
15762 return NULL;
15763 }
15764
15765
15766 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15767 PyObject *resultobj = 0;
15768 wxJoystick *arg1 = (wxJoystick *) 0 ;
15769 int result;
15770 void *argp1 = 0 ;
15771 int res1 = 0 ;
15772 PyObject *swig_obj[1] ;
15773
15774 if (!args) SWIG_fail;
15775 swig_obj[0] = args;
15776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15777 if (!SWIG_IsOK(res1)) {
15778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15779 }
15780 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15781 {
15782 PyThreadState* __tstate = wxPyBeginAllowThreads();
15783 result = (int)(arg1)->GetZMin();
15784 wxPyEndAllowThreads(__tstate);
15785 if (PyErr_Occurred()) SWIG_fail;
15786 }
15787 resultobj = SWIG_From_int(static_cast< int >(result));
15788 return resultobj;
15789 fail:
15790 return NULL;
15791 }
15792
15793
15794 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15795 PyObject *resultobj = 0;
15796 wxJoystick *arg1 = (wxJoystick *) 0 ;
15797 int result;
15798 void *argp1 = 0 ;
15799 int res1 = 0 ;
15800 PyObject *swig_obj[1] ;
15801
15802 if (!args) SWIG_fail;
15803 swig_obj[0] = args;
15804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15805 if (!SWIG_IsOK(res1)) {
15806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15807 }
15808 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 result = (int)(arg1)->GetXMax();
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 resultobj = SWIG_From_int(static_cast< int >(result));
15816 return resultobj;
15817 fail:
15818 return NULL;
15819 }
15820
15821
15822 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15823 PyObject *resultobj = 0;
15824 wxJoystick *arg1 = (wxJoystick *) 0 ;
15825 int result;
15826 void *argp1 = 0 ;
15827 int res1 = 0 ;
15828 PyObject *swig_obj[1] ;
15829
15830 if (!args) SWIG_fail;
15831 swig_obj[0] = args;
15832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15833 if (!SWIG_IsOK(res1)) {
15834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15835 }
15836 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15837 {
15838 PyThreadState* __tstate = wxPyBeginAllowThreads();
15839 result = (int)(arg1)->GetYMax();
15840 wxPyEndAllowThreads(__tstate);
15841 if (PyErr_Occurred()) SWIG_fail;
15842 }
15843 resultobj = SWIG_From_int(static_cast< int >(result));
15844 return resultobj;
15845 fail:
15846 return NULL;
15847 }
15848
15849
15850 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15851 PyObject *resultobj = 0;
15852 wxJoystick *arg1 = (wxJoystick *) 0 ;
15853 int result;
15854 void *argp1 = 0 ;
15855 int res1 = 0 ;
15856 PyObject *swig_obj[1] ;
15857
15858 if (!args) SWIG_fail;
15859 swig_obj[0] = args;
15860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15861 if (!SWIG_IsOK(res1)) {
15862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15863 }
15864 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 result = (int)(arg1)->GetZMax();
15868 wxPyEndAllowThreads(__tstate);
15869 if (PyErr_Occurred()) SWIG_fail;
15870 }
15871 resultobj = SWIG_From_int(static_cast< int >(result));
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15879 PyObject *resultobj = 0;
15880 wxJoystick *arg1 = (wxJoystick *) 0 ;
15881 int result;
15882 void *argp1 = 0 ;
15883 int res1 = 0 ;
15884 PyObject *swig_obj[1] ;
15885
15886 if (!args) SWIG_fail;
15887 swig_obj[0] = args;
15888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15889 if (!SWIG_IsOK(res1)) {
15890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15891 }
15892 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (int)(arg1)->GetNumberButtons();
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 resultobj = SWIG_From_int(static_cast< int >(result));
15900 return resultobj;
15901 fail:
15902 return NULL;
15903 }
15904
15905
15906 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15907 PyObject *resultobj = 0;
15908 wxJoystick *arg1 = (wxJoystick *) 0 ;
15909 int result;
15910 void *argp1 = 0 ;
15911 int res1 = 0 ;
15912 PyObject *swig_obj[1] ;
15913
15914 if (!args) SWIG_fail;
15915 swig_obj[0] = args;
15916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15917 if (!SWIG_IsOK(res1)) {
15918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15919 }
15920 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (int)(arg1)->GetNumberAxes();
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_From_int(static_cast< int >(result));
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15935 PyObject *resultobj = 0;
15936 wxJoystick *arg1 = (wxJoystick *) 0 ;
15937 int result;
15938 void *argp1 = 0 ;
15939 int res1 = 0 ;
15940 PyObject *swig_obj[1] ;
15941
15942 if (!args) SWIG_fail;
15943 swig_obj[0] = args;
15944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15945 if (!SWIG_IsOK(res1)) {
15946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15947 }
15948 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 result = (int)(arg1)->GetMaxButtons();
15952 wxPyEndAllowThreads(__tstate);
15953 if (PyErr_Occurred()) SWIG_fail;
15954 }
15955 resultobj = SWIG_From_int(static_cast< int >(result));
15956 return resultobj;
15957 fail:
15958 return NULL;
15959 }
15960
15961
15962 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15963 PyObject *resultobj = 0;
15964 wxJoystick *arg1 = (wxJoystick *) 0 ;
15965 int result;
15966 void *argp1 = 0 ;
15967 int res1 = 0 ;
15968 PyObject *swig_obj[1] ;
15969
15970 if (!args) SWIG_fail;
15971 swig_obj[0] = args;
15972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15973 if (!SWIG_IsOK(res1)) {
15974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15975 }
15976 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15977 {
15978 PyThreadState* __tstate = wxPyBeginAllowThreads();
15979 result = (int)(arg1)->GetMaxAxes();
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 resultobj = SWIG_From_int(static_cast< int >(result));
15984 return resultobj;
15985 fail:
15986 return NULL;
15987 }
15988
15989
15990 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15991 PyObject *resultobj = 0;
15992 wxJoystick *arg1 = (wxJoystick *) 0 ;
15993 int result;
15994 void *argp1 = 0 ;
15995 int res1 = 0 ;
15996 PyObject *swig_obj[1] ;
15997
15998 if (!args) SWIG_fail;
15999 swig_obj[0] = args;
16000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16001 if (!SWIG_IsOK(res1)) {
16002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16003 }
16004 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 result = (int)(arg1)->GetPollingMin();
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 resultobj = SWIG_From_int(static_cast< int >(result));
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16019 PyObject *resultobj = 0;
16020 wxJoystick *arg1 = (wxJoystick *) 0 ;
16021 int result;
16022 void *argp1 = 0 ;
16023 int res1 = 0 ;
16024 PyObject *swig_obj[1] ;
16025
16026 if (!args) SWIG_fail;
16027 swig_obj[0] = args;
16028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16029 if (!SWIG_IsOK(res1)) {
16030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16031 }
16032 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16033 {
16034 PyThreadState* __tstate = wxPyBeginAllowThreads();
16035 result = (int)(arg1)->GetPollingMax();
16036 wxPyEndAllowThreads(__tstate);
16037 if (PyErr_Occurred()) SWIG_fail;
16038 }
16039 resultobj = SWIG_From_int(static_cast< int >(result));
16040 return resultobj;
16041 fail:
16042 return NULL;
16043 }
16044
16045
16046 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16047 PyObject *resultobj = 0;
16048 wxJoystick *arg1 = (wxJoystick *) 0 ;
16049 int result;
16050 void *argp1 = 0 ;
16051 int res1 = 0 ;
16052 PyObject *swig_obj[1] ;
16053
16054 if (!args) SWIG_fail;
16055 swig_obj[0] = args;
16056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16057 if (!SWIG_IsOK(res1)) {
16058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16059 }
16060 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16061 {
16062 PyThreadState* __tstate = wxPyBeginAllowThreads();
16063 result = (int)(arg1)->GetRudderMin();
16064 wxPyEndAllowThreads(__tstate);
16065 if (PyErr_Occurred()) SWIG_fail;
16066 }
16067 resultobj = SWIG_From_int(static_cast< int >(result));
16068 return resultobj;
16069 fail:
16070 return NULL;
16071 }
16072
16073
16074 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16075 PyObject *resultobj = 0;
16076 wxJoystick *arg1 = (wxJoystick *) 0 ;
16077 int result;
16078 void *argp1 = 0 ;
16079 int res1 = 0 ;
16080 PyObject *swig_obj[1] ;
16081
16082 if (!args) SWIG_fail;
16083 swig_obj[0] = args;
16084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16085 if (!SWIG_IsOK(res1)) {
16086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16087 }
16088 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16089 {
16090 PyThreadState* __tstate = wxPyBeginAllowThreads();
16091 result = (int)(arg1)->GetRudderMax();
16092 wxPyEndAllowThreads(__tstate);
16093 if (PyErr_Occurred()) SWIG_fail;
16094 }
16095 resultobj = SWIG_From_int(static_cast< int >(result));
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16103 PyObject *resultobj = 0;
16104 wxJoystick *arg1 = (wxJoystick *) 0 ;
16105 int result;
16106 void *argp1 = 0 ;
16107 int res1 = 0 ;
16108 PyObject *swig_obj[1] ;
16109
16110 if (!args) SWIG_fail;
16111 swig_obj[0] = args;
16112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16113 if (!SWIG_IsOK(res1)) {
16114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16115 }
16116 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16117 {
16118 PyThreadState* __tstate = wxPyBeginAllowThreads();
16119 result = (int)(arg1)->GetUMin();
16120 wxPyEndAllowThreads(__tstate);
16121 if (PyErr_Occurred()) SWIG_fail;
16122 }
16123 resultobj = SWIG_From_int(static_cast< int >(result));
16124 return resultobj;
16125 fail:
16126 return NULL;
16127 }
16128
16129
16130 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16131 PyObject *resultobj = 0;
16132 wxJoystick *arg1 = (wxJoystick *) 0 ;
16133 int result;
16134 void *argp1 = 0 ;
16135 int res1 = 0 ;
16136 PyObject *swig_obj[1] ;
16137
16138 if (!args) SWIG_fail;
16139 swig_obj[0] = args;
16140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16141 if (!SWIG_IsOK(res1)) {
16142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16143 }
16144 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = (int)(arg1)->GetUMax();
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 resultobj = SWIG_From_int(static_cast< int >(result));
16152 return resultobj;
16153 fail:
16154 return NULL;
16155 }
16156
16157
16158 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16159 PyObject *resultobj = 0;
16160 wxJoystick *arg1 = (wxJoystick *) 0 ;
16161 int result;
16162 void *argp1 = 0 ;
16163 int res1 = 0 ;
16164 PyObject *swig_obj[1] ;
16165
16166 if (!args) SWIG_fail;
16167 swig_obj[0] = args;
16168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16169 if (!SWIG_IsOK(res1)) {
16170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16171 }
16172 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 result = (int)(arg1)->GetVMin();
16176 wxPyEndAllowThreads(__tstate);
16177 if (PyErr_Occurred()) SWIG_fail;
16178 }
16179 resultobj = SWIG_From_int(static_cast< int >(result));
16180 return resultobj;
16181 fail:
16182 return NULL;
16183 }
16184
16185
16186 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16187 PyObject *resultobj = 0;
16188 wxJoystick *arg1 = (wxJoystick *) 0 ;
16189 int result;
16190 void *argp1 = 0 ;
16191 int res1 = 0 ;
16192 PyObject *swig_obj[1] ;
16193
16194 if (!args) SWIG_fail;
16195 swig_obj[0] = args;
16196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16197 if (!SWIG_IsOK(res1)) {
16198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16199 }
16200 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = (int)(arg1)->GetVMax();
16204 wxPyEndAllowThreads(__tstate);
16205 if (PyErr_Occurred()) SWIG_fail;
16206 }
16207 resultobj = SWIG_From_int(static_cast< int >(result));
16208 return resultobj;
16209 fail:
16210 return NULL;
16211 }
16212
16213
16214 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16215 PyObject *resultobj = 0;
16216 wxJoystick *arg1 = (wxJoystick *) 0 ;
16217 bool result;
16218 void *argp1 = 0 ;
16219 int res1 = 0 ;
16220 PyObject *swig_obj[1] ;
16221
16222 if (!args) SWIG_fail;
16223 swig_obj[0] = args;
16224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16227 }
16228 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16229 {
16230 PyThreadState* __tstate = wxPyBeginAllowThreads();
16231 result = (bool)(arg1)->HasRudder();
16232 wxPyEndAllowThreads(__tstate);
16233 if (PyErr_Occurred()) SWIG_fail;
16234 }
16235 {
16236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16237 }
16238 return resultobj;
16239 fail:
16240 return NULL;
16241 }
16242
16243
16244 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16245 PyObject *resultobj = 0;
16246 wxJoystick *arg1 = (wxJoystick *) 0 ;
16247 bool result;
16248 void *argp1 = 0 ;
16249 int res1 = 0 ;
16250 PyObject *swig_obj[1] ;
16251
16252 if (!args) SWIG_fail;
16253 swig_obj[0] = args;
16254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16255 if (!SWIG_IsOK(res1)) {
16256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16257 }
16258 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16259 {
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 result = (bool)(arg1)->HasZ();
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 {
16266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16267 }
16268 return resultobj;
16269 fail:
16270 return NULL;
16271 }
16272
16273
16274 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16275 PyObject *resultobj = 0;
16276 wxJoystick *arg1 = (wxJoystick *) 0 ;
16277 bool result;
16278 void *argp1 = 0 ;
16279 int res1 = 0 ;
16280 PyObject *swig_obj[1] ;
16281
16282 if (!args) SWIG_fail;
16283 swig_obj[0] = args;
16284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16285 if (!SWIG_IsOK(res1)) {
16286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16287 }
16288 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16289 {
16290 PyThreadState* __tstate = wxPyBeginAllowThreads();
16291 result = (bool)(arg1)->HasU();
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 {
16296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16297 }
16298 return resultobj;
16299 fail:
16300 return NULL;
16301 }
16302
16303
16304 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16305 PyObject *resultobj = 0;
16306 wxJoystick *arg1 = (wxJoystick *) 0 ;
16307 bool result;
16308 void *argp1 = 0 ;
16309 int res1 = 0 ;
16310 PyObject *swig_obj[1] ;
16311
16312 if (!args) SWIG_fail;
16313 swig_obj[0] = args;
16314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16315 if (!SWIG_IsOK(res1)) {
16316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16317 }
16318 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16319 {
16320 PyThreadState* __tstate = wxPyBeginAllowThreads();
16321 result = (bool)(arg1)->HasV();
16322 wxPyEndAllowThreads(__tstate);
16323 if (PyErr_Occurred()) SWIG_fail;
16324 }
16325 {
16326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16327 }
16328 return resultobj;
16329 fail:
16330 return NULL;
16331 }
16332
16333
16334 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16335 PyObject *resultobj = 0;
16336 wxJoystick *arg1 = (wxJoystick *) 0 ;
16337 bool result;
16338 void *argp1 = 0 ;
16339 int res1 = 0 ;
16340 PyObject *swig_obj[1] ;
16341
16342 if (!args) SWIG_fail;
16343 swig_obj[0] = args;
16344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16345 if (!SWIG_IsOK(res1)) {
16346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16347 }
16348 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 result = (bool)(arg1)->HasPOV();
16352 wxPyEndAllowThreads(__tstate);
16353 if (PyErr_Occurred()) SWIG_fail;
16354 }
16355 {
16356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16357 }
16358 return resultobj;
16359 fail:
16360 return NULL;
16361 }
16362
16363
16364 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16365 PyObject *resultobj = 0;
16366 wxJoystick *arg1 = (wxJoystick *) 0 ;
16367 bool result;
16368 void *argp1 = 0 ;
16369 int res1 = 0 ;
16370 PyObject *swig_obj[1] ;
16371
16372 if (!args) SWIG_fail;
16373 swig_obj[0] = args;
16374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16375 if (!SWIG_IsOK(res1)) {
16376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16377 }
16378 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (bool)(arg1)->HasPOV4Dir();
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 {
16386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16387 }
16388 return resultobj;
16389 fail:
16390 return NULL;
16391 }
16392
16393
16394 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16395 PyObject *resultobj = 0;
16396 wxJoystick *arg1 = (wxJoystick *) 0 ;
16397 bool result;
16398 void *argp1 = 0 ;
16399 int res1 = 0 ;
16400 PyObject *swig_obj[1] ;
16401
16402 if (!args) SWIG_fail;
16403 swig_obj[0] = args;
16404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16405 if (!SWIG_IsOK(res1)) {
16406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16407 }
16408 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = (bool)(arg1)->HasPOVCTS();
16412 wxPyEndAllowThreads(__tstate);
16413 if (PyErr_Occurred()) SWIG_fail;
16414 }
16415 {
16416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16417 }
16418 return resultobj;
16419 fail:
16420 return NULL;
16421 }
16422
16423
16424 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16425 PyObject *resultobj = 0;
16426 wxJoystick *arg1 = (wxJoystick *) 0 ;
16427 wxWindow *arg2 = (wxWindow *) 0 ;
16428 int arg3 = (int) 0 ;
16429 bool result;
16430 void *argp1 = 0 ;
16431 int res1 = 0 ;
16432 void *argp2 = 0 ;
16433 int res2 = 0 ;
16434 int val3 ;
16435 int ecode3 = 0 ;
16436 PyObject * obj0 = 0 ;
16437 PyObject * obj1 = 0 ;
16438 PyObject * obj2 = 0 ;
16439 char * kwnames[] = {
16440 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16441 };
16442
16443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16445 if (!SWIG_IsOK(res1)) {
16446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16447 }
16448 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16450 if (!SWIG_IsOK(res2)) {
16451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16452 }
16453 arg2 = reinterpret_cast< wxWindow * >(argp2);
16454 if (obj2) {
16455 ecode3 = SWIG_AsVal_int(obj2, &val3);
16456 if (!SWIG_IsOK(ecode3)) {
16457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16458 }
16459 arg3 = static_cast< int >(val3);
16460 }
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = (bool)(arg1)->SetCapture(arg2,arg3);
16464 wxPyEndAllowThreads(__tstate);
16465 if (PyErr_Occurred()) SWIG_fail;
16466 }
16467 {
16468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16469 }
16470 return resultobj;
16471 fail:
16472 return NULL;
16473 }
16474
16475
16476 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16477 PyObject *resultobj = 0;
16478 wxJoystick *arg1 = (wxJoystick *) 0 ;
16479 bool result;
16480 void *argp1 = 0 ;
16481 int res1 = 0 ;
16482 PyObject *swig_obj[1] ;
16483
16484 if (!args) SWIG_fail;
16485 swig_obj[0] = args;
16486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16487 if (!SWIG_IsOK(res1)) {
16488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16489 }
16490 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (bool)(arg1)->ReleaseCapture();
16494 wxPyEndAllowThreads(__tstate);
16495 if (PyErr_Occurred()) SWIG_fail;
16496 }
16497 {
16498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16499 }
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16507 PyObject *obj;
16508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16509 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16510 return SWIG_Py_Void();
16511 }
16512
16513 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16514 return SWIG_Python_InitShadowInstance(args);
16515 }
16516
16517 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj = 0;
16519 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16520 int arg2 = (int) 0 ;
16521 int arg3 = (int) wxJOYSTICK1 ;
16522 int arg4 = (int) 0 ;
16523 wxJoystickEvent *result = 0 ;
16524 int val1 ;
16525 int ecode1 = 0 ;
16526 int val2 ;
16527 int ecode2 = 0 ;
16528 int val3 ;
16529 int ecode3 = 0 ;
16530 int val4 ;
16531 int ecode4 = 0 ;
16532 PyObject * obj0 = 0 ;
16533 PyObject * obj1 = 0 ;
16534 PyObject * obj2 = 0 ;
16535 PyObject * obj3 = 0 ;
16536 char * kwnames[] = {
16537 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16538 };
16539
16540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16541 if (obj0) {
16542 ecode1 = SWIG_AsVal_int(obj0, &val1);
16543 if (!SWIG_IsOK(ecode1)) {
16544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16545 }
16546 arg1 = static_cast< wxEventType >(val1);
16547 }
16548 if (obj1) {
16549 ecode2 = SWIG_AsVal_int(obj1, &val2);
16550 if (!SWIG_IsOK(ecode2)) {
16551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16552 }
16553 arg2 = static_cast< int >(val2);
16554 }
16555 if (obj2) {
16556 ecode3 = SWIG_AsVal_int(obj2, &val3);
16557 if (!SWIG_IsOK(ecode3)) {
16558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16559 }
16560 arg3 = static_cast< int >(val3);
16561 }
16562 if (obj3) {
16563 ecode4 = SWIG_AsVal_int(obj3, &val4);
16564 if (!SWIG_IsOK(ecode4)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16566 }
16567 arg4 = static_cast< int >(val4);
16568 }
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16583 PyObject *resultobj = 0;
16584 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16585 wxPoint result;
16586 void *argp1 = 0 ;
16587 int res1 = 0 ;
16588 PyObject *swig_obj[1] ;
16589
16590 if (!args) SWIG_fail;
16591 swig_obj[0] = args;
16592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16593 if (!SWIG_IsOK(res1)) {
16594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16595 }
16596 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16604 return resultobj;
16605 fail:
16606 return NULL;
16607 }
16608
16609
16610 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16611 PyObject *resultobj = 0;
16612 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16613 int result;
16614 void *argp1 = 0 ;
16615 int res1 = 0 ;
16616 PyObject *swig_obj[1] ;
16617
16618 if (!args) SWIG_fail;
16619 swig_obj[0] = args;
16620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16621 if (!SWIG_IsOK(res1)) {
16622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16623 }
16624 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16625 {
16626 PyThreadState* __tstate = wxPyBeginAllowThreads();
16627 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16628 wxPyEndAllowThreads(__tstate);
16629 if (PyErr_Occurred()) SWIG_fail;
16630 }
16631 resultobj = SWIG_From_int(static_cast< int >(result));
16632 return resultobj;
16633 fail:
16634 return NULL;
16635 }
16636
16637
16638 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16639 PyObject *resultobj = 0;
16640 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16641 int result;
16642 void *argp1 = 0 ;
16643 int res1 = 0 ;
16644 PyObject *swig_obj[1] ;
16645
16646 if (!args) SWIG_fail;
16647 swig_obj[0] = args;
16648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16649 if (!SWIG_IsOK(res1)) {
16650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16651 }
16652 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16653 {
16654 PyThreadState* __tstate = wxPyBeginAllowThreads();
16655 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 resultobj = SWIG_From_int(static_cast< int >(result));
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16667 PyObject *resultobj = 0;
16668 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16669 int result;
16670 void *argp1 = 0 ;
16671 int res1 = 0 ;
16672 PyObject *swig_obj[1] ;
16673
16674 if (!args) SWIG_fail;
16675 swig_obj[0] = args;
16676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16677 if (!SWIG_IsOK(res1)) {
16678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16679 }
16680 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16681 {
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 resultobj = SWIG_From_int(static_cast< int >(result));
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16695 PyObject *resultobj = 0;
16696 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16697 int result;
16698 void *argp1 = 0 ;
16699 int res1 = 0 ;
16700 PyObject *swig_obj[1] ;
16701
16702 if (!args) SWIG_fail;
16703 swig_obj[0] = args;
16704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16705 if (!SWIG_IsOK(res1)) {
16706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16707 }
16708 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_From_int(static_cast< int >(result));
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj = 0;
16724 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16725 int arg2 ;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 int val2 ;
16729 int ecode2 = 0 ;
16730 PyObject * obj0 = 0 ;
16731 PyObject * obj1 = 0 ;
16732 char * kwnames[] = {
16733 (char *) "self",(char *) "stick", NULL
16734 };
16735
16736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16738 if (!SWIG_IsOK(res1)) {
16739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16740 }
16741 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16742 ecode2 = SWIG_AsVal_int(obj1, &val2);
16743 if (!SWIG_IsOK(ecode2)) {
16744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16745 }
16746 arg2 = static_cast< int >(val2);
16747 {
16748 PyThreadState* __tstate = wxPyBeginAllowThreads();
16749 (arg1)->SetJoystick(arg2);
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 resultobj = SWIG_Py_Void();
16754 return resultobj;
16755 fail:
16756 return NULL;
16757 }
16758
16759
16760 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16761 PyObject *resultobj = 0;
16762 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16763 int arg2 ;
16764 void *argp1 = 0 ;
16765 int res1 = 0 ;
16766 int val2 ;
16767 int ecode2 = 0 ;
16768 PyObject * obj0 = 0 ;
16769 PyObject * obj1 = 0 ;
16770 char * kwnames[] = {
16771 (char *) "self",(char *) "state", NULL
16772 };
16773
16774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16776 if (!SWIG_IsOK(res1)) {
16777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16778 }
16779 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16780 ecode2 = SWIG_AsVal_int(obj1, &val2);
16781 if (!SWIG_IsOK(ecode2)) {
16782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16783 }
16784 arg2 = static_cast< int >(val2);
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 (arg1)->SetButtonState(arg2);
16788 wxPyEndAllowThreads(__tstate);
16789 if (PyErr_Occurred()) SWIG_fail;
16790 }
16791 resultobj = SWIG_Py_Void();
16792 return resultobj;
16793 fail:
16794 return NULL;
16795 }
16796
16797
16798 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16799 PyObject *resultobj = 0;
16800 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16801 int arg2 ;
16802 void *argp1 = 0 ;
16803 int res1 = 0 ;
16804 int val2 ;
16805 int ecode2 = 0 ;
16806 PyObject * obj0 = 0 ;
16807 PyObject * obj1 = 0 ;
16808 char * kwnames[] = {
16809 (char *) "self",(char *) "change", NULL
16810 };
16811
16812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16814 if (!SWIG_IsOK(res1)) {
16815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16816 }
16817 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16818 ecode2 = SWIG_AsVal_int(obj1, &val2);
16819 if (!SWIG_IsOK(ecode2)) {
16820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16821 }
16822 arg2 = static_cast< int >(val2);
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 (arg1)->SetButtonChange(arg2);
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 resultobj = SWIG_Py_Void();
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj = 0;
16838 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16839 wxPoint *arg2 = 0 ;
16840 void *argp1 = 0 ;
16841 int res1 = 0 ;
16842 wxPoint temp2 ;
16843 PyObject * obj0 = 0 ;
16844 PyObject * obj1 = 0 ;
16845 char * kwnames[] = {
16846 (char *) "self",(char *) "pos", NULL
16847 };
16848
16849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16851 if (!SWIG_IsOK(res1)) {
16852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16853 }
16854 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16855 {
16856 arg2 = &temp2;
16857 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16858 }
16859 {
16860 PyThreadState* __tstate = wxPyBeginAllowThreads();
16861 (arg1)->SetPosition((wxPoint const &)*arg2);
16862 wxPyEndAllowThreads(__tstate);
16863 if (PyErr_Occurred()) SWIG_fail;
16864 }
16865 resultobj = SWIG_Py_Void();
16866 return resultobj;
16867 fail:
16868 return NULL;
16869 }
16870
16871
16872 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16873 PyObject *resultobj = 0;
16874 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16875 int arg2 ;
16876 void *argp1 = 0 ;
16877 int res1 = 0 ;
16878 int val2 ;
16879 int ecode2 = 0 ;
16880 PyObject * obj0 = 0 ;
16881 PyObject * obj1 = 0 ;
16882 char * kwnames[] = {
16883 (char *) "self",(char *) "zPos", NULL
16884 };
16885
16886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16888 if (!SWIG_IsOK(res1)) {
16889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16890 }
16891 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16892 ecode2 = SWIG_AsVal_int(obj1, &val2);
16893 if (!SWIG_IsOK(ecode2)) {
16894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16895 }
16896 arg2 = static_cast< int >(val2);
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 (arg1)->SetZPosition(arg2);
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 resultobj = SWIG_Py_Void();
16904 return resultobj;
16905 fail:
16906 return NULL;
16907 }
16908
16909
16910 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16911 PyObject *resultobj = 0;
16912 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16913 bool result;
16914 void *argp1 = 0 ;
16915 int res1 = 0 ;
16916 PyObject *swig_obj[1] ;
16917
16918 if (!args) SWIG_fail;
16919 swig_obj[0] = args;
16920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16921 if (!SWIG_IsOK(res1)) {
16922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16923 }
16924 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 {
16932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16933 }
16934 return resultobj;
16935 fail:
16936 return NULL;
16937 }
16938
16939
16940 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16941 PyObject *resultobj = 0;
16942 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16943 bool result;
16944 void *argp1 = 0 ;
16945 int res1 = 0 ;
16946 PyObject *swig_obj[1] ;
16947
16948 if (!args) SWIG_fail;
16949 swig_obj[0] = args;
16950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16951 if (!SWIG_IsOK(res1)) {
16952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16953 }
16954 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 {
16962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16963 }
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16971 PyObject *resultobj = 0;
16972 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16973 bool result;
16974 void *argp1 = 0 ;
16975 int res1 = 0 ;
16976 PyObject *swig_obj[1] ;
16977
16978 if (!args) SWIG_fail;
16979 swig_obj[0] = args;
16980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16981 if (!SWIG_IsOK(res1)) {
16982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16983 }
16984 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 {
16992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16993 }
16994 return resultobj;
16995 fail:
16996 return NULL;
16997 }
16998
16999
17000 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17001 PyObject *resultobj = 0;
17002 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17003 int arg2 = (int) wxJOY_BUTTON_ANY ;
17004 bool result;
17005 void *argp1 = 0 ;
17006 int res1 = 0 ;
17007 int val2 ;
17008 int ecode2 = 0 ;
17009 PyObject * obj0 = 0 ;
17010 PyObject * obj1 = 0 ;
17011 char * kwnames[] = {
17012 (char *) "self",(char *) "but", NULL
17013 };
17014
17015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17017 if (!SWIG_IsOK(res1)) {
17018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17019 }
17020 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17021 if (obj1) {
17022 ecode2 = SWIG_AsVal_int(obj1, &val2);
17023 if (!SWIG_IsOK(ecode2)) {
17024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17025 }
17026 arg2 = static_cast< int >(val2);
17027 }
17028 {
17029 PyThreadState* __tstate = wxPyBeginAllowThreads();
17030 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17031 wxPyEndAllowThreads(__tstate);
17032 if (PyErr_Occurred()) SWIG_fail;
17033 }
17034 {
17035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17036 }
17037 return resultobj;
17038 fail:
17039 return NULL;
17040 }
17041
17042
17043 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17044 PyObject *resultobj = 0;
17045 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17046 int arg2 = (int) wxJOY_BUTTON_ANY ;
17047 bool result;
17048 void *argp1 = 0 ;
17049 int res1 = 0 ;
17050 int val2 ;
17051 int ecode2 = 0 ;
17052 PyObject * obj0 = 0 ;
17053 PyObject * obj1 = 0 ;
17054 char * kwnames[] = {
17055 (char *) "self",(char *) "but", NULL
17056 };
17057
17058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17060 if (!SWIG_IsOK(res1)) {
17061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17062 }
17063 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17064 if (obj1) {
17065 ecode2 = SWIG_AsVal_int(obj1, &val2);
17066 if (!SWIG_IsOK(ecode2)) {
17067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17068 }
17069 arg2 = static_cast< int >(val2);
17070 }
17071 {
17072 PyThreadState* __tstate = wxPyBeginAllowThreads();
17073 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 {
17078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17079 }
17080 return resultobj;
17081 fail:
17082 return NULL;
17083 }
17084
17085
17086 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj = 0;
17088 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17089 int arg2 = (int) wxJOY_BUTTON_ANY ;
17090 bool result;
17091 void *argp1 = 0 ;
17092 int res1 = 0 ;
17093 int val2 ;
17094 int ecode2 = 0 ;
17095 PyObject * obj0 = 0 ;
17096 PyObject * obj1 = 0 ;
17097 char * kwnames[] = {
17098 (char *) "self",(char *) "but", NULL
17099 };
17100
17101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17103 if (!SWIG_IsOK(res1)) {
17104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17105 }
17106 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17107 if (obj1) {
17108 ecode2 = SWIG_AsVal_int(obj1, &val2);
17109 if (!SWIG_IsOK(ecode2)) {
17110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17111 }
17112 arg2 = static_cast< int >(val2);
17113 }
17114 {
17115 PyThreadState* __tstate = wxPyBeginAllowThreads();
17116 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17117 wxPyEndAllowThreads(__tstate);
17118 if (PyErr_Occurred()) SWIG_fail;
17119 }
17120 {
17121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17122 }
17123 return resultobj;
17124 fail:
17125 return NULL;
17126 }
17127
17128
17129 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17130 PyObject *obj;
17131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17132 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17133 return SWIG_Py_Void();
17134 }
17135
17136 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17137 return SWIG_Python_InitShadowInstance(args);
17138 }
17139
17140 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj = 0;
17142 wxString const &arg1_defvalue = wxPyEmptyString ;
17143 wxString *arg1 = (wxString *) &arg1_defvalue ;
17144 wxSound *result = 0 ;
17145 bool temp1 = false ;
17146 PyObject * obj0 = 0 ;
17147 char * kwnames[] = {
17148 (char *) "fileName", NULL
17149 };
17150
17151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17152 if (obj0) {
17153 {
17154 arg1 = wxString_in_helper(obj0);
17155 if (arg1 == NULL) SWIG_fail;
17156 temp1 = true;
17157 }
17158 }
17159 {
17160 if (!wxPyCheckForApp()) SWIG_fail;
17161 PyThreadState* __tstate = wxPyBeginAllowThreads();
17162 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17163 wxPyEndAllowThreads(__tstate);
17164 if (PyErr_Occurred()) SWIG_fail;
17165 }
17166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17167 {
17168 if (temp1)
17169 delete arg1;
17170 }
17171 return resultobj;
17172 fail:
17173 {
17174 if (temp1)
17175 delete arg1;
17176 }
17177 return NULL;
17178 }
17179
17180
17181 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj = 0;
17183 PyObject *arg1 = (PyObject *) 0 ;
17184 wxSound *result = 0 ;
17185 PyObject * obj0 = 0 ;
17186 char * kwnames[] = {
17187 (char *) "data", NULL
17188 };
17189
17190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17191 arg1 = obj0;
17192 {
17193 if (!wxPyCheckForApp()) SWIG_fail;
17194 PyThreadState* __tstate = wxPyBeginAllowThreads();
17195 result = (wxSound *)new_wxSound(arg1);
17196 wxPyEndAllowThreads(__tstate);
17197 if (PyErr_Occurred()) SWIG_fail;
17198 }
17199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17200 return resultobj;
17201 fail:
17202 return NULL;
17203 }
17204
17205
17206 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17207 PyObject *resultobj = 0;
17208 wxSound *arg1 = (wxSound *) 0 ;
17209 void *argp1 = 0 ;
17210 int res1 = 0 ;
17211 PyObject *swig_obj[1] ;
17212
17213 if (!args) SWIG_fail;
17214 swig_obj[0] = args;
17215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17216 if (!SWIG_IsOK(res1)) {
17217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17218 }
17219 arg1 = reinterpret_cast< wxSound * >(argp1);
17220 {
17221 PyThreadState* __tstate = wxPyBeginAllowThreads();
17222 delete arg1;
17223
17224 wxPyEndAllowThreads(__tstate);
17225 if (PyErr_Occurred()) SWIG_fail;
17226 }
17227 resultobj = SWIG_Py_Void();
17228 return resultobj;
17229 fail:
17230 return NULL;
17231 }
17232
17233
17234 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17235 PyObject *resultobj = 0;
17236 wxSound *arg1 = (wxSound *) 0 ;
17237 wxString *arg2 = 0 ;
17238 bool result;
17239 void *argp1 = 0 ;
17240 int res1 = 0 ;
17241 bool temp2 = false ;
17242 PyObject * obj0 = 0 ;
17243 PyObject * obj1 = 0 ;
17244 char * kwnames[] = {
17245 (char *) "self",(char *) "fileName", NULL
17246 };
17247
17248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17250 if (!SWIG_IsOK(res1)) {
17251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17252 }
17253 arg1 = reinterpret_cast< wxSound * >(argp1);
17254 {
17255 arg2 = wxString_in_helper(obj1);
17256 if (arg2 == NULL) SWIG_fail;
17257 temp2 = true;
17258 }
17259 {
17260 PyThreadState* __tstate = wxPyBeginAllowThreads();
17261 result = (bool)(arg1)->Create((wxString const &)*arg2);
17262 wxPyEndAllowThreads(__tstate);
17263 if (PyErr_Occurred()) SWIG_fail;
17264 }
17265 {
17266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17267 }
17268 {
17269 if (temp2)
17270 delete arg2;
17271 }
17272 return resultobj;
17273 fail:
17274 {
17275 if (temp2)
17276 delete arg2;
17277 }
17278 return NULL;
17279 }
17280
17281
17282 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj = 0;
17284 wxSound *arg1 = (wxSound *) 0 ;
17285 PyObject *arg2 = (PyObject *) 0 ;
17286 bool result;
17287 void *argp1 = 0 ;
17288 int res1 = 0 ;
17289 PyObject * obj0 = 0 ;
17290 PyObject * obj1 = 0 ;
17291 char * kwnames[] = {
17292 (char *) "self",(char *) "data", NULL
17293 };
17294
17295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17297 if (!SWIG_IsOK(res1)) {
17298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17299 }
17300 arg1 = reinterpret_cast< wxSound * >(argp1);
17301 arg2 = obj1;
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (bool)wxSound_CreateFromData(arg1,arg2);
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 {
17309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17310 }
17311 return resultobj;
17312 fail:
17313 return NULL;
17314 }
17315
17316
17317 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17318 PyObject *resultobj = 0;
17319 wxSound *arg1 = (wxSound *) 0 ;
17320 bool result;
17321 void *argp1 = 0 ;
17322 int res1 = 0 ;
17323 PyObject *swig_obj[1] ;
17324
17325 if (!args) SWIG_fail;
17326 swig_obj[0] = args;
17327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17328 if (!SWIG_IsOK(res1)) {
17329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17330 }
17331 arg1 = reinterpret_cast< wxSound * >(argp1);
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 result = (bool)(arg1)->IsOk();
17335 wxPyEndAllowThreads(__tstate);
17336 if (PyErr_Occurred()) SWIG_fail;
17337 }
17338 {
17339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17340 }
17341 return resultobj;
17342 fail:
17343 return NULL;
17344 }
17345
17346
17347 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17348 PyObject *resultobj = 0;
17349 wxSound *arg1 = (wxSound *) 0 ;
17350 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17351 bool result;
17352 void *argp1 = 0 ;
17353 int res1 = 0 ;
17354 unsigned int val2 ;
17355 int ecode2 = 0 ;
17356 PyObject * obj0 = 0 ;
17357 PyObject * obj1 = 0 ;
17358 char * kwnames[] = {
17359 (char *) "self",(char *) "flags", NULL
17360 };
17361
17362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17364 if (!SWIG_IsOK(res1)) {
17365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17366 }
17367 arg1 = reinterpret_cast< wxSound * >(argp1);
17368 if (obj1) {
17369 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17370 if (!SWIG_IsOK(ecode2)) {
17371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17372 }
17373 arg2 = static_cast< unsigned int >(val2);
17374 }
17375 {
17376 if (!wxPyCheckForApp()) SWIG_fail;
17377 PyThreadState* __tstate = wxPyBeginAllowThreads();
17378 result = (bool)((wxSound const *)arg1)->Play(arg2);
17379 wxPyEndAllowThreads(__tstate);
17380 if (PyErr_Occurred()) SWIG_fail;
17381 }
17382 {
17383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17384 }
17385 return resultobj;
17386 fail:
17387 return NULL;
17388 }
17389
17390
17391 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj = 0;
17393 wxString *arg1 = 0 ;
17394 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17395 bool result;
17396 bool temp1 = false ;
17397 unsigned int val2 ;
17398 int ecode2 = 0 ;
17399 PyObject * obj0 = 0 ;
17400 PyObject * obj1 = 0 ;
17401 char * kwnames[] = {
17402 (char *) "filename",(char *) "flags", NULL
17403 };
17404
17405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17406 {
17407 arg1 = wxString_in_helper(obj0);
17408 if (arg1 == NULL) SWIG_fail;
17409 temp1 = true;
17410 }
17411 if (obj1) {
17412 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17413 if (!SWIG_IsOK(ecode2)) {
17414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17415 }
17416 arg2 = static_cast< unsigned int >(val2);
17417 }
17418 {
17419 if (!wxPyCheckForApp()) SWIG_fail;
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17427 }
17428 {
17429 if (temp1)
17430 delete arg1;
17431 }
17432 return resultobj;
17433 fail:
17434 {
17435 if (temp1)
17436 delete arg1;
17437 }
17438 return NULL;
17439 }
17440
17441
17442 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17443 PyObject *resultobj = 0;
17444
17445 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17446 {
17447 if (!wxPyCheckForApp()) SWIG_fail;
17448 PyThreadState* __tstate = wxPyBeginAllowThreads();
17449 wxSound::Stop();
17450 wxPyEndAllowThreads(__tstate);
17451 if (PyErr_Occurred()) SWIG_fail;
17452 }
17453 resultobj = SWIG_Py_Void();
17454 return resultobj;
17455 fail:
17456 return NULL;
17457 }
17458
17459
17460 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17461 PyObject *obj;
17462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17463 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17464 return SWIG_Py_Void();
17465 }
17466
17467 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 return SWIG_Python_InitShadowInstance(args);
17469 }
17470
17471 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17472 PyObject *resultobj = 0;
17473 wxString *arg1 = 0 ;
17474 wxString *arg2 = 0 ;
17475 wxString *arg3 = 0 ;
17476 wxString *arg4 = 0 ;
17477 wxFileTypeInfo *result = 0 ;
17478 bool temp1 = false ;
17479 bool temp2 = false ;
17480 bool temp3 = false ;
17481 bool temp4 = false ;
17482 PyObject * obj0 = 0 ;
17483 PyObject * obj1 = 0 ;
17484 PyObject * obj2 = 0 ;
17485 PyObject * obj3 = 0 ;
17486 char * kwnames[] = {
17487 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17488 };
17489
17490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17491 {
17492 arg1 = wxString_in_helper(obj0);
17493 if (arg1 == NULL) SWIG_fail;
17494 temp1 = true;
17495 }
17496 {
17497 arg2 = wxString_in_helper(obj1);
17498 if (arg2 == NULL) SWIG_fail;
17499 temp2 = true;
17500 }
17501 {
17502 arg3 = wxString_in_helper(obj2);
17503 if (arg3 == NULL) SWIG_fail;
17504 temp3 = true;
17505 }
17506 {
17507 arg4 = wxString_in_helper(obj3);
17508 if (arg4 == NULL) SWIG_fail;
17509 temp4 = true;
17510 }
17511 {
17512 PyThreadState* __tstate = wxPyBeginAllowThreads();
17513 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17518 {
17519 if (temp1)
17520 delete arg1;
17521 }
17522 {
17523 if (temp2)
17524 delete arg2;
17525 }
17526 {
17527 if (temp3)
17528 delete arg3;
17529 }
17530 {
17531 if (temp4)
17532 delete arg4;
17533 }
17534 return resultobj;
17535 fail:
17536 {
17537 if (temp1)
17538 delete arg1;
17539 }
17540 {
17541 if (temp2)
17542 delete arg2;
17543 }
17544 {
17545 if (temp3)
17546 delete arg3;
17547 }
17548 {
17549 if (temp4)
17550 delete arg4;
17551 }
17552 return NULL;
17553 }
17554
17555
17556 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj = 0;
17558 wxArrayString *arg1 = 0 ;
17559 wxFileTypeInfo *result = 0 ;
17560 bool temp1 = false ;
17561 PyObject * obj0 = 0 ;
17562 char * kwnames[] = {
17563 (char *) "sArray", NULL
17564 };
17565
17566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17567 {
17568 if (! PySequence_Check(obj0)) {
17569 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17570 SWIG_fail;
17571 }
17572 arg1 = new wxArrayString;
17573 temp1 = true;
17574 int i, len=PySequence_Length(obj0);
17575 for (i=0; i<len; i++) {
17576 PyObject* item = PySequence_GetItem(obj0, i);
17577 wxString* s = wxString_in_helper(item);
17578 if (PyErr_Occurred()) SWIG_fail;
17579 arg1->Add(*s);
17580 delete s;
17581 Py_DECREF(item);
17582 }
17583 }
17584 {
17585 PyThreadState* __tstate = wxPyBeginAllowThreads();
17586 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17587 wxPyEndAllowThreads(__tstate);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 }
17590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17591 {
17592 if (temp1) delete arg1;
17593 }
17594 return resultobj;
17595 fail:
17596 {
17597 if (temp1) delete arg1;
17598 }
17599 return NULL;
17600 }
17601
17602
17603 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17604 PyObject *resultobj = 0;
17605 wxFileTypeInfo *result = 0 ;
17606
17607 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17622 PyObject *resultobj = 0;
17623 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17624 bool result;
17625 void *argp1 = 0 ;
17626 int res1 = 0 ;
17627 PyObject *swig_obj[1] ;
17628
17629 if (!args) SWIG_fail;
17630 swig_obj[0] = args;
17631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17632 if (!SWIG_IsOK(res1)) {
17633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17634 }
17635 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17636 {
17637 PyThreadState* __tstate = wxPyBeginAllowThreads();
17638 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 {
17643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17644 }
17645 return resultobj;
17646 fail:
17647 return NULL;
17648 }
17649
17650
17651 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj = 0;
17653 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17654 wxString *arg2 = 0 ;
17655 int arg3 = (int) 0 ;
17656 void *argp1 = 0 ;
17657 int res1 = 0 ;
17658 bool temp2 = false ;
17659 int val3 ;
17660 int ecode3 = 0 ;
17661 PyObject * obj0 = 0 ;
17662 PyObject * obj1 = 0 ;
17663 PyObject * obj2 = 0 ;
17664 char * kwnames[] = {
17665 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17666 };
17667
17668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17670 if (!SWIG_IsOK(res1)) {
17671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17672 }
17673 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17674 {
17675 arg2 = wxString_in_helper(obj1);
17676 if (arg2 == NULL) SWIG_fail;
17677 temp2 = true;
17678 }
17679 if (obj2) {
17680 ecode3 = SWIG_AsVal_int(obj2, &val3);
17681 if (!SWIG_IsOK(ecode3)) {
17682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17683 }
17684 arg3 = static_cast< int >(val3);
17685 }
17686 {
17687 PyThreadState* __tstate = wxPyBeginAllowThreads();
17688 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17689 wxPyEndAllowThreads(__tstate);
17690 if (PyErr_Occurred()) SWIG_fail;
17691 }
17692 resultobj = SWIG_Py_Void();
17693 {
17694 if (temp2)
17695 delete arg2;
17696 }
17697 return resultobj;
17698 fail:
17699 {
17700 if (temp2)
17701 delete arg2;
17702 }
17703 return NULL;
17704 }
17705
17706
17707 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17708 PyObject *resultobj = 0;
17709 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17710 wxString *arg2 = 0 ;
17711 void *argp1 = 0 ;
17712 int res1 = 0 ;
17713 bool temp2 = false ;
17714 PyObject * obj0 = 0 ;
17715 PyObject * obj1 = 0 ;
17716 char * kwnames[] = {
17717 (char *) "self",(char *) "shortDesc", NULL
17718 };
17719
17720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17722 if (!SWIG_IsOK(res1)) {
17723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17724 }
17725 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17726 {
17727 arg2 = wxString_in_helper(obj1);
17728 if (arg2 == NULL) SWIG_fail;
17729 temp2 = true;
17730 }
17731 {
17732 PyThreadState* __tstate = wxPyBeginAllowThreads();
17733 (arg1)->SetShortDesc((wxString const &)*arg2);
17734 wxPyEndAllowThreads(__tstate);
17735 if (PyErr_Occurred()) SWIG_fail;
17736 }
17737 resultobj = SWIG_Py_Void();
17738 {
17739 if (temp2)
17740 delete arg2;
17741 }
17742 return resultobj;
17743 fail:
17744 {
17745 if (temp2)
17746 delete arg2;
17747 }
17748 return NULL;
17749 }
17750
17751
17752 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17753 PyObject *resultobj = 0;
17754 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17755 wxString *result = 0 ;
17756 void *argp1 = 0 ;
17757 int res1 = 0 ;
17758 PyObject *swig_obj[1] ;
17759
17760 if (!args) SWIG_fail;
17761 swig_obj[0] = args;
17762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17763 if (!SWIG_IsOK(res1)) {
17764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17765 }
17766 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17767 {
17768 PyThreadState* __tstate = wxPyBeginAllowThreads();
17769 {
17770 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17771 result = (wxString *) &_result_ref;
17772 }
17773 wxPyEndAllowThreads(__tstate);
17774 if (PyErr_Occurred()) SWIG_fail;
17775 }
17776 {
17777 #if wxUSE_UNICODE
17778 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17779 #else
17780 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17781 #endif
17782 }
17783 return resultobj;
17784 fail:
17785 return NULL;
17786 }
17787
17788
17789 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17790 PyObject *resultobj = 0;
17791 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17792 wxString *result = 0 ;
17793 void *argp1 = 0 ;
17794 int res1 = 0 ;
17795 PyObject *swig_obj[1] ;
17796
17797 if (!args) SWIG_fail;
17798 swig_obj[0] = args;
17799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17800 if (!SWIG_IsOK(res1)) {
17801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17802 }
17803 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17804 {
17805 PyThreadState* __tstate = wxPyBeginAllowThreads();
17806 {
17807 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17808 result = (wxString *) &_result_ref;
17809 }
17810 wxPyEndAllowThreads(__tstate);
17811 if (PyErr_Occurred()) SWIG_fail;
17812 }
17813 {
17814 #if wxUSE_UNICODE
17815 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17816 #else
17817 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17818 #endif
17819 }
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17827 PyObject *resultobj = 0;
17828 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17829 wxString *result = 0 ;
17830 void *argp1 = 0 ;
17831 int res1 = 0 ;
17832 PyObject *swig_obj[1] ;
17833
17834 if (!args) SWIG_fail;
17835 swig_obj[0] = args;
17836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17837 if (!SWIG_IsOK(res1)) {
17838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17839 }
17840 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 {
17844 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17845 result = (wxString *) &_result_ref;
17846 }
17847 wxPyEndAllowThreads(__tstate);
17848 if (PyErr_Occurred()) SWIG_fail;
17849 }
17850 {
17851 #if wxUSE_UNICODE
17852 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17853 #else
17854 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17855 #endif
17856 }
17857 return resultobj;
17858 fail:
17859 return NULL;
17860 }
17861
17862
17863 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17864 PyObject *resultobj = 0;
17865 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17866 wxString *result = 0 ;
17867 void *argp1 = 0 ;
17868 int res1 = 0 ;
17869 PyObject *swig_obj[1] ;
17870
17871 if (!args) SWIG_fail;
17872 swig_obj[0] = args;
17873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17874 if (!SWIG_IsOK(res1)) {
17875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17876 }
17877 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17878 {
17879 PyThreadState* __tstate = wxPyBeginAllowThreads();
17880 {
17881 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17882 result = (wxString *) &_result_ref;
17883 }
17884 wxPyEndAllowThreads(__tstate);
17885 if (PyErr_Occurred()) SWIG_fail;
17886 }
17887 {
17888 #if wxUSE_UNICODE
17889 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17890 #else
17891 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17892 #endif
17893 }
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17901 PyObject *resultobj = 0;
17902 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17903 wxString *result = 0 ;
17904 void *argp1 = 0 ;
17905 int res1 = 0 ;
17906 PyObject *swig_obj[1] ;
17907
17908 if (!args) SWIG_fail;
17909 swig_obj[0] = args;
17910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17911 if (!SWIG_IsOK(res1)) {
17912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17913 }
17914 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17915 {
17916 PyThreadState* __tstate = wxPyBeginAllowThreads();
17917 {
17918 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17919 result = (wxString *) &_result_ref;
17920 }
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 {
17925 #if wxUSE_UNICODE
17926 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17927 #else
17928 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17929 #endif
17930 }
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17938 PyObject *resultobj = 0;
17939 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17940 wxArrayString *result = 0 ;
17941 void *argp1 = 0 ;
17942 int res1 = 0 ;
17943 PyObject *swig_obj[1] ;
17944
17945 if (!args) SWIG_fail;
17946 swig_obj[0] = args;
17947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17948 if (!SWIG_IsOK(res1)) {
17949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17950 }
17951 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17952 {
17953 PyThreadState* __tstate = wxPyBeginAllowThreads();
17954 {
17955 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17956 result = (wxArrayString *) &_result_ref;
17957 }
17958 wxPyEndAllowThreads(__tstate);
17959 if (PyErr_Occurred()) SWIG_fail;
17960 }
17961 {
17962 resultobj = wxArrayString2PyList_helper(*result);
17963 }
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17971 PyObject *resultobj = 0;
17972 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17973 size_t result;
17974 void *argp1 = 0 ;
17975 int res1 = 0 ;
17976 PyObject *swig_obj[1] ;
17977
17978 if (!args) SWIG_fail;
17979 swig_obj[0] = args;
17980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17981 if (!SWIG_IsOK(res1)) {
17982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17983 }
17984 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17985 {
17986 PyThreadState* __tstate = wxPyBeginAllowThreads();
17987 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17992 return resultobj;
17993 fail:
17994 return NULL;
17995 }
17996
17997
17998 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17999 PyObject *resultobj = 0;
18000 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18001 wxString *result = 0 ;
18002 void *argp1 = 0 ;
18003 int res1 = 0 ;
18004 PyObject *swig_obj[1] ;
18005
18006 if (!args) SWIG_fail;
18007 swig_obj[0] = args;
18008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18009 if (!SWIG_IsOK(res1)) {
18010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18011 }
18012 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18013 {
18014 PyThreadState* __tstate = wxPyBeginAllowThreads();
18015 {
18016 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18017 result = (wxString *) &_result_ref;
18018 }
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 {
18023 #if wxUSE_UNICODE
18024 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18025 #else
18026 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18027 #endif
18028 }
18029 return resultobj;
18030 fail:
18031 return NULL;
18032 }
18033
18034
18035 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18036 PyObject *resultobj = 0;
18037 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18038 int result;
18039 void *argp1 = 0 ;
18040 int res1 = 0 ;
18041 PyObject *swig_obj[1] ;
18042
18043 if (!args) SWIG_fail;
18044 swig_obj[0] = args;
18045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18046 if (!SWIG_IsOK(res1)) {
18047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18048 }
18049 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18050 {
18051 PyThreadState* __tstate = wxPyBeginAllowThreads();
18052 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 resultobj = SWIG_From_int(static_cast< int >(result));
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18064 PyObject *obj;
18065 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18066 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18067 return SWIG_Py_Void();
18068 }
18069
18070 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18071 return SWIG_Python_InitShadowInstance(args);
18072 }
18073
18074 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18075 PyObject *resultobj = 0;
18076 wxFileTypeInfo *arg1 = 0 ;
18077 wxFileType *result = 0 ;
18078 void *argp1 = 0 ;
18079 int res1 = 0 ;
18080 PyObject * obj0 = 0 ;
18081 char * kwnames[] = {
18082 (char *) "ftInfo", NULL
18083 };
18084
18085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18086 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18087 if (!SWIG_IsOK(res1)) {
18088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18089 }
18090 if (!argp1) {
18091 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18092 }
18093 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18108 PyObject *resultobj = 0;
18109 wxFileType *arg1 = (wxFileType *) 0 ;
18110 void *argp1 = 0 ;
18111 int res1 = 0 ;
18112 PyObject *swig_obj[1] ;
18113
18114 if (!args) SWIG_fail;
18115 swig_obj[0] = args;
18116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18117 if (!SWIG_IsOK(res1)) {
18118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18119 }
18120 arg1 = reinterpret_cast< wxFileType * >(argp1);
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 delete arg1;
18124
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 resultobj = SWIG_Py_Void();
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxFileType *arg1 = (wxFileType *) 0 ;
18138 PyObject *result = 0 ;
18139 void *argp1 = 0 ;
18140 int res1 = 0 ;
18141 PyObject *swig_obj[1] ;
18142
18143 if (!args) SWIG_fail;
18144 swig_obj[0] = args;
18145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18146 if (!SWIG_IsOK(res1)) {
18147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18148 }
18149 arg1 = reinterpret_cast< wxFileType * >(argp1);
18150 {
18151 PyThreadState* __tstate = wxPyBeginAllowThreads();
18152 result = (PyObject *)wxFileType_GetMimeType(arg1);
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 resultobj = result;
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164 PyObject *resultobj = 0;
18165 wxFileType *arg1 = (wxFileType *) 0 ;
18166 PyObject *result = 0 ;
18167 void *argp1 = 0 ;
18168 int res1 = 0 ;
18169 PyObject *swig_obj[1] ;
18170
18171 if (!args) SWIG_fail;
18172 swig_obj[0] = args;
18173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18174 if (!SWIG_IsOK(res1)) {
18175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18176 }
18177 arg1 = reinterpret_cast< wxFileType * >(argp1);
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 resultobj = result;
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18192 PyObject *resultobj = 0;
18193 wxFileType *arg1 = (wxFileType *) 0 ;
18194 PyObject *result = 0 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 PyObject *swig_obj[1] ;
18198
18199 if (!args) SWIG_fail;
18200 swig_obj[0] = args;
18201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18202 if (!SWIG_IsOK(res1)) {
18203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18204 }
18205 arg1 = reinterpret_cast< wxFileType * >(argp1);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 result = (PyObject *)wxFileType_GetExtensions(arg1);
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = result;
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18220 PyObject *resultobj = 0;
18221 wxFileType *arg1 = (wxFileType *) 0 ;
18222 wxIcon *result = 0 ;
18223 void *argp1 = 0 ;
18224 int res1 = 0 ;
18225 PyObject *swig_obj[1] ;
18226
18227 if (!args) SWIG_fail;
18228 swig_obj[0] = args;
18229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18230 if (!SWIG_IsOK(res1)) {
18231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18232 }
18233 arg1 = reinterpret_cast< wxFileType * >(argp1);
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 result = (wxIcon *)wxFileType_GetIcon(arg1);
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18248 PyObject *resultobj = 0;
18249 wxFileType *arg1 = (wxFileType *) 0 ;
18250 PyObject *result = 0 ;
18251 void *argp1 = 0 ;
18252 int res1 = 0 ;
18253 PyObject *swig_obj[1] ;
18254
18255 if (!args) SWIG_fail;
18256 swig_obj[0] = args;
18257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18258 if (!SWIG_IsOK(res1)) {
18259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18260 }
18261 arg1 = reinterpret_cast< wxFileType * >(argp1);
18262 {
18263 PyThreadState* __tstate = wxPyBeginAllowThreads();
18264 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18265 wxPyEndAllowThreads(__tstate);
18266 if (PyErr_Occurred()) SWIG_fail;
18267 }
18268 resultobj = result;
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18276 PyObject *resultobj = 0;
18277 wxFileType *arg1 = (wxFileType *) 0 ;
18278 PyObject *result = 0 ;
18279 void *argp1 = 0 ;
18280 int res1 = 0 ;
18281 PyObject *swig_obj[1] ;
18282
18283 if (!args) SWIG_fail;
18284 swig_obj[0] = args;
18285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18286 if (!SWIG_IsOK(res1)) {
18287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18288 }
18289 arg1 = reinterpret_cast< wxFileType * >(argp1);
18290 {
18291 PyThreadState* __tstate = wxPyBeginAllowThreads();
18292 result = (PyObject *)wxFileType_GetDescription(arg1);
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 resultobj = result;
18297 return resultobj;
18298 fail:
18299 return NULL;
18300 }
18301
18302
18303 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18304 PyObject *resultobj = 0;
18305 wxFileType *arg1 = (wxFileType *) 0 ;
18306 wxString *arg2 = 0 ;
18307 wxString const &arg3_defvalue = wxPyEmptyString ;
18308 wxString *arg3 = (wxString *) &arg3_defvalue ;
18309 PyObject *result = 0 ;
18310 void *argp1 = 0 ;
18311 int res1 = 0 ;
18312 bool temp2 = false ;
18313 bool temp3 = false ;
18314 PyObject * obj0 = 0 ;
18315 PyObject * obj1 = 0 ;
18316 PyObject * obj2 = 0 ;
18317 char * kwnames[] = {
18318 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18319 };
18320
18321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18323 if (!SWIG_IsOK(res1)) {
18324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18325 }
18326 arg1 = reinterpret_cast< wxFileType * >(argp1);
18327 {
18328 arg2 = wxString_in_helper(obj1);
18329 if (arg2 == NULL) SWIG_fail;
18330 temp2 = true;
18331 }
18332 if (obj2) {
18333 {
18334 arg3 = wxString_in_helper(obj2);
18335 if (arg3 == NULL) SWIG_fail;
18336 temp3 = true;
18337 }
18338 }
18339 {
18340 PyThreadState* __tstate = wxPyBeginAllowThreads();
18341 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18342 wxPyEndAllowThreads(__tstate);
18343 if (PyErr_Occurred()) SWIG_fail;
18344 }
18345 resultobj = result;
18346 {
18347 if (temp2)
18348 delete arg2;
18349 }
18350 {
18351 if (temp3)
18352 delete arg3;
18353 }
18354 return resultobj;
18355 fail:
18356 {
18357 if (temp2)
18358 delete arg2;
18359 }
18360 {
18361 if (temp3)
18362 delete arg3;
18363 }
18364 return NULL;
18365 }
18366
18367
18368 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18369 PyObject *resultobj = 0;
18370 wxFileType *arg1 = (wxFileType *) 0 ;
18371 wxString *arg2 = 0 ;
18372 wxString const &arg3_defvalue = wxPyEmptyString ;
18373 wxString *arg3 = (wxString *) &arg3_defvalue ;
18374 PyObject *result = 0 ;
18375 void *argp1 = 0 ;
18376 int res1 = 0 ;
18377 bool temp2 = false ;
18378 bool temp3 = false ;
18379 PyObject * obj0 = 0 ;
18380 PyObject * obj1 = 0 ;
18381 PyObject * obj2 = 0 ;
18382 char * kwnames[] = {
18383 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18384 };
18385
18386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18388 if (!SWIG_IsOK(res1)) {
18389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18390 }
18391 arg1 = reinterpret_cast< wxFileType * >(argp1);
18392 {
18393 arg2 = wxString_in_helper(obj1);
18394 if (arg2 == NULL) SWIG_fail;
18395 temp2 = true;
18396 }
18397 if (obj2) {
18398 {
18399 arg3 = wxString_in_helper(obj2);
18400 if (arg3 == NULL) SWIG_fail;
18401 temp3 = true;
18402 }
18403 }
18404 {
18405 PyThreadState* __tstate = wxPyBeginAllowThreads();
18406 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18407 wxPyEndAllowThreads(__tstate);
18408 if (PyErr_Occurred()) SWIG_fail;
18409 }
18410 resultobj = result;
18411 {
18412 if (temp2)
18413 delete arg2;
18414 }
18415 {
18416 if (temp3)
18417 delete arg3;
18418 }
18419 return resultobj;
18420 fail:
18421 {
18422 if (temp2)
18423 delete arg2;
18424 }
18425 {
18426 if (temp3)
18427 delete arg3;
18428 }
18429 return NULL;
18430 }
18431
18432
18433 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18434 PyObject *resultobj = 0;
18435 wxFileType *arg1 = (wxFileType *) 0 ;
18436 wxString *arg2 = 0 ;
18437 wxString const &arg3_defvalue = wxPyEmptyString ;
18438 wxString *arg3 = (wxString *) &arg3_defvalue ;
18439 PyObject *result = 0 ;
18440 void *argp1 = 0 ;
18441 int res1 = 0 ;
18442 bool temp2 = false ;
18443 bool temp3 = false ;
18444 PyObject * obj0 = 0 ;
18445 PyObject * obj1 = 0 ;
18446 PyObject * obj2 = 0 ;
18447 char * kwnames[] = {
18448 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18449 };
18450
18451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18453 if (!SWIG_IsOK(res1)) {
18454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18455 }
18456 arg1 = reinterpret_cast< wxFileType * >(argp1);
18457 {
18458 arg2 = wxString_in_helper(obj1);
18459 if (arg2 == NULL) SWIG_fail;
18460 temp2 = true;
18461 }
18462 if (obj2) {
18463 {
18464 arg3 = wxString_in_helper(obj2);
18465 if (arg3 == NULL) SWIG_fail;
18466 temp3 = true;
18467 }
18468 }
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 resultobj = result;
18476 {
18477 if (temp2)
18478 delete arg2;
18479 }
18480 {
18481 if (temp3)
18482 delete arg3;
18483 }
18484 return resultobj;
18485 fail:
18486 {
18487 if (temp2)
18488 delete arg2;
18489 }
18490 {
18491 if (temp3)
18492 delete arg3;
18493 }
18494 return NULL;
18495 }
18496
18497
18498 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18499 PyObject *resultobj = 0;
18500 wxFileType *arg1 = (wxFileType *) 0 ;
18501 wxString *arg2 = 0 ;
18502 wxString *arg3 = 0 ;
18503 bool arg4 = (bool) true ;
18504 bool result;
18505 void *argp1 = 0 ;
18506 int res1 = 0 ;
18507 bool temp2 = false ;
18508 bool temp3 = false ;
18509 bool val4 ;
18510 int ecode4 = 0 ;
18511 PyObject * obj0 = 0 ;
18512 PyObject * obj1 = 0 ;
18513 PyObject * obj2 = 0 ;
18514 PyObject * obj3 = 0 ;
18515 char * kwnames[] = {
18516 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18517 };
18518
18519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18521 if (!SWIG_IsOK(res1)) {
18522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18523 }
18524 arg1 = reinterpret_cast< wxFileType * >(argp1);
18525 {
18526 arg2 = wxString_in_helper(obj1);
18527 if (arg2 == NULL) SWIG_fail;
18528 temp2 = true;
18529 }
18530 {
18531 arg3 = wxString_in_helper(obj2);
18532 if (arg3 == NULL) SWIG_fail;
18533 temp3 = true;
18534 }
18535 if (obj3) {
18536 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18537 if (!SWIG_IsOK(ecode4)) {
18538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18539 }
18540 arg4 = static_cast< bool >(val4);
18541 }
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18545 wxPyEndAllowThreads(__tstate);
18546 if (PyErr_Occurred()) SWIG_fail;
18547 }
18548 {
18549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18550 }
18551 {
18552 if (temp2)
18553 delete arg2;
18554 }
18555 {
18556 if (temp3)
18557 delete arg3;
18558 }
18559 return resultobj;
18560 fail:
18561 {
18562 if (temp2)
18563 delete arg2;
18564 }
18565 {
18566 if (temp3)
18567 delete arg3;
18568 }
18569 return NULL;
18570 }
18571
18572
18573 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18574 PyObject *resultobj = 0;
18575 wxFileType *arg1 = (wxFileType *) 0 ;
18576 wxString const &arg2_defvalue = wxPyEmptyString ;
18577 wxString *arg2 = (wxString *) &arg2_defvalue ;
18578 int arg3 = (int) 0 ;
18579 bool result;
18580 void *argp1 = 0 ;
18581 int res1 = 0 ;
18582 bool temp2 = false ;
18583 int val3 ;
18584 int ecode3 = 0 ;
18585 PyObject * obj0 = 0 ;
18586 PyObject * obj1 = 0 ;
18587 PyObject * obj2 = 0 ;
18588 char * kwnames[] = {
18589 (char *) "self",(char *) "cmd",(char *) "index", NULL
18590 };
18591
18592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18594 if (!SWIG_IsOK(res1)) {
18595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18596 }
18597 arg1 = reinterpret_cast< wxFileType * >(argp1);
18598 if (obj1) {
18599 {
18600 arg2 = wxString_in_helper(obj1);
18601 if (arg2 == NULL) SWIG_fail;
18602 temp2 = true;
18603 }
18604 }
18605 if (obj2) {
18606 ecode3 = SWIG_AsVal_int(obj2, &val3);
18607 if (!SWIG_IsOK(ecode3)) {
18608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18609 }
18610 arg3 = static_cast< int >(val3);
18611 }
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 {
18619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18620 }
18621 {
18622 if (temp2)
18623 delete arg2;
18624 }
18625 return resultobj;
18626 fail:
18627 {
18628 if (temp2)
18629 delete arg2;
18630 }
18631 return NULL;
18632 }
18633
18634
18635 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18636 PyObject *resultobj = 0;
18637 wxFileType *arg1 = (wxFileType *) 0 ;
18638 bool result;
18639 void *argp1 = 0 ;
18640 int res1 = 0 ;
18641 PyObject *swig_obj[1] ;
18642
18643 if (!args) SWIG_fail;
18644 swig_obj[0] = args;
18645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18646 if (!SWIG_IsOK(res1)) {
18647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18648 }
18649 arg1 = reinterpret_cast< wxFileType * >(argp1);
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 result = (bool)(arg1)->Unassociate();
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 {
18657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18658 }
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18666 PyObject *resultobj = 0;
18667 wxString *arg1 = 0 ;
18668 wxString *arg2 = 0 ;
18669 wxString const &arg3_defvalue = wxPyEmptyString ;
18670 wxString *arg3 = (wxString *) &arg3_defvalue ;
18671 wxString result;
18672 bool temp1 = false ;
18673 bool temp2 = false ;
18674 bool temp3 = false ;
18675 PyObject * obj0 = 0 ;
18676 PyObject * obj1 = 0 ;
18677 PyObject * obj2 = 0 ;
18678 char * kwnames[] = {
18679 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18680 };
18681
18682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18683 {
18684 arg1 = wxString_in_helper(obj0);
18685 if (arg1 == NULL) SWIG_fail;
18686 temp1 = true;
18687 }
18688 {
18689 arg2 = wxString_in_helper(obj1);
18690 if (arg2 == NULL) SWIG_fail;
18691 temp2 = true;
18692 }
18693 if (obj2) {
18694 {
18695 arg3 = wxString_in_helper(obj2);
18696 if (arg3 == NULL) SWIG_fail;
18697 temp3 = true;
18698 }
18699 }
18700 {
18701 PyThreadState* __tstate = wxPyBeginAllowThreads();
18702 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18703 wxPyEndAllowThreads(__tstate);
18704 if (PyErr_Occurred()) SWIG_fail;
18705 }
18706 {
18707 #if wxUSE_UNICODE
18708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18709 #else
18710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18711 #endif
18712 }
18713 {
18714 if (temp1)
18715 delete arg1;
18716 }
18717 {
18718 if (temp2)
18719 delete arg2;
18720 }
18721 {
18722 if (temp3)
18723 delete arg3;
18724 }
18725 return resultobj;
18726 fail:
18727 {
18728 if (temp1)
18729 delete arg1;
18730 }
18731 {
18732 if (temp2)
18733 delete arg2;
18734 }
18735 {
18736 if (temp3)
18737 delete arg3;
18738 }
18739 return NULL;
18740 }
18741
18742
18743 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18744 PyObject *obj;
18745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18746 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18747 return SWIG_Py_Void();
18748 }
18749
18750 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18751 return SWIG_Python_InitShadowInstance(args);
18752 }
18753
18754 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18755 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18756 return 1;
18757 }
18758
18759
18760 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18761 PyObject *pyobj = 0;
18762
18763 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18764 return pyobj;
18765 }
18766
18767
18768 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18769 PyObject *resultobj = 0;
18770 wxString *arg1 = 0 ;
18771 wxString *arg2 = 0 ;
18772 bool result;
18773 bool temp1 = false ;
18774 bool temp2 = false ;
18775 PyObject * obj0 = 0 ;
18776 PyObject * obj1 = 0 ;
18777 char * kwnames[] = {
18778 (char *) "mimeType",(char *) "wildcard", NULL
18779 };
18780
18781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18782 {
18783 arg1 = wxString_in_helper(obj0);
18784 if (arg1 == NULL) SWIG_fail;
18785 temp1 = true;
18786 }
18787 {
18788 arg2 = wxString_in_helper(obj1);
18789 if (arg2 == NULL) SWIG_fail;
18790 temp2 = true;
18791 }
18792 {
18793 PyThreadState* __tstate = wxPyBeginAllowThreads();
18794 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18795 wxPyEndAllowThreads(__tstate);
18796 if (PyErr_Occurred()) SWIG_fail;
18797 }
18798 {
18799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18800 }
18801 {
18802 if (temp1)
18803 delete arg1;
18804 }
18805 {
18806 if (temp2)
18807 delete arg2;
18808 }
18809 return resultobj;
18810 fail:
18811 {
18812 if (temp1)
18813 delete arg1;
18814 }
18815 {
18816 if (temp2)
18817 delete arg2;
18818 }
18819 return NULL;
18820 }
18821
18822
18823 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18824 PyObject *resultobj = 0;
18825 wxMimeTypesManager *result = 0 ;
18826
18827 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18828 {
18829 PyThreadState* __tstate = wxPyBeginAllowThreads();
18830 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18831 wxPyEndAllowThreads(__tstate);
18832 if (PyErr_Occurred()) SWIG_fail;
18833 }
18834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18835 return resultobj;
18836 fail:
18837 return NULL;
18838 }
18839
18840
18841 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18842 PyObject *resultobj = 0;
18843 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18844 int arg2 = (int) wxMAILCAP_ALL ;
18845 wxString const &arg3_defvalue = wxPyEmptyString ;
18846 wxString *arg3 = (wxString *) &arg3_defvalue ;
18847 void *argp1 = 0 ;
18848 int res1 = 0 ;
18849 int val2 ;
18850 int ecode2 = 0 ;
18851 bool temp3 = false ;
18852 PyObject * obj0 = 0 ;
18853 PyObject * obj1 = 0 ;
18854 PyObject * obj2 = 0 ;
18855 char * kwnames[] = {
18856 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18857 };
18858
18859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18861 if (!SWIG_IsOK(res1)) {
18862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18863 }
18864 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18865 if (obj1) {
18866 ecode2 = SWIG_AsVal_int(obj1, &val2);
18867 if (!SWIG_IsOK(ecode2)) {
18868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18869 }
18870 arg2 = static_cast< int >(val2);
18871 }
18872 if (obj2) {
18873 {
18874 arg3 = wxString_in_helper(obj2);
18875 if (arg3 == NULL) SWIG_fail;
18876 temp3 = true;
18877 }
18878 }
18879 {
18880 PyThreadState* __tstate = wxPyBeginAllowThreads();
18881 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18882 wxPyEndAllowThreads(__tstate);
18883 if (PyErr_Occurred()) SWIG_fail;
18884 }
18885 resultobj = SWIG_Py_Void();
18886 {
18887 if (temp3)
18888 delete arg3;
18889 }
18890 return resultobj;
18891 fail:
18892 {
18893 if (temp3)
18894 delete arg3;
18895 }
18896 return NULL;
18897 }
18898
18899
18900 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18901 PyObject *resultobj = 0;
18902 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18903 void *argp1 = 0 ;
18904 int res1 = 0 ;
18905 PyObject *swig_obj[1] ;
18906
18907 if (!args) SWIG_fail;
18908 swig_obj[0] = args;
18909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18910 if (!SWIG_IsOK(res1)) {
18911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18912 }
18913 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 (arg1)->ClearData();
18917 wxPyEndAllowThreads(__tstate);
18918 if (PyErr_Occurred()) SWIG_fail;
18919 }
18920 resultobj = SWIG_Py_Void();
18921 return resultobj;
18922 fail:
18923 return NULL;
18924 }
18925
18926
18927 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18928 PyObject *resultobj = 0;
18929 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18930 wxString *arg2 = 0 ;
18931 wxFileType *result = 0 ;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 bool temp2 = false ;
18935 PyObject * obj0 = 0 ;
18936 PyObject * obj1 = 0 ;
18937 char * kwnames[] = {
18938 (char *) "self",(char *) "ext", NULL
18939 };
18940
18941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18943 if (!SWIG_IsOK(res1)) {
18944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18945 }
18946 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18947 {
18948 arg2 = wxString_in_helper(obj1);
18949 if (arg2 == NULL) SWIG_fail;
18950 temp2 = true;
18951 }
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18959 {
18960 if (temp2)
18961 delete arg2;
18962 }
18963 return resultobj;
18964 fail:
18965 {
18966 if (temp2)
18967 delete arg2;
18968 }
18969 return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18974 PyObject *resultobj = 0;
18975 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18976 wxString *arg2 = 0 ;
18977 wxFileType *result = 0 ;
18978 void *argp1 = 0 ;
18979 int res1 = 0 ;
18980 bool temp2 = false ;
18981 PyObject * obj0 = 0 ;
18982 PyObject * obj1 = 0 ;
18983 char * kwnames[] = {
18984 (char *) "self",(char *) "mimeType", NULL
18985 };
18986
18987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18989 if (!SWIG_IsOK(res1)) {
18990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18991 }
18992 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18993 {
18994 arg2 = wxString_in_helper(obj1);
18995 if (arg2 == NULL) SWIG_fail;
18996 temp2 = true;
18997 }
18998 {
18999 PyThreadState* __tstate = wxPyBeginAllowThreads();
19000 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19001 wxPyEndAllowThreads(__tstate);
19002 if (PyErr_Occurred()) SWIG_fail;
19003 }
19004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19005 {
19006 if (temp2)
19007 delete arg2;
19008 }
19009 return resultobj;
19010 fail:
19011 {
19012 if (temp2)
19013 delete arg2;
19014 }
19015 return NULL;
19016 }
19017
19018
19019 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19020 PyObject *resultobj = 0;
19021 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19022 wxString *arg2 = 0 ;
19023 bool arg3 = (bool) false ;
19024 bool result;
19025 void *argp1 = 0 ;
19026 int res1 = 0 ;
19027 bool temp2 = false ;
19028 bool val3 ;
19029 int ecode3 = 0 ;
19030 PyObject * obj0 = 0 ;
19031 PyObject * obj1 = 0 ;
19032 PyObject * obj2 = 0 ;
19033 char * kwnames[] = {
19034 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19035 };
19036
19037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19039 if (!SWIG_IsOK(res1)) {
19040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19041 }
19042 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19043 {
19044 arg2 = wxString_in_helper(obj1);
19045 if (arg2 == NULL) SWIG_fail;
19046 temp2 = true;
19047 }
19048 if (obj2) {
19049 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19050 if (!SWIG_IsOK(ecode3)) {
19051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19052 }
19053 arg3 = static_cast< bool >(val3);
19054 }
19055 {
19056 PyThreadState* __tstate = wxPyBeginAllowThreads();
19057 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19058 wxPyEndAllowThreads(__tstate);
19059 if (PyErr_Occurred()) SWIG_fail;
19060 }
19061 {
19062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19063 }
19064 {
19065 if (temp2)
19066 delete arg2;
19067 }
19068 return resultobj;
19069 fail:
19070 {
19071 if (temp2)
19072 delete arg2;
19073 }
19074 return NULL;
19075 }
19076
19077
19078 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19079 PyObject *resultobj = 0;
19080 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19081 wxString *arg2 = 0 ;
19082 bool result;
19083 void *argp1 = 0 ;
19084 int res1 = 0 ;
19085 bool temp2 = false ;
19086 PyObject * obj0 = 0 ;
19087 PyObject * obj1 = 0 ;
19088 char * kwnames[] = {
19089 (char *) "self",(char *) "filename", NULL
19090 };
19091
19092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19094 if (!SWIG_IsOK(res1)) {
19095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19096 }
19097 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19098 {
19099 arg2 = wxString_in_helper(obj1);
19100 if (arg2 == NULL) SWIG_fail;
19101 temp2 = true;
19102 }
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 {
19110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19111 }
19112 {
19113 if (temp2)
19114 delete arg2;
19115 }
19116 return resultobj;
19117 fail:
19118 {
19119 if (temp2)
19120 delete arg2;
19121 }
19122 return NULL;
19123 }
19124
19125
19126 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19127 PyObject *resultobj = 0;
19128 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19129 PyObject *result = 0 ;
19130 void *argp1 = 0 ;
19131 int res1 = 0 ;
19132 PyObject *swig_obj[1] ;
19133
19134 if (!args) SWIG_fail;
19135 swig_obj[0] = args;
19136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19137 if (!SWIG_IsOK(res1)) {
19138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19139 }
19140 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19141 {
19142 PyThreadState* __tstate = wxPyBeginAllowThreads();
19143 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19144 wxPyEndAllowThreads(__tstate);
19145 if (PyErr_Occurred()) SWIG_fail;
19146 }
19147 resultobj = result;
19148 return resultobj;
19149 fail:
19150 return NULL;
19151 }
19152
19153
19154 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19155 PyObject *resultobj = 0;
19156 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19157 wxFileTypeInfo *arg2 = 0 ;
19158 void *argp1 = 0 ;
19159 int res1 = 0 ;
19160 void *argp2 = 0 ;
19161 int res2 = 0 ;
19162 PyObject * obj0 = 0 ;
19163 PyObject * obj1 = 0 ;
19164 char * kwnames[] = {
19165 (char *) "self",(char *) "ft", NULL
19166 };
19167
19168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19172 }
19173 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19175 if (!SWIG_IsOK(res2)) {
19176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19177 }
19178 if (!argp2) {
19179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19180 }
19181 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19182 {
19183 PyThreadState* __tstate = wxPyBeginAllowThreads();
19184 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19185 wxPyEndAllowThreads(__tstate);
19186 if (PyErr_Occurred()) SWIG_fail;
19187 }
19188 resultobj = SWIG_Py_Void();
19189 return resultobj;
19190 fail:
19191 return NULL;
19192 }
19193
19194
19195 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19196 PyObject *resultobj = 0;
19197 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19198 wxFileTypeInfo *arg2 = 0 ;
19199 wxFileType *result = 0 ;
19200 void *argp1 = 0 ;
19201 int res1 = 0 ;
19202 void *argp2 = 0 ;
19203 int res2 = 0 ;
19204 PyObject * obj0 = 0 ;
19205 PyObject * obj1 = 0 ;
19206 char * kwnames[] = {
19207 (char *) "self",(char *) "ftInfo", NULL
19208 };
19209
19210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19214 }
19215 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19217 if (!SWIG_IsOK(res2)) {
19218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19219 }
19220 if (!argp2) {
19221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19222 }
19223 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19224 {
19225 PyThreadState* __tstate = wxPyBeginAllowThreads();
19226 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19227 wxPyEndAllowThreads(__tstate);
19228 if (PyErr_Occurred()) SWIG_fail;
19229 }
19230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19238 PyObject *resultobj = 0;
19239 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19240 wxFileType *arg2 = (wxFileType *) 0 ;
19241 bool result;
19242 void *argp1 = 0 ;
19243 int res1 = 0 ;
19244 void *argp2 = 0 ;
19245 int res2 = 0 ;
19246 PyObject * obj0 = 0 ;
19247 PyObject * obj1 = 0 ;
19248 char * kwnames[] = {
19249 (char *) "self",(char *) "ft", NULL
19250 };
19251
19252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19254 if (!SWIG_IsOK(res1)) {
19255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19256 }
19257 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19259 if (!SWIG_IsOK(res2)) {
19260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19261 }
19262 arg2 = reinterpret_cast< wxFileType * >(argp2);
19263 {
19264 PyThreadState* __tstate = wxPyBeginAllowThreads();
19265 result = (bool)(arg1)->Unassociate(arg2);
19266 wxPyEndAllowThreads(__tstate);
19267 if (PyErr_Occurred()) SWIG_fail;
19268 }
19269 {
19270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19279 PyObject *resultobj = 0;
19280 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19281 void *argp1 = 0 ;
19282 int res1 = 0 ;
19283 PyObject *swig_obj[1] ;
19284
19285 if (!args) SWIG_fail;
19286 swig_obj[0] = args;
19287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19288 if (!SWIG_IsOK(res1)) {
19289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19290 }
19291 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19292 {
19293 PyThreadState* __tstate = wxPyBeginAllowThreads();
19294 delete arg1;
19295
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 resultobj = SWIG_Py_Void();
19300 return resultobj;
19301 fail:
19302 return NULL;
19303 }
19304
19305
19306 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19307 PyObject *obj;
19308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19309 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19310 return SWIG_Py_Void();
19311 }
19312
19313 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19314 return SWIG_Python_InitShadowInstance(args);
19315 }
19316
19317 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19318 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19319 return 1;
19320 }
19321
19322
19323 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19324 PyObject *pyobj = 0;
19325
19326 {
19327 #if wxUSE_UNICODE
19328 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19329 #else
19330 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19331 #endif
19332 }
19333 return pyobj;
19334 }
19335
19336
19337 SWIGINTERN int ART_MENU_set(PyObject *) {
19338 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19339 return 1;
19340 }
19341
19342
19343 SWIGINTERN PyObject *ART_MENU_get(void) {
19344 PyObject *pyobj = 0;
19345
19346 {
19347 #if wxUSE_UNICODE
19348 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19349 #else
19350 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19351 #endif
19352 }
19353 return pyobj;
19354 }
19355
19356
19357 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19358 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19359 return 1;
19360 }
19361
19362
19363 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19364 PyObject *pyobj = 0;
19365
19366 {
19367 #if wxUSE_UNICODE
19368 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19369 #else
19370 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19371 #endif
19372 }
19373 return pyobj;
19374 }
19375
19376
19377 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19378 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19379 return 1;
19380 }
19381
19382
19383 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19384 PyObject *pyobj = 0;
19385
19386 {
19387 #if wxUSE_UNICODE
19388 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19389 #else
19390 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19391 #endif
19392 }
19393 return pyobj;
19394 }
19395
19396
19397 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19398 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19399 return 1;
19400 }
19401
19402
19403 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19404 PyObject *pyobj = 0;
19405
19406 {
19407 #if wxUSE_UNICODE
19408 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19409 #else
19410 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19411 #endif
19412 }
19413 return pyobj;
19414 }
19415
19416
19417 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19418 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19419 return 1;
19420 }
19421
19422
19423 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19424 PyObject *pyobj = 0;
19425
19426 {
19427 #if wxUSE_UNICODE
19428 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19429 #else
19430 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19431 #endif
19432 }
19433 return pyobj;
19434 }
19435
19436
19437 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19438 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19439 return 1;
19440 }
19441
19442
19443 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19444 PyObject *pyobj = 0;
19445
19446 {
19447 #if wxUSE_UNICODE
19448 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19449 #else
19450 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19451 #endif
19452 }
19453 return pyobj;
19454 }
19455
19456
19457 SWIGINTERN int ART_OTHER_set(PyObject *) {
19458 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19459 return 1;
19460 }
19461
19462
19463 SWIGINTERN PyObject *ART_OTHER_get(void) {
19464 PyObject *pyobj = 0;
19465
19466 {
19467 #if wxUSE_UNICODE
19468 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19469 #else
19470 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19471 #endif
19472 }
19473 return pyobj;
19474 }
19475
19476
19477 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19478 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19479 return 1;
19480 }
19481
19482
19483 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19484 PyObject *pyobj = 0;
19485
19486 {
19487 #if wxUSE_UNICODE
19488 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19489 #else
19490 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19491 #endif
19492 }
19493 return pyobj;
19494 }
19495
19496
19497 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19498 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19499 return 1;
19500 }
19501
19502
19503 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19504 PyObject *pyobj = 0;
19505
19506 {
19507 #if wxUSE_UNICODE
19508 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19509 #else
19510 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19511 #endif
19512 }
19513 return pyobj;
19514 }
19515
19516
19517 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19518 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19519 return 1;
19520 }
19521
19522
19523 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19524 PyObject *pyobj = 0;
19525
19526 {
19527 #if wxUSE_UNICODE
19528 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19529 #else
19530 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19531 #endif
19532 }
19533 return pyobj;
19534 }
19535
19536
19537 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19538 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19539 return 1;
19540 }
19541
19542
19543 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19544 PyObject *pyobj = 0;
19545
19546 {
19547 #if wxUSE_UNICODE
19548 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19549 #else
19550 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19551 #endif
19552 }
19553 return pyobj;
19554 }
19555
19556
19557 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19558 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19559 return 1;
19560 }
19561
19562
19563 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19564 PyObject *pyobj = 0;
19565
19566 {
19567 #if wxUSE_UNICODE
19568 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19569 #else
19570 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19571 #endif
19572 }
19573 return pyobj;
19574 }
19575
19576
19577 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19578 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19579 return 1;
19580 }
19581
19582
19583 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19584 PyObject *pyobj = 0;
19585
19586 {
19587 #if wxUSE_UNICODE
19588 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19589 #else
19590 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19591 #endif
19592 }
19593 return pyobj;
19594 }
19595
19596
19597 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19598 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19599 return 1;
19600 }
19601
19602
19603 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19604 PyObject *pyobj = 0;
19605
19606 {
19607 #if wxUSE_UNICODE
19608 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19609 #else
19610 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19611 #endif
19612 }
19613 return pyobj;
19614 }
19615
19616
19617 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19618 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19619 return 1;
19620 }
19621
19622
19623 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19624 PyObject *pyobj = 0;
19625
19626 {
19627 #if wxUSE_UNICODE
19628 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19629 #else
19630 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19631 #endif
19632 }
19633 return pyobj;
19634 }
19635
19636
19637 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19638 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19639 return 1;
19640 }
19641
19642
19643 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19644 PyObject *pyobj = 0;
19645
19646 {
19647 #if wxUSE_UNICODE
19648 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19649 #else
19650 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19651 #endif
19652 }
19653 return pyobj;
19654 }
19655
19656
19657 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19658 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19659 return 1;
19660 }
19661
19662
19663 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19664 PyObject *pyobj = 0;
19665
19666 {
19667 #if wxUSE_UNICODE
19668 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19669 #else
19670 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19671 #endif
19672 }
19673 return pyobj;
19674 }
19675
19676
19677 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19678 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19679 return 1;
19680 }
19681
19682
19683 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19684 PyObject *pyobj = 0;
19685
19686 {
19687 #if wxUSE_UNICODE
19688 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19689 #else
19690 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19691 #endif
19692 }
19693 return pyobj;
19694 }
19695
19696
19697 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19698 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19699 return 1;
19700 }
19701
19702
19703 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19704 PyObject *pyobj = 0;
19705
19706 {
19707 #if wxUSE_UNICODE
19708 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19709 #else
19710 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19711 #endif
19712 }
19713 return pyobj;
19714 }
19715
19716
19717 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19718 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19719 return 1;
19720 }
19721
19722
19723 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19724 PyObject *pyobj = 0;
19725
19726 {
19727 #if wxUSE_UNICODE
19728 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19729 #else
19730 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19731 #endif
19732 }
19733 return pyobj;
19734 }
19735
19736
19737 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19738 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19739 return 1;
19740 }
19741
19742
19743 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19744 PyObject *pyobj = 0;
19745
19746 {
19747 #if wxUSE_UNICODE
19748 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19749 #else
19750 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19751 #endif
19752 }
19753 return pyobj;
19754 }
19755
19756
19757 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19758 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19759 return 1;
19760 }
19761
19762
19763 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19764 PyObject *pyobj = 0;
19765
19766 {
19767 #if wxUSE_UNICODE
19768 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19769 #else
19770 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19771 #endif
19772 }
19773 return pyobj;
19774 }
19775
19776
19777 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19778 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19779 return 1;
19780 }
19781
19782
19783 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19784 PyObject *pyobj = 0;
19785
19786 {
19787 #if wxUSE_UNICODE
19788 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19789 #else
19790 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19791 #endif
19792 }
19793 return pyobj;
19794 }
19795
19796
19797 SWIGINTERN int ART_PRINT_set(PyObject *) {
19798 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19799 return 1;
19800 }
19801
19802
19803 SWIGINTERN PyObject *ART_PRINT_get(void) {
19804 PyObject *pyobj = 0;
19805
19806 {
19807 #if wxUSE_UNICODE
19808 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19809 #else
19810 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19811 #endif
19812 }
19813 return pyobj;
19814 }
19815
19816
19817 SWIGINTERN int ART_HELP_set(PyObject *) {
19818 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19819 return 1;
19820 }
19821
19822
19823 SWIGINTERN PyObject *ART_HELP_get(void) {
19824 PyObject *pyobj = 0;
19825
19826 {
19827 #if wxUSE_UNICODE
19828 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19829 #else
19830 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19831 #endif
19832 }
19833 return pyobj;
19834 }
19835
19836
19837 SWIGINTERN int ART_TIP_set(PyObject *) {
19838 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19839 return 1;
19840 }
19841
19842
19843 SWIGINTERN PyObject *ART_TIP_get(void) {
19844 PyObject *pyobj = 0;
19845
19846 {
19847 #if wxUSE_UNICODE
19848 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19849 #else
19850 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19851 #endif
19852 }
19853 return pyobj;
19854 }
19855
19856
19857 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19858 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19859 return 1;
19860 }
19861
19862
19863 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19864 PyObject *pyobj = 0;
19865
19866 {
19867 #if wxUSE_UNICODE
19868 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19869 #else
19870 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19871 #endif
19872 }
19873 return pyobj;
19874 }
19875
19876
19877 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19878 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19879 return 1;
19880 }
19881
19882
19883 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19884 PyObject *pyobj = 0;
19885
19886 {
19887 #if wxUSE_UNICODE
19888 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19889 #else
19890 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19891 #endif
19892 }
19893 return pyobj;
19894 }
19895
19896
19897 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19898 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19899 return 1;
19900 }
19901
19902
19903 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19904 PyObject *pyobj = 0;
19905
19906 {
19907 #if wxUSE_UNICODE
19908 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19909 #else
19910 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19911 #endif
19912 }
19913 return pyobj;
19914 }
19915
19916
19917 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19918 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19919 return 1;
19920 }
19921
19922
19923 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19924 PyObject *pyobj = 0;
19925
19926 {
19927 #if wxUSE_UNICODE
19928 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19929 #else
19930 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19931 #endif
19932 }
19933 return pyobj;
19934 }
19935
19936
19937 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19938 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19939 return 1;
19940 }
19941
19942
19943 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19944 PyObject *pyobj = 0;
19945
19946 {
19947 #if wxUSE_UNICODE
19948 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19949 #else
19950 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19951 #endif
19952 }
19953 return pyobj;
19954 }
19955
19956
19957 SWIGINTERN int ART_CDROM_set(PyObject *) {
19958 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19959 return 1;
19960 }
19961
19962
19963 SWIGINTERN PyObject *ART_CDROM_get(void) {
19964 PyObject *pyobj = 0;
19965
19966 {
19967 #if wxUSE_UNICODE
19968 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19969 #else
19970 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19971 #endif
19972 }
19973 return pyobj;
19974 }
19975
19976
19977 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19978 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19979 return 1;
19980 }
19981
19982
19983 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19984 PyObject *pyobj = 0;
19985
19986 {
19987 #if wxUSE_UNICODE
19988 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19989 #else
19990 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19991 #endif
19992 }
19993 return pyobj;
19994 }
19995
19996
19997 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19998 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19999 return 1;
20000 }
20001
20002
20003 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20004 PyObject *pyobj = 0;
20005
20006 {
20007 #if wxUSE_UNICODE
20008 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20009 #else
20010 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20011 #endif
20012 }
20013 return pyobj;
20014 }
20015
20016
20017 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20018 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20019 return 1;
20020 }
20021
20022
20023 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20024 PyObject *pyobj = 0;
20025
20026 {
20027 #if wxUSE_UNICODE
20028 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20029 #else
20030 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20031 #endif
20032 }
20033 return pyobj;
20034 }
20035
20036
20037 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20038 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20039 return 1;
20040 }
20041
20042
20043 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20044 PyObject *pyobj = 0;
20045
20046 {
20047 #if wxUSE_UNICODE
20048 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20049 #else
20050 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20051 #endif
20052 }
20053 return pyobj;
20054 }
20055
20056
20057 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20058 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20059 return 1;
20060 }
20061
20062
20063 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20064 PyObject *pyobj = 0;
20065
20066 {
20067 #if wxUSE_UNICODE
20068 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20069 #else
20070 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20071 #endif
20072 }
20073 return pyobj;
20074 }
20075
20076
20077 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20078 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20079 return 1;
20080 }
20081
20082
20083 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20084 PyObject *pyobj = 0;
20085
20086 {
20087 #if wxUSE_UNICODE
20088 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20089 #else
20090 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20091 #endif
20092 }
20093 return pyobj;
20094 }
20095
20096
20097 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20098 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20099 return 1;
20100 }
20101
20102
20103 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20104 PyObject *pyobj = 0;
20105
20106 {
20107 #if wxUSE_UNICODE
20108 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20109 #else
20110 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20111 #endif
20112 }
20113 return pyobj;
20114 }
20115
20116
20117 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20118 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20119 return 1;
20120 }
20121
20122
20123 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20124 PyObject *pyobj = 0;
20125
20126 {
20127 #if wxUSE_UNICODE
20128 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20129 #else
20130 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20131 #endif
20132 }
20133 return pyobj;
20134 }
20135
20136
20137 SWIGINTERN int ART_ERROR_set(PyObject *) {
20138 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20139 return 1;
20140 }
20141
20142
20143 SWIGINTERN PyObject *ART_ERROR_get(void) {
20144 PyObject *pyobj = 0;
20145
20146 {
20147 #if wxUSE_UNICODE
20148 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20149 #else
20150 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20151 #endif
20152 }
20153 return pyobj;
20154 }
20155
20156
20157 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20158 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20159 return 1;
20160 }
20161
20162
20163 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20164 PyObject *pyobj = 0;
20165
20166 {
20167 #if wxUSE_UNICODE
20168 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20169 #else
20170 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20171 #endif
20172 }
20173 return pyobj;
20174 }
20175
20176
20177 SWIGINTERN int ART_WARNING_set(PyObject *) {
20178 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20179 return 1;
20180 }
20181
20182
20183 SWIGINTERN PyObject *ART_WARNING_get(void) {
20184 PyObject *pyobj = 0;
20185
20186 {
20187 #if wxUSE_UNICODE
20188 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20189 #else
20190 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20191 #endif
20192 }
20193 return pyobj;
20194 }
20195
20196
20197 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20198 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20199 return 1;
20200 }
20201
20202
20203 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20204 PyObject *pyobj = 0;
20205
20206 {
20207 #if wxUSE_UNICODE
20208 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20209 #else
20210 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20211 #endif
20212 }
20213 return pyobj;
20214 }
20215
20216
20217 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20218 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20219 return 1;
20220 }
20221
20222
20223 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20224 PyObject *pyobj = 0;
20225
20226 {
20227 #if wxUSE_UNICODE
20228 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20229 #else
20230 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20231 #endif
20232 }
20233 return pyobj;
20234 }
20235
20236
20237 SWIGINTERN int ART_COPY_set(PyObject *) {
20238 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20239 return 1;
20240 }
20241
20242
20243 SWIGINTERN PyObject *ART_COPY_get(void) {
20244 PyObject *pyobj = 0;
20245
20246 {
20247 #if wxUSE_UNICODE
20248 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20249 #else
20250 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20251 #endif
20252 }
20253 return pyobj;
20254 }
20255
20256
20257 SWIGINTERN int ART_CUT_set(PyObject *) {
20258 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20259 return 1;
20260 }
20261
20262
20263 SWIGINTERN PyObject *ART_CUT_get(void) {
20264 PyObject *pyobj = 0;
20265
20266 {
20267 #if wxUSE_UNICODE
20268 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20269 #else
20270 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20271 #endif
20272 }
20273 return pyobj;
20274 }
20275
20276
20277 SWIGINTERN int ART_PASTE_set(PyObject *) {
20278 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20279 return 1;
20280 }
20281
20282
20283 SWIGINTERN PyObject *ART_PASTE_get(void) {
20284 PyObject *pyobj = 0;
20285
20286 {
20287 #if wxUSE_UNICODE
20288 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20289 #else
20290 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20291 #endif
20292 }
20293 return pyobj;
20294 }
20295
20296
20297 SWIGINTERN int ART_DELETE_set(PyObject *) {
20298 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20299 return 1;
20300 }
20301
20302
20303 SWIGINTERN PyObject *ART_DELETE_get(void) {
20304 PyObject *pyobj = 0;
20305
20306 {
20307 #if wxUSE_UNICODE
20308 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20309 #else
20310 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20311 #endif
20312 }
20313 return pyobj;
20314 }
20315
20316
20317 SWIGINTERN int ART_NEW_set(PyObject *) {
20318 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20319 return 1;
20320 }
20321
20322
20323 SWIGINTERN PyObject *ART_NEW_get(void) {
20324 PyObject *pyobj = 0;
20325
20326 {
20327 #if wxUSE_UNICODE
20328 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20329 #else
20330 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20331 #endif
20332 }
20333 return pyobj;
20334 }
20335
20336
20337 SWIGINTERN int ART_UNDO_set(PyObject *) {
20338 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20339 return 1;
20340 }
20341
20342
20343 SWIGINTERN PyObject *ART_UNDO_get(void) {
20344 PyObject *pyobj = 0;
20345
20346 {
20347 #if wxUSE_UNICODE
20348 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20349 #else
20350 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20351 #endif
20352 }
20353 return pyobj;
20354 }
20355
20356
20357 SWIGINTERN int ART_REDO_set(PyObject *) {
20358 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20359 return 1;
20360 }
20361
20362
20363 SWIGINTERN PyObject *ART_REDO_get(void) {
20364 PyObject *pyobj = 0;
20365
20366 {
20367 #if wxUSE_UNICODE
20368 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20369 #else
20370 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20371 #endif
20372 }
20373 return pyobj;
20374 }
20375
20376
20377 SWIGINTERN int ART_QUIT_set(PyObject *) {
20378 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20379 return 1;
20380 }
20381
20382
20383 SWIGINTERN PyObject *ART_QUIT_get(void) {
20384 PyObject *pyobj = 0;
20385
20386 {
20387 #if wxUSE_UNICODE
20388 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20389 #else
20390 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20391 #endif
20392 }
20393 return pyobj;
20394 }
20395
20396
20397 SWIGINTERN int ART_FIND_set(PyObject *) {
20398 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20399 return 1;
20400 }
20401
20402
20403 SWIGINTERN PyObject *ART_FIND_get(void) {
20404 PyObject *pyobj = 0;
20405
20406 {
20407 #if wxUSE_UNICODE
20408 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20409 #else
20410 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20411 #endif
20412 }
20413 return pyobj;
20414 }
20415
20416
20417 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20418 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20419 return 1;
20420 }
20421
20422
20423 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20424 PyObject *pyobj = 0;
20425
20426 {
20427 #if wxUSE_UNICODE
20428 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20429 #else
20430 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20431 #endif
20432 }
20433 return pyobj;
20434 }
20435
20436
20437 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20438 PyObject *resultobj = 0;
20439 wxPyArtProvider *result = 0 ;
20440
20441 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20442 {
20443 if (!wxPyCheckForApp()) SWIG_fail;
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 result = (wxPyArtProvider *)new wxPyArtProvider();
20446 wxPyEndAllowThreads(__tstate);
20447 if (PyErr_Occurred()) SWIG_fail;
20448 }
20449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 PyObject *resultobj = 0;
20458 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20459 void *argp1 = 0 ;
20460 int res1 = 0 ;
20461 PyObject *swig_obj[1] ;
20462
20463 if (!args) SWIG_fail;
20464 swig_obj[0] = args;
20465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20466 if (!SWIG_IsOK(res1)) {
20467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20468 }
20469 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20470 {
20471 PyThreadState* __tstate = wxPyBeginAllowThreads();
20472 delete arg1;
20473
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 resultobj = SWIG_Py_Void();
20478 return resultobj;
20479 fail:
20480 return NULL;
20481 }
20482
20483
20484 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20485 PyObject *resultobj = 0;
20486 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20487 PyObject *arg2 = (PyObject *) 0 ;
20488 PyObject *arg3 = (PyObject *) 0 ;
20489 void *argp1 = 0 ;
20490 int res1 = 0 ;
20491 PyObject * obj0 = 0 ;
20492 PyObject * obj1 = 0 ;
20493 PyObject * obj2 = 0 ;
20494 char * kwnames[] = {
20495 (char *) "self",(char *) "self",(char *) "_class", NULL
20496 };
20497
20498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20500 if (!SWIG_IsOK(res1)) {
20501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20502 }
20503 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20504 arg2 = obj1;
20505 arg3 = obj2;
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 (arg1)->_setCallbackInfo(arg2,arg3);
20509 wxPyEndAllowThreads(__tstate);
20510 if (PyErr_Occurred()) SWIG_fail;
20511 }
20512 resultobj = SWIG_Py_Void();
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20520 PyObject *resultobj = 0;
20521 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20522 int res1 = 0 ;
20523 PyObject * obj0 = 0 ;
20524 char * kwnames[] = {
20525 (char *) "provider", NULL
20526 };
20527
20528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20529 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20530 if (!SWIG_IsOK(res1)) {
20531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20532 }
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 wxPyArtProvider::Push(arg1);
20536 wxPyEndAllowThreads(__tstate);
20537 if (PyErr_Occurred()) SWIG_fail;
20538 }
20539 resultobj = SWIG_Py_Void();
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20547 PyObject *resultobj = 0;
20548 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20549 int res1 = 0 ;
20550 PyObject * obj0 = 0 ;
20551 char * kwnames[] = {
20552 (char *) "provider", NULL
20553 };
20554
20555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20556 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20559 }
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 wxPyArtProvider::Insert(arg1);
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 resultobj = SWIG_Py_Void();
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20574 PyObject *resultobj = 0;
20575 bool result;
20576
20577 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20578 {
20579 PyThreadState* __tstate = wxPyBeginAllowThreads();
20580 result = (bool)wxPyArtProvider::Pop();
20581 wxPyEndAllowThreads(__tstate);
20582 if (PyErr_Occurred()) SWIG_fail;
20583 }
20584 {
20585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20586 }
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20594 PyObject *resultobj = 0;
20595 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20596 bool result;
20597 void *argp1 = 0 ;
20598 int res1 = 0 ;
20599 PyObject * obj0 = 0 ;
20600 char * kwnames[] = {
20601 (char *) "provider", NULL
20602 };
20603
20604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20608 }
20609 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (bool)wxPyArtProvider::Delete(arg1);
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20618 }
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20626 PyObject *resultobj = 0;
20627 wxString *arg1 = 0 ;
20628 wxString const &arg2_defvalue = wxPyART_OTHER ;
20629 wxString *arg2 = (wxString *) &arg2_defvalue ;
20630 wxSize const &arg3_defvalue = wxDefaultSize ;
20631 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20632 wxBitmap result;
20633 bool temp1 = false ;
20634 bool temp2 = false ;
20635 wxSize temp3 ;
20636 PyObject * obj0 = 0 ;
20637 PyObject * obj1 = 0 ;
20638 PyObject * obj2 = 0 ;
20639 char * kwnames[] = {
20640 (char *) "id",(char *) "client",(char *) "size", NULL
20641 };
20642
20643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20644 {
20645 arg1 = wxString_in_helper(obj0);
20646 if (arg1 == NULL) SWIG_fail;
20647 temp1 = true;
20648 }
20649 if (obj1) {
20650 {
20651 arg2 = wxString_in_helper(obj1);
20652 if (arg2 == NULL) SWIG_fail;
20653 temp2 = true;
20654 }
20655 }
20656 if (obj2) {
20657 {
20658 arg3 = &temp3;
20659 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20660 }
20661 }
20662 {
20663 if (!wxPyCheckForApp()) SWIG_fail;
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20666 wxPyEndAllowThreads(__tstate);
20667 if (PyErr_Occurred()) SWIG_fail;
20668 }
20669 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20670 {
20671 if (temp1)
20672 delete arg1;
20673 }
20674 {
20675 if (temp2)
20676 delete arg2;
20677 }
20678 return resultobj;
20679 fail:
20680 {
20681 if (temp1)
20682 delete arg1;
20683 }
20684 {
20685 if (temp2)
20686 delete arg2;
20687 }
20688 return NULL;
20689 }
20690
20691
20692 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20693 PyObject *resultobj = 0;
20694 wxString *arg1 = 0 ;
20695 wxString const &arg2_defvalue = wxPyART_OTHER ;
20696 wxString *arg2 = (wxString *) &arg2_defvalue ;
20697 wxSize const &arg3_defvalue = wxDefaultSize ;
20698 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20699 wxIcon result;
20700 bool temp1 = false ;
20701 bool temp2 = false ;
20702 wxSize temp3 ;
20703 PyObject * obj0 = 0 ;
20704 PyObject * obj1 = 0 ;
20705 PyObject * obj2 = 0 ;
20706 char * kwnames[] = {
20707 (char *) "id",(char *) "client",(char *) "size", NULL
20708 };
20709
20710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20711 {
20712 arg1 = wxString_in_helper(obj0);
20713 if (arg1 == NULL) SWIG_fail;
20714 temp1 = true;
20715 }
20716 if (obj1) {
20717 {
20718 arg2 = wxString_in_helper(obj1);
20719 if (arg2 == NULL) SWIG_fail;
20720 temp2 = true;
20721 }
20722 }
20723 if (obj2) {
20724 {
20725 arg3 = &temp3;
20726 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20727 }
20728 }
20729 {
20730 if (!wxPyCheckForApp()) SWIG_fail;
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20737 {
20738 if (temp1)
20739 delete arg1;
20740 }
20741 {
20742 if (temp2)
20743 delete arg2;
20744 }
20745 return resultobj;
20746 fail:
20747 {
20748 if (temp1)
20749 delete arg1;
20750 }
20751 {
20752 if (temp2)
20753 delete arg2;
20754 }
20755 return NULL;
20756 }
20757
20758
20759 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20760 PyObject *resultobj = 0;
20761 wxString *arg1 = 0 ;
20762 bool arg2 = (bool) false ;
20763 wxSize result;
20764 bool temp1 = false ;
20765 bool val2 ;
20766 int ecode2 = 0 ;
20767 PyObject * obj0 = 0 ;
20768 PyObject * obj1 = 0 ;
20769 char * kwnames[] = {
20770 (char *) "client",(char *) "platform_dependent", NULL
20771 };
20772
20773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20774 {
20775 arg1 = wxString_in_helper(obj0);
20776 if (arg1 == NULL) SWIG_fail;
20777 temp1 = true;
20778 }
20779 if (obj1) {
20780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20781 if (!SWIG_IsOK(ecode2)) {
20782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20783 }
20784 arg2 = static_cast< bool >(val2);
20785 }
20786 {
20787 PyThreadState* __tstate = wxPyBeginAllowThreads();
20788 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20789 wxPyEndAllowThreads(__tstate);
20790 if (PyErr_Occurred()) SWIG_fail;
20791 }
20792 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20793 {
20794 if (temp1)
20795 delete arg1;
20796 }
20797 return resultobj;
20798 fail:
20799 {
20800 if (temp1)
20801 delete arg1;
20802 }
20803 return NULL;
20804 }
20805
20806
20807 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20808 PyObject *resultobj = 0;
20809 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 PyObject *swig_obj[1] ;
20813
20814 if (!args) SWIG_fail;
20815 swig_obj[0] = args;
20816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20819 }
20820 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 wxPyArtProvider_Destroy(arg1);
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 resultobj = SWIG_Py_Void();
20828 return resultobj;
20829 fail:
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20835 PyObject *obj;
20836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20837 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20838 return SWIG_Py_Void();
20839 }
20840
20841 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20842 return SWIG_Python_InitShadowInstance(args);
20843 }
20844
20845 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20846 PyObject *resultobj = 0;
20847 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20848 void *argp1 = 0 ;
20849 int res1 = 0 ;
20850 PyObject *swig_obj[1] ;
20851
20852 if (!args) SWIG_fail;
20853 swig_obj[0] = args;
20854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20855 if (!SWIG_IsOK(res1)) {
20856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20857 }
20858 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20859 {
20860 PyThreadState* __tstate = wxPyBeginAllowThreads();
20861 delete arg1;
20862
20863 wxPyEndAllowThreads(__tstate);
20864 if (PyErr_Occurred()) SWIG_fail;
20865 }
20866 resultobj = SWIG_Py_Void();
20867 return resultobj;
20868 fail:
20869 return NULL;
20870 }
20871
20872
20873 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20874 PyObject *resultobj = 0;
20875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20876 wxConfigBase *result = 0 ;
20877 int res1 = 0 ;
20878 PyObject * obj0 = 0 ;
20879 char * kwnames[] = {
20880 (char *) "config", NULL
20881 };
20882
20883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20884 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20885 if (!SWIG_IsOK(res1)) {
20886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20887 }
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20902 PyObject *resultobj = 0;
20903 bool arg1 = (bool) true ;
20904 wxConfigBase *result = 0 ;
20905 bool val1 ;
20906 int ecode1 = 0 ;
20907 PyObject * obj0 = 0 ;
20908 char * kwnames[] = {
20909 (char *) "createOnDemand", NULL
20910 };
20911
20912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20913 if (obj0) {
20914 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20915 if (!SWIG_IsOK(ecode1)) {
20916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20917 }
20918 arg1 = static_cast< bool >(val1);
20919 }
20920 {
20921 PyThreadState* __tstate = wxPyBeginAllowThreads();
20922 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20923 wxPyEndAllowThreads(__tstate);
20924 if (PyErr_Occurred()) SWIG_fail;
20925 }
20926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20927 return resultobj;
20928 fail:
20929 return NULL;
20930 }
20931
20932
20933 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20934 PyObject *resultobj = 0;
20935 wxConfigBase *result = 0 ;
20936
20937 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20938 {
20939 PyThreadState* __tstate = wxPyBeginAllowThreads();
20940 result = (wxConfigBase *)wxConfigBase::Create();
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20945 return resultobj;
20946 fail:
20947 return NULL;
20948 }
20949
20950
20951 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20952 PyObject *resultobj = 0;
20953
20954 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20955 {
20956 PyThreadState* __tstate = wxPyBeginAllowThreads();
20957 wxConfigBase::DontCreateOnDemand();
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 resultobj = SWIG_Py_Void();
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj = 0;
20970 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20971 wxString *arg2 = 0 ;
20972 void *argp1 = 0 ;
20973 int res1 = 0 ;
20974 bool temp2 = false ;
20975 PyObject * obj0 = 0 ;
20976 PyObject * obj1 = 0 ;
20977 char * kwnames[] = {
20978 (char *) "self",(char *) "path", NULL
20979 };
20980
20981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20983 if (!SWIG_IsOK(res1)) {
20984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20985 }
20986 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20987 {
20988 arg2 = wxString_in_helper(obj1);
20989 if (arg2 == NULL) SWIG_fail;
20990 temp2 = true;
20991 }
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 (arg1)->SetPath((wxString const &)*arg2);
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 resultobj = SWIG_Py_Void();
20999 {
21000 if (temp2)
21001 delete arg2;
21002 }
21003 return resultobj;
21004 fail:
21005 {
21006 if (temp2)
21007 delete arg2;
21008 }
21009 return NULL;
21010 }
21011
21012
21013 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21014 PyObject *resultobj = 0;
21015 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21016 wxString *result = 0 ;
21017 void *argp1 = 0 ;
21018 int res1 = 0 ;
21019 PyObject *swig_obj[1] ;
21020
21021 if (!args) SWIG_fail;
21022 swig_obj[0] = args;
21023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21024 if (!SWIG_IsOK(res1)) {
21025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21026 }
21027 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 {
21031 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21032 result = (wxString *) &_result_ref;
21033 }
21034 wxPyEndAllowThreads(__tstate);
21035 if (PyErr_Occurred()) SWIG_fail;
21036 }
21037 {
21038 #if wxUSE_UNICODE
21039 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21040 #else
21041 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21042 #endif
21043 }
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21051 PyObject *resultobj = 0;
21052 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21053 PyObject *result = 0 ;
21054 void *argp1 = 0 ;
21055 int res1 = 0 ;
21056 PyObject *swig_obj[1] ;
21057
21058 if (!args) SWIG_fail;
21059 swig_obj[0] = args;
21060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21061 if (!SWIG_IsOK(res1)) {
21062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21063 }
21064 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21065 {
21066 PyThreadState* __tstate = wxPyBeginAllowThreads();
21067 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 resultobj = result;
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21079 PyObject *resultobj = 0;
21080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21081 long arg2 ;
21082 PyObject *result = 0 ;
21083 void *argp1 = 0 ;
21084 int res1 = 0 ;
21085 long val2 ;
21086 int ecode2 = 0 ;
21087 PyObject * obj0 = 0 ;
21088 PyObject * obj1 = 0 ;
21089 char * kwnames[] = {
21090 (char *) "self",(char *) "index", NULL
21091 };
21092
21093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21095 if (!SWIG_IsOK(res1)) {
21096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21097 }
21098 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21099 ecode2 = SWIG_AsVal_long(obj1, &val2);
21100 if (!SWIG_IsOK(ecode2)) {
21101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21102 }
21103 arg2 = static_cast< long >(val2);
21104 {
21105 PyThreadState* __tstate = wxPyBeginAllowThreads();
21106 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21107 wxPyEndAllowThreads(__tstate);
21108 if (PyErr_Occurred()) SWIG_fail;
21109 }
21110 resultobj = result;
21111 return resultobj;
21112 fail:
21113 return NULL;
21114 }
21115
21116
21117 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21118 PyObject *resultobj = 0;
21119 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21120 PyObject *result = 0 ;
21121 void *argp1 = 0 ;
21122 int res1 = 0 ;
21123 PyObject *swig_obj[1] ;
21124
21125 if (!args) SWIG_fail;
21126 swig_obj[0] = args;
21127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21128 if (!SWIG_IsOK(res1)) {
21129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21130 }
21131 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21135 wxPyEndAllowThreads(__tstate);
21136 if (PyErr_Occurred()) SWIG_fail;
21137 }
21138 resultobj = result;
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21146 PyObject *resultobj = 0;
21147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21148 long arg2 ;
21149 PyObject *result = 0 ;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 long val2 ;
21153 int ecode2 = 0 ;
21154 PyObject * obj0 = 0 ;
21155 PyObject * obj1 = 0 ;
21156 char * kwnames[] = {
21157 (char *) "self",(char *) "index", NULL
21158 };
21159
21160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21162 if (!SWIG_IsOK(res1)) {
21163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21164 }
21165 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21166 ecode2 = SWIG_AsVal_long(obj1, &val2);
21167 if (!SWIG_IsOK(ecode2)) {
21168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21169 }
21170 arg2 = static_cast< long >(val2);
21171 {
21172 PyThreadState* __tstate = wxPyBeginAllowThreads();
21173 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 resultobj = result;
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21185 PyObject *resultobj = 0;
21186 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21187 bool arg2 = (bool) false ;
21188 size_t result;
21189 void *argp1 = 0 ;
21190 int res1 = 0 ;
21191 bool val2 ;
21192 int ecode2 = 0 ;
21193 PyObject * obj0 = 0 ;
21194 PyObject * obj1 = 0 ;
21195 char * kwnames[] = {
21196 (char *) "self",(char *) "recursive", NULL
21197 };
21198
21199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21201 if (!SWIG_IsOK(res1)) {
21202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21203 }
21204 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21205 if (obj1) {
21206 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21207 if (!SWIG_IsOK(ecode2)) {
21208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21209 }
21210 arg2 = static_cast< bool >(val2);
21211 }
21212 {
21213 PyThreadState* __tstate = wxPyBeginAllowThreads();
21214 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21215 wxPyEndAllowThreads(__tstate);
21216 if (PyErr_Occurred()) SWIG_fail;
21217 }
21218 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21226 PyObject *resultobj = 0;
21227 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21228 bool arg2 = (bool) false ;
21229 size_t result;
21230 void *argp1 = 0 ;
21231 int res1 = 0 ;
21232 bool val2 ;
21233 int ecode2 = 0 ;
21234 PyObject * obj0 = 0 ;
21235 PyObject * obj1 = 0 ;
21236 char * kwnames[] = {
21237 (char *) "self",(char *) "recursive", NULL
21238 };
21239
21240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21242 if (!SWIG_IsOK(res1)) {
21243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21244 }
21245 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21246 if (obj1) {
21247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21248 if (!SWIG_IsOK(ecode2)) {
21249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21250 }
21251 arg2 = static_cast< bool >(val2);
21252 }
21253 {
21254 PyThreadState* __tstate = wxPyBeginAllowThreads();
21255 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21267 PyObject *resultobj = 0;
21268 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21269 wxString *arg2 = 0 ;
21270 bool result;
21271 void *argp1 = 0 ;
21272 int res1 = 0 ;
21273 bool temp2 = false ;
21274 PyObject * obj0 = 0 ;
21275 PyObject * obj1 = 0 ;
21276 char * kwnames[] = {
21277 (char *) "self",(char *) "name", NULL
21278 };
21279
21280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21282 if (!SWIG_IsOK(res1)) {
21283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21284 }
21285 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21286 {
21287 arg2 = wxString_in_helper(obj1);
21288 if (arg2 == NULL) SWIG_fail;
21289 temp2 = true;
21290 }
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 {
21298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21299 }
21300 {
21301 if (temp2)
21302 delete arg2;
21303 }
21304 return resultobj;
21305 fail:
21306 {
21307 if (temp2)
21308 delete arg2;
21309 }
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21315 PyObject *resultobj = 0;
21316 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21317 wxString *arg2 = 0 ;
21318 bool result;
21319 void *argp1 = 0 ;
21320 int res1 = 0 ;
21321 bool temp2 = false ;
21322 PyObject * obj0 = 0 ;
21323 PyObject * obj1 = 0 ;
21324 char * kwnames[] = {
21325 (char *) "self",(char *) "name", NULL
21326 };
21327
21328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21330 if (!SWIG_IsOK(res1)) {
21331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21332 }
21333 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21334 {
21335 arg2 = wxString_in_helper(obj1);
21336 if (arg2 == NULL) SWIG_fail;
21337 temp2 = true;
21338 }
21339 {
21340 PyThreadState* __tstate = wxPyBeginAllowThreads();
21341 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21342 wxPyEndAllowThreads(__tstate);
21343 if (PyErr_Occurred()) SWIG_fail;
21344 }
21345 {
21346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21347 }
21348 {
21349 if (temp2)
21350 delete arg2;
21351 }
21352 return resultobj;
21353 fail:
21354 {
21355 if (temp2)
21356 delete arg2;
21357 }
21358 return NULL;
21359 }
21360
21361
21362 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21363 PyObject *resultobj = 0;
21364 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21365 wxString *arg2 = 0 ;
21366 bool result;
21367 void *argp1 = 0 ;
21368 int res1 = 0 ;
21369 bool temp2 = false ;
21370 PyObject * obj0 = 0 ;
21371 PyObject * obj1 = 0 ;
21372 char * kwnames[] = {
21373 (char *) "self",(char *) "name", NULL
21374 };
21375
21376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21378 if (!SWIG_IsOK(res1)) {
21379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21380 }
21381 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21382 {
21383 arg2 = wxString_in_helper(obj1);
21384 if (arg2 == NULL) SWIG_fail;
21385 temp2 = true;
21386 }
21387 {
21388 PyThreadState* __tstate = wxPyBeginAllowThreads();
21389 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21390 wxPyEndAllowThreads(__tstate);
21391 if (PyErr_Occurred()) SWIG_fail;
21392 }
21393 {
21394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21395 }
21396 {
21397 if (temp2)
21398 delete arg2;
21399 }
21400 return resultobj;
21401 fail:
21402 {
21403 if (temp2)
21404 delete arg2;
21405 }
21406 return NULL;
21407 }
21408
21409
21410 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21411 PyObject *resultobj = 0;
21412 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21413 wxString *arg2 = 0 ;
21414 wxConfigBase::EntryType result;
21415 void *argp1 = 0 ;
21416 int res1 = 0 ;
21417 bool temp2 = false ;
21418 PyObject * obj0 = 0 ;
21419 PyObject * obj1 = 0 ;
21420 char * kwnames[] = {
21421 (char *) "self",(char *) "name", NULL
21422 };
21423
21424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21426 if (!SWIG_IsOK(res1)) {
21427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21428 }
21429 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21430 {
21431 arg2 = wxString_in_helper(obj1);
21432 if (arg2 == NULL) SWIG_fail;
21433 temp2 = true;
21434 }
21435 {
21436 PyThreadState* __tstate = wxPyBeginAllowThreads();
21437 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21438 wxPyEndAllowThreads(__tstate);
21439 if (PyErr_Occurred()) SWIG_fail;
21440 }
21441 resultobj = SWIG_From_int(static_cast< int >(result));
21442 {
21443 if (temp2)
21444 delete arg2;
21445 }
21446 return resultobj;
21447 fail:
21448 {
21449 if (temp2)
21450 delete arg2;
21451 }
21452 return NULL;
21453 }
21454
21455
21456 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21457 PyObject *resultobj = 0;
21458 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21459 wxString *arg2 = 0 ;
21460 wxString const &arg3_defvalue = wxPyEmptyString ;
21461 wxString *arg3 = (wxString *) &arg3_defvalue ;
21462 wxString result;
21463 void *argp1 = 0 ;
21464 int res1 = 0 ;
21465 bool temp2 = false ;
21466 bool temp3 = false ;
21467 PyObject * obj0 = 0 ;
21468 PyObject * obj1 = 0 ;
21469 PyObject * obj2 = 0 ;
21470 char * kwnames[] = {
21471 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21472 };
21473
21474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21476 if (!SWIG_IsOK(res1)) {
21477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21478 }
21479 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21480 {
21481 arg2 = wxString_in_helper(obj1);
21482 if (arg2 == NULL) SWIG_fail;
21483 temp2 = true;
21484 }
21485 if (obj2) {
21486 {
21487 arg3 = wxString_in_helper(obj2);
21488 if (arg3 == NULL) SWIG_fail;
21489 temp3 = true;
21490 }
21491 }
21492 {
21493 PyThreadState* __tstate = wxPyBeginAllowThreads();
21494 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21495 wxPyEndAllowThreads(__tstate);
21496 if (PyErr_Occurred()) SWIG_fail;
21497 }
21498 {
21499 #if wxUSE_UNICODE
21500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21501 #else
21502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21503 #endif
21504 }
21505 {
21506 if (temp2)
21507 delete arg2;
21508 }
21509 {
21510 if (temp3)
21511 delete arg3;
21512 }
21513 return resultobj;
21514 fail:
21515 {
21516 if (temp2)
21517 delete arg2;
21518 }
21519 {
21520 if (temp3)
21521 delete arg3;
21522 }
21523 return NULL;
21524 }
21525
21526
21527 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21528 PyObject *resultobj = 0;
21529 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21530 wxString *arg2 = 0 ;
21531 long arg3 = (long) 0 ;
21532 long result;
21533 void *argp1 = 0 ;
21534 int res1 = 0 ;
21535 bool temp2 = false ;
21536 long val3 ;
21537 int ecode3 = 0 ;
21538 PyObject * obj0 = 0 ;
21539 PyObject * obj1 = 0 ;
21540 PyObject * obj2 = 0 ;
21541 char * kwnames[] = {
21542 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21543 };
21544
21545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21547 if (!SWIG_IsOK(res1)) {
21548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21549 }
21550 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21551 {
21552 arg2 = wxString_in_helper(obj1);
21553 if (arg2 == NULL) SWIG_fail;
21554 temp2 = true;
21555 }
21556 if (obj2) {
21557 ecode3 = SWIG_AsVal_long(obj2, &val3);
21558 if (!SWIG_IsOK(ecode3)) {
21559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21560 }
21561 arg3 = static_cast< long >(val3);
21562 }
21563 {
21564 PyThreadState* __tstate = wxPyBeginAllowThreads();
21565 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21566 wxPyEndAllowThreads(__tstate);
21567 if (PyErr_Occurred()) SWIG_fail;
21568 }
21569 resultobj = SWIG_From_long(static_cast< long >(result));
21570 {
21571 if (temp2)
21572 delete arg2;
21573 }
21574 return resultobj;
21575 fail:
21576 {
21577 if (temp2)
21578 delete arg2;
21579 }
21580 return NULL;
21581 }
21582
21583
21584 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21585 PyObject *resultobj = 0;
21586 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21587 wxString *arg2 = 0 ;
21588 double arg3 = (double) 0.0 ;
21589 double result;
21590 void *argp1 = 0 ;
21591 int res1 = 0 ;
21592 bool temp2 = false ;
21593 double val3 ;
21594 int ecode3 = 0 ;
21595 PyObject * obj0 = 0 ;
21596 PyObject * obj1 = 0 ;
21597 PyObject * obj2 = 0 ;
21598 char * kwnames[] = {
21599 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21600 };
21601
21602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21604 if (!SWIG_IsOK(res1)) {
21605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21606 }
21607 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21608 {
21609 arg2 = wxString_in_helper(obj1);
21610 if (arg2 == NULL) SWIG_fail;
21611 temp2 = true;
21612 }
21613 if (obj2) {
21614 ecode3 = SWIG_AsVal_double(obj2, &val3);
21615 if (!SWIG_IsOK(ecode3)) {
21616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21617 }
21618 arg3 = static_cast< double >(val3);
21619 }
21620 {
21621 PyThreadState* __tstate = wxPyBeginAllowThreads();
21622 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21623 wxPyEndAllowThreads(__tstate);
21624 if (PyErr_Occurred()) SWIG_fail;
21625 }
21626 resultobj = SWIG_From_double(static_cast< double >(result));
21627 {
21628 if (temp2)
21629 delete arg2;
21630 }
21631 return resultobj;
21632 fail:
21633 {
21634 if (temp2)
21635 delete arg2;
21636 }
21637 return NULL;
21638 }
21639
21640
21641 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21642 PyObject *resultobj = 0;
21643 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21644 wxString *arg2 = 0 ;
21645 bool arg3 = (bool) false ;
21646 bool result;
21647 void *argp1 = 0 ;
21648 int res1 = 0 ;
21649 bool temp2 = false ;
21650 bool val3 ;
21651 int ecode3 = 0 ;
21652 PyObject * obj0 = 0 ;
21653 PyObject * obj1 = 0 ;
21654 PyObject * obj2 = 0 ;
21655 char * kwnames[] = {
21656 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21657 };
21658
21659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21661 if (!SWIG_IsOK(res1)) {
21662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21663 }
21664 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21665 {
21666 arg2 = wxString_in_helper(obj1);
21667 if (arg2 == NULL) SWIG_fail;
21668 temp2 = true;
21669 }
21670 if (obj2) {
21671 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21672 if (!SWIG_IsOK(ecode3)) {
21673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21674 }
21675 arg3 = static_cast< bool >(val3);
21676 }
21677 {
21678 PyThreadState* __tstate = wxPyBeginAllowThreads();
21679 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21680 wxPyEndAllowThreads(__tstate);
21681 if (PyErr_Occurred()) SWIG_fail;
21682 }
21683 {
21684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21685 }
21686 {
21687 if (temp2)
21688 delete arg2;
21689 }
21690 return resultobj;
21691 fail:
21692 {
21693 if (temp2)
21694 delete arg2;
21695 }
21696 return NULL;
21697 }
21698
21699
21700 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21701 PyObject *resultobj = 0;
21702 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21703 wxString *arg2 = 0 ;
21704 wxString *arg3 = 0 ;
21705 bool result;
21706 void *argp1 = 0 ;
21707 int res1 = 0 ;
21708 bool temp2 = false ;
21709 bool temp3 = false ;
21710 PyObject * obj0 = 0 ;
21711 PyObject * obj1 = 0 ;
21712 PyObject * obj2 = 0 ;
21713 char * kwnames[] = {
21714 (char *) "self",(char *) "key",(char *) "value", NULL
21715 };
21716
21717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21719 if (!SWIG_IsOK(res1)) {
21720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21721 }
21722 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21723 {
21724 arg2 = wxString_in_helper(obj1);
21725 if (arg2 == NULL) SWIG_fail;
21726 temp2 = true;
21727 }
21728 {
21729 arg3 = wxString_in_helper(obj2);
21730 if (arg3 == NULL) SWIG_fail;
21731 temp3 = true;
21732 }
21733 {
21734 PyThreadState* __tstate = wxPyBeginAllowThreads();
21735 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21736 wxPyEndAllowThreads(__tstate);
21737 if (PyErr_Occurred()) SWIG_fail;
21738 }
21739 {
21740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21741 }
21742 {
21743 if (temp2)
21744 delete arg2;
21745 }
21746 {
21747 if (temp3)
21748 delete arg3;
21749 }
21750 return resultobj;
21751 fail:
21752 {
21753 if (temp2)
21754 delete arg2;
21755 }
21756 {
21757 if (temp3)
21758 delete arg3;
21759 }
21760 return NULL;
21761 }
21762
21763
21764 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21765 PyObject *resultobj = 0;
21766 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21767 wxString *arg2 = 0 ;
21768 long arg3 ;
21769 bool result;
21770 void *argp1 = 0 ;
21771 int res1 = 0 ;
21772 bool temp2 = false ;
21773 long val3 ;
21774 int ecode3 = 0 ;
21775 PyObject * obj0 = 0 ;
21776 PyObject * obj1 = 0 ;
21777 PyObject * obj2 = 0 ;
21778 char * kwnames[] = {
21779 (char *) "self",(char *) "key",(char *) "value", NULL
21780 };
21781
21782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21784 if (!SWIG_IsOK(res1)) {
21785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21786 }
21787 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21788 {
21789 arg2 = wxString_in_helper(obj1);
21790 if (arg2 == NULL) SWIG_fail;
21791 temp2 = true;
21792 }
21793 ecode3 = SWIG_AsVal_long(obj2, &val3);
21794 if (!SWIG_IsOK(ecode3)) {
21795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21796 }
21797 arg3 = static_cast< long >(val3);
21798 {
21799 PyThreadState* __tstate = wxPyBeginAllowThreads();
21800 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21801 wxPyEndAllowThreads(__tstate);
21802 if (PyErr_Occurred()) SWIG_fail;
21803 }
21804 {
21805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21806 }
21807 {
21808 if (temp2)
21809 delete arg2;
21810 }
21811 return resultobj;
21812 fail:
21813 {
21814 if (temp2)
21815 delete arg2;
21816 }
21817 return NULL;
21818 }
21819
21820
21821 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21822 PyObject *resultobj = 0;
21823 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21824 wxString *arg2 = 0 ;
21825 double arg3 ;
21826 bool result;
21827 void *argp1 = 0 ;
21828 int res1 = 0 ;
21829 bool temp2 = false ;
21830 double val3 ;
21831 int ecode3 = 0 ;
21832 PyObject * obj0 = 0 ;
21833 PyObject * obj1 = 0 ;
21834 PyObject * obj2 = 0 ;
21835 char * kwnames[] = {
21836 (char *) "self",(char *) "key",(char *) "value", NULL
21837 };
21838
21839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21841 if (!SWIG_IsOK(res1)) {
21842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21843 }
21844 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21845 {
21846 arg2 = wxString_in_helper(obj1);
21847 if (arg2 == NULL) SWIG_fail;
21848 temp2 = true;
21849 }
21850 ecode3 = SWIG_AsVal_double(obj2, &val3);
21851 if (!SWIG_IsOK(ecode3)) {
21852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21853 }
21854 arg3 = static_cast< double >(val3);
21855 {
21856 PyThreadState* __tstate = wxPyBeginAllowThreads();
21857 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21858 wxPyEndAllowThreads(__tstate);
21859 if (PyErr_Occurred()) SWIG_fail;
21860 }
21861 {
21862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21863 }
21864 {
21865 if (temp2)
21866 delete arg2;
21867 }
21868 return resultobj;
21869 fail:
21870 {
21871 if (temp2)
21872 delete arg2;
21873 }
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21879 PyObject *resultobj = 0;
21880 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21881 wxString *arg2 = 0 ;
21882 bool arg3 ;
21883 bool result;
21884 void *argp1 = 0 ;
21885 int res1 = 0 ;
21886 bool temp2 = false ;
21887 bool val3 ;
21888 int ecode3 = 0 ;
21889 PyObject * obj0 = 0 ;
21890 PyObject * obj1 = 0 ;
21891 PyObject * obj2 = 0 ;
21892 char * kwnames[] = {
21893 (char *) "self",(char *) "key",(char *) "value", NULL
21894 };
21895
21896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21898 if (!SWIG_IsOK(res1)) {
21899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21900 }
21901 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21902 {
21903 arg2 = wxString_in_helper(obj1);
21904 if (arg2 == NULL) SWIG_fail;
21905 temp2 = true;
21906 }
21907 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21908 if (!SWIG_IsOK(ecode3)) {
21909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21910 }
21911 arg3 = static_cast< bool >(val3);
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21915 wxPyEndAllowThreads(__tstate);
21916 if (PyErr_Occurred()) SWIG_fail;
21917 }
21918 {
21919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21920 }
21921 {
21922 if (temp2)
21923 delete arg2;
21924 }
21925 return resultobj;
21926 fail:
21927 {
21928 if (temp2)
21929 delete arg2;
21930 }
21931 return NULL;
21932 }
21933
21934
21935 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21936 PyObject *resultobj = 0;
21937 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21938 bool arg2 = (bool) false ;
21939 bool result;
21940 void *argp1 = 0 ;
21941 int res1 = 0 ;
21942 bool val2 ;
21943 int ecode2 = 0 ;
21944 PyObject * obj0 = 0 ;
21945 PyObject * obj1 = 0 ;
21946 char * kwnames[] = {
21947 (char *) "self",(char *) "currentOnly", NULL
21948 };
21949
21950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21952 if (!SWIG_IsOK(res1)) {
21953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21954 }
21955 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21956 if (obj1) {
21957 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21958 if (!SWIG_IsOK(ecode2)) {
21959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21960 }
21961 arg2 = static_cast< bool >(val2);
21962 }
21963 {
21964 PyThreadState* __tstate = wxPyBeginAllowThreads();
21965 result = (bool)(arg1)->Flush(arg2);
21966 wxPyEndAllowThreads(__tstate);
21967 if (PyErr_Occurred()) SWIG_fail;
21968 }
21969 {
21970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21971 }
21972 return resultobj;
21973 fail:
21974 return NULL;
21975 }
21976
21977
21978 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21979 PyObject *resultobj = 0;
21980 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21981 wxString *arg2 = 0 ;
21982 wxString *arg3 = 0 ;
21983 bool result;
21984 void *argp1 = 0 ;
21985 int res1 = 0 ;
21986 bool temp2 = false ;
21987 bool temp3 = false ;
21988 PyObject * obj0 = 0 ;
21989 PyObject * obj1 = 0 ;
21990 PyObject * obj2 = 0 ;
21991 char * kwnames[] = {
21992 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21993 };
21994
21995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21997 if (!SWIG_IsOK(res1)) {
21998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21999 }
22000 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22001 {
22002 arg2 = wxString_in_helper(obj1);
22003 if (arg2 == NULL) SWIG_fail;
22004 temp2 = true;
22005 }
22006 {
22007 arg3 = wxString_in_helper(obj2);
22008 if (arg3 == NULL) SWIG_fail;
22009 temp3 = true;
22010 }
22011 {
22012 PyThreadState* __tstate = wxPyBeginAllowThreads();
22013 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22014 wxPyEndAllowThreads(__tstate);
22015 if (PyErr_Occurred()) SWIG_fail;
22016 }
22017 {
22018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22019 }
22020 {
22021 if (temp2)
22022 delete arg2;
22023 }
22024 {
22025 if (temp3)
22026 delete arg3;
22027 }
22028 return resultobj;
22029 fail:
22030 {
22031 if (temp2)
22032 delete arg2;
22033 }
22034 {
22035 if (temp3)
22036 delete arg3;
22037 }
22038 return NULL;
22039 }
22040
22041
22042 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22043 PyObject *resultobj = 0;
22044 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22045 wxString *arg2 = 0 ;
22046 wxString *arg3 = 0 ;
22047 bool result;
22048 void *argp1 = 0 ;
22049 int res1 = 0 ;
22050 bool temp2 = false ;
22051 bool temp3 = false ;
22052 PyObject * obj0 = 0 ;
22053 PyObject * obj1 = 0 ;
22054 PyObject * obj2 = 0 ;
22055 char * kwnames[] = {
22056 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22057 };
22058
22059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22063 }
22064 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22065 {
22066 arg2 = wxString_in_helper(obj1);
22067 if (arg2 == NULL) SWIG_fail;
22068 temp2 = true;
22069 }
22070 {
22071 arg3 = wxString_in_helper(obj2);
22072 if (arg3 == NULL) SWIG_fail;
22073 temp3 = true;
22074 }
22075 {
22076 PyThreadState* __tstate = wxPyBeginAllowThreads();
22077 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22078 wxPyEndAllowThreads(__tstate);
22079 if (PyErr_Occurred()) SWIG_fail;
22080 }
22081 {
22082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22083 }
22084 {
22085 if (temp2)
22086 delete arg2;
22087 }
22088 {
22089 if (temp3)
22090 delete arg3;
22091 }
22092 return resultobj;
22093 fail:
22094 {
22095 if (temp2)
22096 delete arg2;
22097 }
22098 {
22099 if (temp3)
22100 delete arg3;
22101 }
22102 return NULL;
22103 }
22104
22105
22106 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22107 PyObject *resultobj = 0;
22108 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22109 wxString *arg2 = 0 ;
22110 bool arg3 = (bool) true ;
22111 bool result;
22112 void *argp1 = 0 ;
22113 int res1 = 0 ;
22114 bool temp2 = false ;
22115 bool val3 ;
22116 int ecode3 = 0 ;
22117 PyObject * obj0 = 0 ;
22118 PyObject * obj1 = 0 ;
22119 PyObject * obj2 = 0 ;
22120 char * kwnames[] = {
22121 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22122 };
22123
22124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22126 if (!SWIG_IsOK(res1)) {
22127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22128 }
22129 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22130 {
22131 arg2 = wxString_in_helper(obj1);
22132 if (arg2 == NULL) SWIG_fail;
22133 temp2 = true;
22134 }
22135 if (obj2) {
22136 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22137 if (!SWIG_IsOK(ecode3)) {
22138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22139 }
22140 arg3 = static_cast< bool >(val3);
22141 }
22142 {
22143 PyThreadState* __tstate = wxPyBeginAllowThreads();
22144 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 {
22149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22150 }
22151 {
22152 if (temp2)
22153 delete arg2;
22154 }
22155 return resultobj;
22156 fail:
22157 {
22158 if (temp2)
22159 delete arg2;
22160 }
22161 return NULL;
22162 }
22163
22164
22165 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22166 PyObject *resultobj = 0;
22167 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22168 wxString *arg2 = 0 ;
22169 bool result;
22170 void *argp1 = 0 ;
22171 int res1 = 0 ;
22172 bool temp2 = false ;
22173 PyObject * obj0 = 0 ;
22174 PyObject * obj1 = 0 ;
22175 char * kwnames[] = {
22176 (char *) "self",(char *) "key", NULL
22177 };
22178
22179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22181 if (!SWIG_IsOK(res1)) {
22182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22183 }
22184 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22185 {
22186 arg2 = wxString_in_helper(obj1);
22187 if (arg2 == NULL) SWIG_fail;
22188 temp2 = true;
22189 }
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22193 wxPyEndAllowThreads(__tstate);
22194 if (PyErr_Occurred()) SWIG_fail;
22195 }
22196 {
22197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22198 }
22199 {
22200 if (temp2)
22201 delete arg2;
22202 }
22203 return resultobj;
22204 fail:
22205 {
22206 if (temp2)
22207 delete arg2;
22208 }
22209 return NULL;
22210 }
22211
22212
22213 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22214 PyObject *resultobj = 0;
22215 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22216 bool result;
22217 void *argp1 = 0 ;
22218 int res1 = 0 ;
22219 PyObject *swig_obj[1] ;
22220
22221 if (!args) SWIG_fail;
22222 swig_obj[0] = args;
22223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22224 if (!SWIG_IsOK(res1)) {
22225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22226 }
22227 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22228 {
22229 PyThreadState* __tstate = wxPyBeginAllowThreads();
22230 result = (bool)(arg1)->DeleteAll();
22231 wxPyEndAllowThreads(__tstate);
22232 if (PyErr_Occurred()) SWIG_fail;
22233 }
22234 {
22235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22236 }
22237 return resultobj;
22238 fail:
22239 return NULL;
22240 }
22241
22242
22243 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22244 PyObject *resultobj = 0;
22245 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22246 bool arg2 = (bool) true ;
22247 void *argp1 = 0 ;
22248 int res1 = 0 ;
22249 bool val2 ;
22250 int ecode2 = 0 ;
22251 PyObject * obj0 = 0 ;
22252 PyObject * obj1 = 0 ;
22253 char * kwnames[] = {
22254 (char *) "self",(char *) "doIt", NULL
22255 };
22256
22257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22259 if (!SWIG_IsOK(res1)) {
22260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22261 }
22262 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22263 if (obj1) {
22264 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22265 if (!SWIG_IsOK(ecode2)) {
22266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22267 }
22268 arg2 = static_cast< bool >(val2);
22269 }
22270 {
22271 PyThreadState* __tstate = wxPyBeginAllowThreads();
22272 (arg1)->SetExpandEnvVars(arg2);
22273 wxPyEndAllowThreads(__tstate);
22274 if (PyErr_Occurred()) SWIG_fail;
22275 }
22276 resultobj = SWIG_Py_Void();
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22284 PyObject *resultobj = 0;
22285 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22286 bool result;
22287 void *argp1 = 0 ;
22288 int res1 = 0 ;
22289 PyObject *swig_obj[1] ;
22290
22291 if (!args) SWIG_fail;
22292 swig_obj[0] = args;
22293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22294 if (!SWIG_IsOK(res1)) {
22295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22296 }
22297 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22301 wxPyEndAllowThreads(__tstate);
22302 if (PyErr_Occurred()) SWIG_fail;
22303 }
22304 {
22305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22306 }
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22314 PyObject *resultobj = 0;
22315 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22316 bool arg2 = (bool) true ;
22317 void *argp1 = 0 ;
22318 int res1 = 0 ;
22319 bool val2 ;
22320 int ecode2 = 0 ;
22321 PyObject * obj0 = 0 ;
22322 PyObject * obj1 = 0 ;
22323 char * kwnames[] = {
22324 (char *) "self",(char *) "doIt", NULL
22325 };
22326
22327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22329 if (!SWIG_IsOK(res1)) {
22330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22331 }
22332 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22333 if (obj1) {
22334 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22335 if (!SWIG_IsOK(ecode2)) {
22336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22337 }
22338 arg2 = static_cast< bool >(val2);
22339 }
22340 {
22341 PyThreadState* __tstate = wxPyBeginAllowThreads();
22342 (arg1)->SetRecordDefaults(arg2);
22343 wxPyEndAllowThreads(__tstate);
22344 if (PyErr_Occurred()) SWIG_fail;
22345 }
22346 resultobj = SWIG_Py_Void();
22347 return resultobj;
22348 fail:
22349 return NULL;
22350 }
22351
22352
22353 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22354 PyObject *resultobj = 0;
22355 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22356 bool result;
22357 void *argp1 = 0 ;
22358 int res1 = 0 ;
22359 PyObject *swig_obj[1] ;
22360
22361 if (!args) SWIG_fail;
22362 swig_obj[0] = args;
22363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22364 if (!SWIG_IsOK(res1)) {
22365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22366 }
22367 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22368 {
22369 PyThreadState* __tstate = wxPyBeginAllowThreads();
22370 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22371 wxPyEndAllowThreads(__tstate);
22372 if (PyErr_Occurred()) SWIG_fail;
22373 }
22374 {
22375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22376 }
22377 return resultobj;
22378 fail:
22379 return NULL;
22380 }
22381
22382
22383 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22384 PyObject *resultobj = 0;
22385 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22386 wxString *arg2 = 0 ;
22387 wxString result;
22388 void *argp1 = 0 ;
22389 int res1 = 0 ;
22390 bool temp2 = false ;
22391 PyObject * obj0 = 0 ;
22392 PyObject * obj1 = 0 ;
22393 char * kwnames[] = {
22394 (char *) "self",(char *) "str", NULL
22395 };
22396
22397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22399 if (!SWIG_IsOK(res1)) {
22400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22401 }
22402 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22403 {
22404 arg2 = wxString_in_helper(obj1);
22405 if (arg2 == NULL) SWIG_fail;
22406 temp2 = true;
22407 }
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 {
22415 #if wxUSE_UNICODE
22416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22417 #else
22418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22419 #endif
22420 }
22421 {
22422 if (temp2)
22423 delete arg2;
22424 }
22425 return resultobj;
22426 fail:
22427 {
22428 if (temp2)
22429 delete arg2;
22430 }
22431 return NULL;
22432 }
22433
22434
22435 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22436 PyObject *resultobj = 0;
22437 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22438 wxString result;
22439 void *argp1 = 0 ;
22440 int res1 = 0 ;
22441 PyObject *swig_obj[1] ;
22442
22443 if (!args) SWIG_fail;
22444 swig_obj[0] = args;
22445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22446 if (!SWIG_IsOK(res1)) {
22447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22448 }
22449 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22450 {
22451 PyThreadState* __tstate = wxPyBeginAllowThreads();
22452 result = ((wxConfigBase const *)arg1)->GetAppName();
22453 wxPyEndAllowThreads(__tstate);
22454 if (PyErr_Occurred()) SWIG_fail;
22455 }
22456 {
22457 #if wxUSE_UNICODE
22458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22459 #else
22460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22461 #endif
22462 }
22463 return resultobj;
22464 fail:
22465 return NULL;
22466 }
22467
22468
22469 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22470 PyObject *resultobj = 0;
22471 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22472 wxString result;
22473 void *argp1 = 0 ;
22474 int res1 = 0 ;
22475 PyObject *swig_obj[1] ;
22476
22477 if (!args) SWIG_fail;
22478 swig_obj[0] = args;
22479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22480 if (!SWIG_IsOK(res1)) {
22481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22482 }
22483 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22484 {
22485 PyThreadState* __tstate = wxPyBeginAllowThreads();
22486 result = ((wxConfigBase const *)arg1)->GetVendorName();
22487 wxPyEndAllowThreads(__tstate);
22488 if (PyErr_Occurred()) SWIG_fail;
22489 }
22490 {
22491 #if wxUSE_UNICODE
22492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22493 #else
22494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22495 #endif
22496 }
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj = 0;
22505 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22506 wxString *arg2 = 0 ;
22507 void *argp1 = 0 ;
22508 int res1 = 0 ;
22509 bool temp2 = false ;
22510 PyObject * obj0 = 0 ;
22511 PyObject * obj1 = 0 ;
22512 char * kwnames[] = {
22513 (char *) "self",(char *) "appName", NULL
22514 };
22515
22516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22518 if (!SWIG_IsOK(res1)) {
22519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22520 }
22521 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22522 {
22523 arg2 = wxString_in_helper(obj1);
22524 if (arg2 == NULL) SWIG_fail;
22525 temp2 = true;
22526 }
22527 {
22528 PyThreadState* __tstate = wxPyBeginAllowThreads();
22529 (arg1)->SetAppName((wxString const &)*arg2);
22530 wxPyEndAllowThreads(__tstate);
22531 if (PyErr_Occurred()) SWIG_fail;
22532 }
22533 resultobj = SWIG_Py_Void();
22534 {
22535 if (temp2)
22536 delete arg2;
22537 }
22538 return resultobj;
22539 fail:
22540 {
22541 if (temp2)
22542 delete arg2;
22543 }
22544 return NULL;
22545 }
22546
22547
22548 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22549 PyObject *resultobj = 0;
22550 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22551 wxString *arg2 = 0 ;
22552 void *argp1 = 0 ;
22553 int res1 = 0 ;
22554 bool temp2 = false ;
22555 PyObject * obj0 = 0 ;
22556 PyObject * obj1 = 0 ;
22557 char * kwnames[] = {
22558 (char *) "self",(char *) "vendorName", NULL
22559 };
22560
22561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22563 if (!SWIG_IsOK(res1)) {
22564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22565 }
22566 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22567 {
22568 arg2 = wxString_in_helper(obj1);
22569 if (arg2 == NULL) SWIG_fail;
22570 temp2 = true;
22571 }
22572 {
22573 PyThreadState* __tstate = wxPyBeginAllowThreads();
22574 (arg1)->SetVendorName((wxString const &)*arg2);
22575 wxPyEndAllowThreads(__tstate);
22576 if (PyErr_Occurred()) SWIG_fail;
22577 }
22578 resultobj = SWIG_Py_Void();
22579 {
22580 if (temp2)
22581 delete arg2;
22582 }
22583 return resultobj;
22584 fail:
22585 {
22586 if (temp2)
22587 delete arg2;
22588 }
22589 return NULL;
22590 }
22591
22592
22593 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22594 PyObject *resultobj = 0;
22595 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22596 long arg2 ;
22597 void *argp1 = 0 ;
22598 int res1 = 0 ;
22599 long val2 ;
22600 int ecode2 = 0 ;
22601 PyObject * obj0 = 0 ;
22602 PyObject * obj1 = 0 ;
22603 char * kwnames[] = {
22604 (char *) "self",(char *) "style", NULL
22605 };
22606
22607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22609 if (!SWIG_IsOK(res1)) {
22610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22611 }
22612 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22613 ecode2 = SWIG_AsVal_long(obj1, &val2);
22614 if (!SWIG_IsOK(ecode2)) {
22615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22616 }
22617 arg2 = static_cast< long >(val2);
22618 {
22619 PyThreadState* __tstate = wxPyBeginAllowThreads();
22620 (arg1)->SetStyle(arg2);
22621 wxPyEndAllowThreads(__tstate);
22622 if (PyErr_Occurred()) SWIG_fail;
22623 }
22624 resultobj = SWIG_Py_Void();
22625 return resultobj;
22626 fail:
22627 return NULL;
22628 }
22629
22630
22631 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22632 PyObject *resultobj = 0;
22633 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22634 long result;
22635 void *argp1 = 0 ;
22636 int res1 = 0 ;
22637 PyObject *swig_obj[1] ;
22638
22639 if (!args) SWIG_fail;
22640 swig_obj[0] = args;
22641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22642 if (!SWIG_IsOK(res1)) {
22643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22644 }
22645 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22646 {
22647 PyThreadState* __tstate = wxPyBeginAllowThreads();
22648 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22649 wxPyEndAllowThreads(__tstate);
22650 if (PyErr_Occurred()) SWIG_fail;
22651 }
22652 resultobj = SWIG_From_long(static_cast< long >(result));
22653 return resultobj;
22654 fail:
22655 return NULL;
22656 }
22657
22658
22659 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22660 PyObject *obj;
22661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22662 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22663 return SWIG_Py_Void();
22664 }
22665
22666 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22667 PyObject *resultobj = 0;
22668 wxString const &arg1_defvalue = wxPyEmptyString ;
22669 wxString *arg1 = (wxString *) &arg1_defvalue ;
22670 wxString const &arg2_defvalue = wxPyEmptyString ;
22671 wxString *arg2 = (wxString *) &arg2_defvalue ;
22672 wxString const &arg3_defvalue = wxPyEmptyString ;
22673 wxString *arg3 = (wxString *) &arg3_defvalue ;
22674 wxString const &arg4_defvalue = wxPyEmptyString ;
22675 wxString *arg4 = (wxString *) &arg4_defvalue ;
22676 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22677 wxConfig *result = 0 ;
22678 bool temp1 = false ;
22679 bool temp2 = false ;
22680 bool temp3 = false ;
22681 bool temp4 = false ;
22682 long val5 ;
22683 int ecode5 = 0 ;
22684 PyObject * obj0 = 0 ;
22685 PyObject * obj1 = 0 ;
22686 PyObject * obj2 = 0 ;
22687 PyObject * obj3 = 0 ;
22688 PyObject * obj4 = 0 ;
22689 char * kwnames[] = {
22690 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22691 };
22692
22693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22694 if (obj0) {
22695 {
22696 arg1 = wxString_in_helper(obj0);
22697 if (arg1 == NULL) SWIG_fail;
22698 temp1 = true;
22699 }
22700 }
22701 if (obj1) {
22702 {
22703 arg2 = wxString_in_helper(obj1);
22704 if (arg2 == NULL) SWIG_fail;
22705 temp2 = true;
22706 }
22707 }
22708 if (obj2) {
22709 {
22710 arg3 = wxString_in_helper(obj2);
22711 if (arg3 == NULL) SWIG_fail;
22712 temp3 = true;
22713 }
22714 }
22715 if (obj3) {
22716 {
22717 arg4 = wxString_in_helper(obj3);
22718 if (arg4 == NULL) SWIG_fail;
22719 temp4 = true;
22720 }
22721 }
22722 if (obj4) {
22723 ecode5 = SWIG_AsVal_long(obj4, &val5);
22724 if (!SWIG_IsOK(ecode5)) {
22725 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22726 }
22727 arg5 = static_cast< long >(val5);
22728 }
22729 {
22730 PyThreadState* __tstate = wxPyBeginAllowThreads();
22731 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22732 wxPyEndAllowThreads(__tstate);
22733 if (PyErr_Occurred()) SWIG_fail;
22734 }
22735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22736 {
22737 if (temp1)
22738 delete arg1;
22739 }
22740 {
22741 if (temp2)
22742 delete arg2;
22743 }
22744 {
22745 if (temp3)
22746 delete arg3;
22747 }
22748 {
22749 if (temp4)
22750 delete arg4;
22751 }
22752 return resultobj;
22753 fail:
22754 {
22755 if (temp1)
22756 delete arg1;
22757 }
22758 {
22759 if (temp2)
22760 delete arg2;
22761 }
22762 {
22763 if (temp3)
22764 delete arg3;
22765 }
22766 {
22767 if (temp4)
22768 delete arg4;
22769 }
22770 return NULL;
22771 }
22772
22773
22774 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22775 PyObject *resultobj = 0;
22776 wxConfig *arg1 = (wxConfig *) 0 ;
22777 void *argp1 = 0 ;
22778 int res1 = 0 ;
22779 PyObject *swig_obj[1] ;
22780
22781 if (!args) SWIG_fail;
22782 swig_obj[0] = args;
22783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22784 if (!SWIG_IsOK(res1)) {
22785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22786 }
22787 arg1 = reinterpret_cast< wxConfig * >(argp1);
22788 {
22789 PyThreadState* __tstate = wxPyBeginAllowThreads();
22790 delete arg1;
22791
22792 wxPyEndAllowThreads(__tstate);
22793 if (PyErr_Occurred()) SWIG_fail;
22794 }
22795 resultobj = SWIG_Py_Void();
22796 return resultobj;
22797 fail:
22798 return NULL;
22799 }
22800
22801
22802 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22803 PyObject *obj;
22804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22805 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22806 return SWIG_Py_Void();
22807 }
22808
22809 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22810 return SWIG_Python_InitShadowInstance(args);
22811 }
22812
22813 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22814 PyObject *resultobj = 0;
22815 wxString const &arg1_defvalue = wxPyEmptyString ;
22816 wxString *arg1 = (wxString *) &arg1_defvalue ;
22817 wxString const &arg2_defvalue = wxPyEmptyString ;
22818 wxString *arg2 = (wxString *) &arg2_defvalue ;
22819 wxString const &arg3_defvalue = wxPyEmptyString ;
22820 wxString *arg3 = (wxString *) &arg3_defvalue ;
22821 wxString const &arg4_defvalue = wxPyEmptyString ;
22822 wxString *arg4 = (wxString *) &arg4_defvalue ;
22823 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22824 wxFileConfig *result = 0 ;
22825 bool temp1 = false ;
22826 bool temp2 = false ;
22827 bool temp3 = false ;
22828 bool temp4 = false ;
22829 long val5 ;
22830 int ecode5 = 0 ;
22831 PyObject * obj0 = 0 ;
22832 PyObject * obj1 = 0 ;
22833 PyObject * obj2 = 0 ;
22834 PyObject * obj3 = 0 ;
22835 PyObject * obj4 = 0 ;
22836 char * kwnames[] = {
22837 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22838 };
22839
22840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22841 if (obj0) {
22842 {
22843 arg1 = wxString_in_helper(obj0);
22844 if (arg1 == NULL) SWIG_fail;
22845 temp1 = true;
22846 }
22847 }
22848 if (obj1) {
22849 {
22850 arg2 = wxString_in_helper(obj1);
22851 if (arg2 == NULL) SWIG_fail;
22852 temp2 = true;
22853 }
22854 }
22855 if (obj2) {
22856 {
22857 arg3 = wxString_in_helper(obj2);
22858 if (arg3 == NULL) SWIG_fail;
22859 temp3 = true;
22860 }
22861 }
22862 if (obj3) {
22863 {
22864 arg4 = wxString_in_helper(obj3);
22865 if (arg4 == NULL) SWIG_fail;
22866 temp4 = true;
22867 }
22868 }
22869 if (obj4) {
22870 ecode5 = SWIG_AsVal_long(obj4, &val5);
22871 if (!SWIG_IsOK(ecode5)) {
22872 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22873 }
22874 arg5 = static_cast< long >(val5);
22875 }
22876 {
22877 PyThreadState* __tstate = wxPyBeginAllowThreads();
22878 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22879 wxPyEndAllowThreads(__tstate);
22880 if (PyErr_Occurred()) SWIG_fail;
22881 }
22882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22883 {
22884 if (temp1)
22885 delete arg1;
22886 }
22887 {
22888 if (temp2)
22889 delete arg2;
22890 }
22891 {
22892 if (temp3)
22893 delete arg3;
22894 }
22895 {
22896 if (temp4)
22897 delete arg4;
22898 }
22899 return resultobj;
22900 fail:
22901 {
22902 if (temp1)
22903 delete arg1;
22904 }
22905 {
22906 if (temp2)
22907 delete arg2;
22908 }
22909 {
22910 if (temp3)
22911 delete arg3;
22912 }
22913 {
22914 if (temp4)
22915 delete arg4;
22916 }
22917 return NULL;
22918 }
22919
22920
22921 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22922 PyObject *resultobj = 0;
22923 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22924 void *argp1 = 0 ;
22925 int res1 = 0 ;
22926 PyObject *swig_obj[1] ;
22927
22928 if (!args) SWIG_fail;
22929 swig_obj[0] = args;
22930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22931 if (!SWIG_IsOK(res1)) {
22932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22933 }
22934 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 delete arg1;
22938
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 resultobj = SWIG_Py_Void();
22943 return resultobj;
22944 fail:
22945 return NULL;
22946 }
22947
22948
22949 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22950 PyObject *obj;
22951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22952 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22953 return SWIG_Py_Void();
22954 }
22955
22956 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22957 return SWIG_Python_InitShadowInstance(args);
22958 }
22959
22960 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22961 PyObject *resultobj = 0;
22962 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22963 wxString *arg2 = 0 ;
22964 wxConfigPathChanger *result = 0 ;
22965 void *argp1 = 0 ;
22966 int res1 = 0 ;
22967 bool temp2 = false ;
22968 PyObject * obj0 = 0 ;
22969 PyObject * obj1 = 0 ;
22970 char * kwnames[] = {
22971 (char *) "config",(char *) "entry", NULL
22972 };
22973
22974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22976 if (!SWIG_IsOK(res1)) {
22977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22978 }
22979 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22980 {
22981 arg2 = wxString_in_helper(obj1);
22982 if (arg2 == NULL) SWIG_fail;
22983 temp2 = true;
22984 }
22985 {
22986 PyThreadState* __tstate = wxPyBeginAllowThreads();
22987 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22988 wxPyEndAllowThreads(__tstate);
22989 if (PyErr_Occurred()) SWIG_fail;
22990 }
22991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22992 {
22993 if (temp2)
22994 delete arg2;
22995 }
22996 return resultobj;
22997 fail:
22998 {
22999 if (temp2)
23000 delete arg2;
23001 }
23002 return NULL;
23003 }
23004
23005
23006 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23007 PyObject *resultobj = 0;
23008 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23009 void *argp1 = 0 ;
23010 int res1 = 0 ;
23011 PyObject *swig_obj[1] ;
23012
23013 if (!args) SWIG_fail;
23014 swig_obj[0] = args;
23015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23016 if (!SWIG_IsOK(res1)) {
23017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23018 }
23019 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23020 {
23021 PyThreadState* __tstate = wxPyBeginAllowThreads();
23022 delete arg1;
23023
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 resultobj = SWIG_Py_Void();
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23035 PyObject *resultobj = 0;
23036 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23037 wxString *result = 0 ;
23038 void *argp1 = 0 ;
23039 int res1 = 0 ;
23040 PyObject *swig_obj[1] ;
23041
23042 if (!args) SWIG_fail;
23043 swig_obj[0] = args;
23044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23045 if (!SWIG_IsOK(res1)) {
23046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23047 }
23048 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 {
23052 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23053 result = (wxString *) &_result_ref;
23054 }
23055 wxPyEndAllowThreads(__tstate);
23056 if (PyErr_Occurred()) SWIG_fail;
23057 }
23058 {
23059 #if wxUSE_UNICODE
23060 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23061 #else
23062 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23063 #endif
23064 }
23065 return resultobj;
23066 fail:
23067 return NULL;
23068 }
23069
23070
23071 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23072 PyObject *obj;
23073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23074 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23075 return SWIG_Py_Void();
23076 }
23077
23078 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23079 return SWIG_Python_InitShadowInstance(args);
23080 }
23081
23082 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj = 0;
23084 wxString *arg1 = 0 ;
23085 wxString result;
23086 bool temp1 = false ;
23087 PyObject * obj0 = 0 ;
23088 char * kwnames[] = {
23089 (char *) "sz", NULL
23090 };
23091
23092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23093 {
23094 arg1 = wxString_in_helper(obj0);
23095 if (arg1 == NULL) SWIG_fail;
23096 temp1 = true;
23097 }
23098 {
23099 PyThreadState* __tstate = wxPyBeginAllowThreads();
23100 result = wxExpandEnvVars((wxString const &)*arg1);
23101 wxPyEndAllowThreads(__tstate);
23102 if (PyErr_Occurred()) SWIG_fail;
23103 }
23104 {
23105 #if wxUSE_UNICODE
23106 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23107 #else
23108 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23109 #endif
23110 }
23111 {
23112 if (temp1)
23113 delete arg1;
23114 }
23115 return resultobj;
23116 fail:
23117 {
23118 if (temp1)
23119 delete arg1;
23120 }
23121 return NULL;
23122 }
23123
23124
23125 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23126 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23127 return 1;
23128 }
23129
23130
23131 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23132 PyObject *pyobj = 0;
23133
23134 {
23135 #if wxUSE_UNICODE
23136 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23137 #else
23138 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23139 #endif
23140 }
23141 return pyobj;
23142 }
23143
23144
23145 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23146 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23147 return 1;
23148 }
23149
23150
23151 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23152 PyObject *pyobj = 0;
23153
23154 {
23155 #if wxUSE_UNICODE
23156 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23157 #else
23158 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23159 #endif
23160 }
23161 return pyobj;
23162 }
23163
23164
23165 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23166 PyObject *resultobj = 0;
23167 wxDateTime::Country arg1 ;
23168 int val1 ;
23169 int ecode1 = 0 ;
23170 PyObject * obj0 = 0 ;
23171 char * kwnames[] = {
23172 (char *) "country", NULL
23173 };
23174
23175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23176 ecode1 = SWIG_AsVal_int(obj0, &val1);
23177 if (!SWIG_IsOK(ecode1)) {
23178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23179 }
23180 arg1 = static_cast< wxDateTime::Country >(val1);
23181 {
23182 PyThreadState* __tstate = wxPyBeginAllowThreads();
23183 wxDateTime::SetCountry(arg1);
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 resultobj = SWIG_Py_Void();
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23195 PyObject *resultobj = 0;
23196 wxDateTime::Country result;
23197
23198 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23199 {
23200 PyThreadState* __tstate = wxPyBeginAllowThreads();
23201 result = (wxDateTime::Country)wxDateTime::GetCountry();
23202 wxPyEndAllowThreads(__tstate);
23203 if (PyErr_Occurred()) SWIG_fail;
23204 }
23205 resultobj = SWIG_From_int(static_cast< int >(result));
23206 return resultobj;
23207 fail:
23208 return NULL;
23209 }
23210
23211
23212 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23213 PyObject *resultobj = 0;
23214 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23215 bool result;
23216 int val1 ;
23217 int ecode1 = 0 ;
23218 PyObject * obj0 = 0 ;
23219 char * kwnames[] = {
23220 (char *) "country", NULL
23221 };
23222
23223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23224 if (obj0) {
23225 ecode1 = SWIG_AsVal_int(obj0, &val1);
23226 if (!SWIG_IsOK(ecode1)) {
23227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23228 }
23229 arg1 = static_cast< wxDateTime::Country >(val1);
23230 }
23231 {
23232 PyThreadState* __tstate = wxPyBeginAllowThreads();
23233 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 {
23238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23239 }
23240 return resultobj;
23241 fail:
23242 return NULL;
23243 }
23244
23245
23246 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23247 PyObject *resultobj = 0;
23248 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23249 int result;
23250 int val1 ;
23251 int ecode1 = 0 ;
23252 PyObject * obj0 = 0 ;
23253 char * kwnames[] = {
23254 (char *) "cal", NULL
23255 };
23256
23257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23258 if (obj0) {
23259 ecode1 = SWIG_AsVal_int(obj0, &val1);
23260 if (!SWIG_IsOK(ecode1)) {
23261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23262 }
23263 arg1 = static_cast< wxDateTime::Calendar >(val1);
23264 }
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 result = (int)wxDateTime::GetCurrentYear(arg1);
23268 wxPyEndAllowThreads(__tstate);
23269 if (PyErr_Occurred()) SWIG_fail;
23270 }
23271 resultobj = SWIG_From_int(static_cast< int >(result));
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23279 PyObject *resultobj = 0;
23280 int arg1 ;
23281 int result;
23282 int val1 ;
23283 int ecode1 = 0 ;
23284 PyObject * obj0 = 0 ;
23285 char * kwnames[] = {
23286 (char *) "year", NULL
23287 };
23288
23289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23290 ecode1 = SWIG_AsVal_int(obj0, &val1);
23291 if (!SWIG_IsOK(ecode1)) {
23292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23293 }
23294 arg1 = static_cast< int >(val1);
23295 {
23296 PyThreadState* __tstate = wxPyBeginAllowThreads();
23297 result = (int)wxDateTime::ConvertYearToBC(arg1);
23298 wxPyEndAllowThreads(__tstate);
23299 if (PyErr_Occurred()) SWIG_fail;
23300 }
23301 resultobj = SWIG_From_int(static_cast< int >(result));
23302 return resultobj;
23303 fail:
23304 return NULL;
23305 }
23306
23307
23308 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23309 PyObject *resultobj = 0;
23310 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23311 wxDateTime::Month result;
23312 int val1 ;
23313 int ecode1 = 0 ;
23314 PyObject * obj0 = 0 ;
23315 char * kwnames[] = {
23316 (char *) "cal", NULL
23317 };
23318
23319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23320 if (obj0) {
23321 ecode1 = SWIG_AsVal_int(obj0, &val1);
23322 if (!SWIG_IsOK(ecode1)) {
23323 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23324 }
23325 arg1 = static_cast< wxDateTime::Calendar >(val1);
23326 }
23327 {
23328 PyThreadState* __tstate = wxPyBeginAllowThreads();
23329 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23330 wxPyEndAllowThreads(__tstate);
23331 if (PyErr_Occurred()) SWIG_fail;
23332 }
23333 resultobj = SWIG_From_int(static_cast< int >(result));
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23341 PyObject *resultobj = 0;
23342 int arg1 = (int) wxDateTime::Inv_Year ;
23343 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23344 bool result;
23345 int val1 ;
23346 int ecode1 = 0 ;
23347 int val2 ;
23348 int ecode2 = 0 ;
23349 PyObject * obj0 = 0 ;
23350 PyObject * obj1 = 0 ;
23351 char * kwnames[] = {
23352 (char *) "year",(char *) "cal", NULL
23353 };
23354
23355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23356 if (obj0) {
23357 ecode1 = SWIG_AsVal_int(obj0, &val1);
23358 if (!SWIG_IsOK(ecode1)) {
23359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23360 }
23361 arg1 = static_cast< int >(val1);
23362 }
23363 if (obj1) {
23364 ecode2 = SWIG_AsVal_int(obj1, &val2);
23365 if (!SWIG_IsOK(ecode2)) {
23366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23367 }
23368 arg2 = static_cast< wxDateTime::Calendar >(val2);
23369 }
23370 {
23371 PyThreadState* __tstate = wxPyBeginAllowThreads();
23372 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23373 wxPyEndAllowThreads(__tstate);
23374 if (PyErr_Occurred()) SWIG_fail;
23375 }
23376 {
23377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23378 }
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23386 PyObject *resultobj = 0;
23387 int arg1 = (int) wxDateTime::Inv_Year ;
23388 int result;
23389 int val1 ;
23390 int ecode1 = 0 ;
23391 PyObject * obj0 = 0 ;
23392 char * kwnames[] = {
23393 (char *) "year", NULL
23394 };
23395
23396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23397 if (obj0) {
23398 ecode1 = SWIG_AsVal_int(obj0, &val1);
23399 if (!SWIG_IsOK(ecode1)) {
23400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23401 }
23402 arg1 = static_cast< int >(val1);
23403 }
23404 {
23405 PyThreadState* __tstate = wxPyBeginAllowThreads();
23406 result = (int)wxDateTime::GetCentury(arg1);
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 resultobj = SWIG_From_int(static_cast< int >(result));
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj = 0;
23419 int arg1 ;
23420 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23421 int result;
23422 int val1 ;
23423 int ecode1 = 0 ;
23424 int val2 ;
23425 int ecode2 = 0 ;
23426 PyObject * obj0 = 0 ;
23427 PyObject * obj1 = 0 ;
23428 char * kwnames[] = {
23429 (char *) "year",(char *) "cal", NULL
23430 };
23431
23432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23433 ecode1 = SWIG_AsVal_int(obj0, &val1);
23434 if (!SWIG_IsOK(ecode1)) {
23435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23436 }
23437 arg1 = static_cast< int >(val1);
23438 if (obj1) {
23439 ecode2 = SWIG_AsVal_int(obj1, &val2);
23440 if (!SWIG_IsOK(ecode2)) {
23441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23442 }
23443 arg2 = static_cast< wxDateTime::Calendar >(val2);
23444 }
23445 {
23446 PyThreadState* __tstate = wxPyBeginAllowThreads();
23447 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23448 wxPyEndAllowThreads(__tstate);
23449 if (PyErr_Occurred()) SWIG_fail;
23450 }
23451 resultobj = SWIG_From_int(static_cast< int >(result));
23452 return resultobj;
23453 fail:
23454 return NULL;
23455 }
23456
23457
23458 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23459 PyObject *resultobj = 0;
23460 wxDateTime::Month arg1 ;
23461 int arg2 = (int) wxDateTime::Inv_Year ;
23462 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23463 int result;
23464 int val1 ;
23465 int ecode1 = 0 ;
23466 int val2 ;
23467 int ecode2 = 0 ;
23468 int val3 ;
23469 int ecode3 = 0 ;
23470 PyObject * obj0 = 0 ;
23471 PyObject * obj1 = 0 ;
23472 PyObject * obj2 = 0 ;
23473 char * kwnames[] = {
23474 (char *) "month",(char *) "year",(char *) "cal", NULL
23475 };
23476
23477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23478 ecode1 = SWIG_AsVal_int(obj0, &val1);
23479 if (!SWIG_IsOK(ecode1)) {
23480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23481 }
23482 arg1 = static_cast< wxDateTime::Month >(val1);
23483 if (obj1) {
23484 ecode2 = SWIG_AsVal_int(obj1, &val2);
23485 if (!SWIG_IsOK(ecode2)) {
23486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23487 }
23488 arg2 = static_cast< int >(val2);
23489 }
23490 if (obj2) {
23491 ecode3 = SWIG_AsVal_int(obj2, &val3);
23492 if (!SWIG_IsOK(ecode3)) {
23493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23494 }
23495 arg3 = static_cast< wxDateTime::Calendar >(val3);
23496 }
23497 {
23498 PyThreadState* __tstate = wxPyBeginAllowThreads();
23499 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23500 wxPyEndAllowThreads(__tstate);
23501 if (PyErr_Occurred()) SWIG_fail;
23502 }
23503 resultobj = SWIG_From_int(static_cast< int >(result));
23504 return resultobj;
23505 fail:
23506 return NULL;
23507 }
23508
23509
23510 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23511 PyObject *resultobj = 0;
23512 wxDateTime::Month arg1 ;
23513 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23514 wxString result;
23515 int val1 ;
23516 int ecode1 = 0 ;
23517 int val2 ;
23518 int ecode2 = 0 ;
23519 PyObject * obj0 = 0 ;
23520 PyObject * obj1 = 0 ;
23521 char * kwnames[] = {
23522 (char *) "month",(char *) "flags", NULL
23523 };
23524
23525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23526 ecode1 = SWIG_AsVal_int(obj0, &val1);
23527 if (!SWIG_IsOK(ecode1)) {
23528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23529 }
23530 arg1 = static_cast< wxDateTime::Month >(val1);
23531 if (obj1) {
23532 ecode2 = SWIG_AsVal_int(obj1, &val2);
23533 if (!SWIG_IsOK(ecode2)) {
23534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23535 }
23536 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23537 }
23538 {
23539 PyThreadState* __tstate = wxPyBeginAllowThreads();
23540 result = wxDateTime::GetMonthName(arg1,arg2);
23541 wxPyEndAllowThreads(__tstate);
23542 if (PyErr_Occurred()) SWIG_fail;
23543 }
23544 {
23545 #if wxUSE_UNICODE
23546 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23547 #else
23548 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23549 #endif
23550 }
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23558 PyObject *resultobj = 0;
23559 wxDateTime::WeekDay arg1 ;
23560 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23561 wxString result;
23562 int val1 ;
23563 int ecode1 = 0 ;
23564 int val2 ;
23565 int ecode2 = 0 ;
23566 PyObject * obj0 = 0 ;
23567 PyObject * obj1 = 0 ;
23568 char * kwnames[] = {
23569 (char *) "weekday",(char *) "flags", NULL
23570 };
23571
23572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23573 ecode1 = SWIG_AsVal_int(obj0, &val1);
23574 if (!SWIG_IsOK(ecode1)) {
23575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23576 }
23577 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23578 if (obj1) {
23579 ecode2 = SWIG_AsVal_int(obj1, &val2);
23580 if (!SWIG_IsOK(ecode2)) {
23581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23582 }
23583 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23584 }
23585 {
23586 PyThreadState* __tstate = wxPyBeginAllowThreads();
23587 result = wxDateTime::GetWeekDayName(arg1,arg2);
23588 wxPyEndAllowThreads(__tstate);
23589 if (PyErr_Occurred()) SWIG_fail;
23590 }
23591 {
23592 #if wxUSE_UNICODE
23593 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23594 #else
23595 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23596 #endif
23597 }
23598 return resultobj;
23599 fail:
23600 return NULL;
23601 }
23602
23603
23604 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23605 PyObject *resultobj = 0;
23606 PyObject *result = 0 ;
23607
23608 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23609 {
23610 PyThreadState* __tstate = wxPyBeginAllowThreads();
23611 result = (PyObject *)wxDateTime_GetAmPmStrings();
23612 wxPyEndAllowThreads(__tstate);
23613 if (PyErr_Occurred()) SWIG_fail;
23614 }
23615 resultobj = result;
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23623 PyObject *resultobj = 0;
23624 int arg1 = (int) wxDateTime::Inv_Year ;
23625 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23626 bool result;
23627 int val1 ;
23628 int ecode1 = 0 ;
23629 int val2 ;
23630 int ecode2 = 0 ;
23631 PyObject * obj0 = 0 ;
23632 PyObject * obj1 = 0 ;
23633 char * kwnames[] = {
23634 (char *) "year",(char *) "country", NULL
23635 };
23636
23637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23638 if (obj0) {
23639 ecode1 = SWIG_AsVal_int(obj0, &val1);
23640 if (!SWIG_IsOK(ecode1)) {
23641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23642 }
23643 arg1 = static_cast< int >(val1);
23644 }
23645 if (obj1) {
23646 ecode2 = SWIG_AsVal_int(obj1, &val2);
23647 if (!SWIG_IsOK(ecode2)) {
23648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23649 }
23650 arg2 = static_cast< wxDateTime::Country >(val2);
23651 }
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 {
23659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj = 0;
23669 int arg1 = (int) wxDateTime::Inv_Year ;
23670 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23671 wxDateTime result;
23672 int val1 ;
23673 int ecode1 = 0 ;
23674 int val2 ;
23675 int ecode2 = 0 ;
23676 PyObject * obj0 = 0 ;
23677 PyObject * obj1 = 0 ;
23678 char * kwnames[] = {
23679 (char *) "year",(char *) "country", NULL
23680 };
23681
23682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23683 if (obj0) {
23684 ecode1 = SWIG_AsVal_int(obj0, &val1);
23685 if (!SWIG_IsOK(ecode1)) {
23686 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23687 }
23688 arg1 = static_cast< int >(val1);
23689 }
23690 if (obj1) {
23691 ecode2 = SWIG_AsVal_int(obj1, &val2);
23692 if (!SWIG_IsOK(ecode2)) {
23693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23694 }
23695 arg2 = static_cast< wxDateTime::Country >(val2);
23696 }
23697 {
23698 PyThreadState* __tstate = wxPyBeginAllowThreads();
23699 result = wxDateTime::GetBeginDST(arg1,arg2);
23700 wxPyEndAllowThreads(__tstate);
23701 if (PyErr_Occurred()) SWIG_fail;
23702 }
23703 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23704 return resultobj;
23705 fail:
23706 return NULL;
23707 }
23708
23709
23710 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23711 PyObject *resultobj = 0;
23712 int arg1 = (int) wxDateTime::Inv_Year ;
23713 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23714 wxDateTime result;
23715 int val1 ;
23716 int ecode1 = 0 ;
23717 int val2 ;
23718 int ecode2 = 0 ;
23719 PyObject * obj0 = 0 ;
23720 PyObject * obj1 = 0 ;
23721 char * kwnames[] = {
23722 (char *) "year",(char *) "country", NULL
23723 };
23724
23725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23726 if (obj0) {
23727 ecode1 = SWIG_AsVal_int(obj0, &val1);
23728 if (!SWIG_IsOK(ecode1)) {
23729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23730 }
23731 arg1 = static_cast< int >(val1);
23732 }
23733 if (obj1) {
23734 ecode2 = SWIG_AsVal_int(obj1, &val2);
23735 if (!SWIG_IsOK(ecode2)) {
23736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23737 }
23738 arg2 = static_cast< wxDateTime::Country >(val2);
23739 }
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 result = wxDateTime::GetEndDST(arg1,arg2);
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23754 PyObject *resultobj = 0;
23755 wxDateTime result;
23756
23757 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23758 {
23759 PyThreadState* __tstate = wxPyBeginAllowThreads();
23760 result = wxDateTime::Now();
23761 wxPyEndAllowThreads(__tstate);
23762 if (PyErr_Occurred()) SWIG_fail;
23763 }
23764 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23765 return resultobj;
23766 fail:
23767 return NULL;
23768 }
23769
23770
23771 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23772 PyObject *resultobj = 0;
23773 wxDateTime result;
23774
23775 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23776 {
23777 PyThreadState* __tstate = wxPyBeginAllowThreads();
23778 result = wxDateTime::UNow();
23779 wxPyEndAllowThreads(__tstate);
23780 if (PyErr_Occurred()) SWIG_fail;
23781 }
23782 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23783 return resultobj;
23784 fail:
23785 return NULL;
23786 }
23787
23788
23789 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23790 PyObject *resultobj = 0;
23791 wxDateTime result;
23792
23793 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 result = wxDateTime::Today();
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23801 return resultobj;
23802 fail:
23803 return NULL;
23804 }
23805
23806
23807 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23808 PyObject *resultobj = 0;
23809 wxDateTime *result = 0 ;
23810
23811 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23812 {
23813 PyThreadState* __tstate = wxPyBeginAllowThreads();
23814 result = (wxDateTime *)new wxDateTime();
23815 wxPyEndAllowThreads(__tstate);
23816 if (PyErr_Occurred()) SWIG_fail;
23817 }
23818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23826 PyObject *resultobj = 0;
23827 time_t arg1 ;
23828 wxDateTime *result = 0 ;
23829 unsigned int val1 ;
23830 int ecode1 = 0 ;
23831 PyObject * obj0 = 0 ;
23832 char * kwnames[] = {
23833 (char *) "timet", NULL
23834 };
23835
23836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23837 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23838 if (!SWIG_IsOK(ecode1)) {
23839 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23840 }
23841 arg1 = static_cast< time_t >(val1);
23842 {
23843 PyThreadState* __tstate = wxPyBeginAllowThreads();
23844 result = (wxDateTime *)new wxDateTime(arg1);
23845 wxPyEndAllowThreads(__tstate);
23846 if (PyErr_Occurred()) SWIG_fail;
23847 }
23848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23856 PyObject *resultobj = 0;
23857 double arg1 ;
23858 wxDateTime *result = 0 ;
23859 double val1 ;
23860 int ecode1 = 0 ;
23861 PyObject * obj0 = 0 ;
23862 char * kwnames[] = {
23863 (char *) "jdn", NULL
23864 };
23865
23866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23867 ecode1 = SWIG_AsVal_double(obj0, &val1);
23868 if (!SWIG_IsOK(ecode1)) {
23869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23870 }
23871 arg1 = static_cast< double >(val1);
23872 {
23873 PyThreadState* __tstate = wxPyBeginAllowThreads();
23874 result = (wxDateTime *)new wxDateTime(arg1);
23875 wxPyEndAllowThreads(__tstate);
23876 if (PyErr_Occurred()) SWIG_fail;
23877 }
23878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23879 return resultobj;
23880 fail:
23881 return NULL;
23882 }
23883
23884
23885 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23886 PyObject *resultobj = 0;
23887 int arg1 ;
23888 int arg2 = (int) 0 ;
23889 int arg3 = (int) 0 ;
23890 int arg4 = (int) 0 ;
23891 wxDateTime *result = 0 ;
23892 int val1 ;
23893 int ecode1 = 0 ;
23894 int val2 ;
23895 int ecode2 = 0 ;
23896 int val3 ;
23897 int ecode3 = 0 ;
23898 int val4 ;
23899 int ecode4 = 0 ;
23900 PyObject * obj0 = 0 ;
23901 PyObject * obj1 = 0 ;
23902 PyObject * obj2 = 0 ;
23903 PyObject * obj3 = 0 ;
23904 char * kwnames[] = {
23905 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23906 };
23907
23908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23909 ecode1 = SWIG_AsVal_int(obj0, &val1);
23910 if (!SWIG_IsOK(ecode1)) {
23911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23912 }
23913 arg1 = static_cast< int >(val1);
23914 if (obj1) {
23915 ecode2 = SWIG_AsVal_int(obj1, &val2);
23916 if (!SWIG_IsOK(ecode2)) {
23917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23918 }
23919 arg2 = static_cast< int >(val2);
23920 }
23921 if (obj2) {
23922 ecode3 = SWIG_AsVal_int(obj2, &val3);
23923 if (!SWIG_IsOK(ecode3)) {
23924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23925 }
23926 arg3 = static_cast< int >(val3);
23927 }
23928 if (obj3) {
23929 ecode4 = SWIG_AsVal_int(obj3, &val4);
23930 if (!SWIG_IsOK(ecode4)) {
23931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23932 }
23933 arg4 = static_cast< int >(val4);
23934 }
23935 {
23936 PyThreadState* __tstate = wxPyBeginAllowThreads();
23937 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23938 wxPyEndAllowThreads(__tstate);
23939 if (PyErr_Occurred()) SWIG_fail;
23940 }
23941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23942 return resultobj;
23943 fail:
23944 return NULL;
23945 }
23946
23947
23948 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23949 PyObject *resultobj = 0;
23950 int arg1 ;
23951 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23952 int arg3 = (int) wxDateTime::Inv_Year ;
23953 int arg4 = (int) 0 ;
23954 int arg5 = (int) 0 ;
23955 int arg6 = (int) 0 ;
23956 int arg7 = (int) 0 ;
23957 wxDateTime *result = 0 ;
23958 int val1 ;
23959 int ecode1 = 0 ;
23960 int val2 ;
23961 int ecode2 = 0 ;
23962 int val3 ;
23963 int ecode3 = 0 ;
23964 int val4 ;
23965 int ecode4 = 0 ;
23966 int val5 ;
23967 int ecode5 = 0 ;
23968 int val6 ;
23969 int ecode6 = 0 ;
23970 int val7 ;
23971 int ecode7 = 0 ;
23972 PyObject * obj0 = 0 ;
23973 PyObject * obj1 = 0 ;
23974 PyObject * obj2 = 0 ;
23975 PyObject * obj3 = 0 ;
23976 PyObject * obj4 = 0 ;
23977 PyObject * obj5 = 0 ;
23978 PyObject * obj6 = 0 ;
23979 char * kwnames[] = {
23980 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23981 };
23982
23983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23984 ecode1 = SWIG_AsVal_int(obj0, &val1);
23985 if (!SWIG_IsOK(ecode1)) {
23986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23987 }
23988 arg1 = static_cast< int >(val1);
23989 if (obj1) {
23990 ecode2 = SWIG_AsVal_int(obj1, &val2);
23991 if (!SWIG_IsOK(ecode2)) {
23992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23993 }
23994 arg2 = static_cast< wxDateTime::Month >(val2);
23995 }
23996 if (obj2) {
23997 ecode3 = SWIG_AsVal_int(obj2, &val3);
23998 if (!SWIG_IsOK(ecode3)) {
23999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24000 }
24001 arg3 = static_cast< int >(val3);
24002 }
24003 if (obj3) {
24004 ecode4 = SWIG_AsVal_int(obj3, &val4);
24005 if (!SWIG_IsOK(ecode4)) {
24006 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24007 }
24008 arg4 = static_cast< int >(val4);
24009 }
24010 if (obj4) {
24011 ecode5 = SWIG_AsVal_int(obj4, &val5);
24012 if (!SWIG_IsOK(ecode5)) {
24013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24014 }
24015 arg5 = static_cast< int >(val5);
24016 }
24017 if (obj5) {
24018 ecode6 = SWIG_AsVal_int(obj5, &val6);
24019 if (!SWIG_IsOK(ecode6)) {
24020 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24021 }
24022 arg6 = static_cast< int >(val6);
24023 }
24024 if (obj6) {
24025 ecode7 = SWIG_AsVal_int(obj6, &val7);
24026 if (!SWIG_IsOK(ecode7)) {
24027 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24028 }
24029 arg7 = static_cast< int >(val7);
24030 }
24031 {
24032 PyThreadState* __tstate = wxPyBeginAllowThreads();
24033 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24034 wxPyEndAllowThreads(__tstate);
24035 if (PyErr_Occurred()) SWIG_fail;
24036 }
24037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24045 PyObject *resultobj = 0;
24046 wxDateTime *arg1 = 0 ;
24047 wxDateTime *result = 0 ;
24048 void *argp1 = 0 ;
24049 int res1 = 0 ;
24050 PyObject * obj0 = 0 ;
24051 char * kwnames[] = {
24052 (char *) "date", NULL
24053 };
24054
24055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24056 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24057 if (!SWIG_IsOK(res1)) {
24058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24059 }
24060 if (!argp1) {
24061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24062 }
24063 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24071 return resultobj;
24072 fail:
24073 return NULL;
24074 }
24075
24076
24077 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24078 PyObject *resultobj = 0;
24079 wxDateTime *arg1 = (wxDateTime *) 0 ;
24080 void *argp1 = 0 ;
24081 int res1 = 0 ;
24082 PyObject *swig_obj[1] ;
24083
24084 if (!args) SWIG_fail;
24085 swig_obj[0] = args;
24086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24087 if (!SWIG_IsOK(res1)) {
24088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24089 }
24090 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24091 {
24092 PyThreadState* __tstate = wxPyBeginAllowThreads();
24093 delete arg1;
24094
24095 wxPyEndAllowThreads(__tstate);
24096 if (PyErr_Occurred()) SWIG_fail;
24097 }
24098 resultobj = SWIG_Py_Void();
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24106 PyObject *resultobj = 0;
24107 wxDateTime *arg1 = (wxDateTime *) 0 ;
24108 wxDateTime *result = 0 ;
24109 void *argp1 = 0 ;
24110 int res1 = 0 ;
24111 PyObject *swig_obj[1] ;
24112
24113 if (!args) SWIG_fail;
24114 swig_obj[0] = args;
24115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24116 if (!SWIG_IsOK(res1)) {
24117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24118 }
24119 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24120 {
24121 PyThreadState* __tstate = wxPyBeginAllowThreads();
24122 {
24123 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24124 result = (wxDateTime *) &_result_ref;
24125 }
24126 wxPyEndAllowThreads(__tstate);
24127 if (PyErr_Occurred()) SWIG_fail;
24128 }
24129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24130 return resultobj;
24131 fail:
24132 return NULL;
24133 }
24134
24135
24136 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24137 PyObject *resultobj = 0;
24138 wxDateTime *arg1 = (wxDateTime *) 0 ;
24139 time_t arg2 ;
24140 wxDateTime *result = 0 ;
24141 void *argp1 = 0 ;
24142 int res1 = 0 ;
24143 unsigned int val2 ;
24144 int ecode2 = 0 ;
24145 PyObject * obj0 = 0 ;
24146 PyObject * obj1 = 0 ;
24147 char * kwnames[] = {
24148 (char *) "self",(char *) "timet", NULL
24149 };
24150
24151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24153 if (!SWIG_IsOK(res1)) {
24154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24155 }
24156 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24157 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24158 if (!SWIG_IsOK(ecode2)) {
24159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24160 }
24161 arg2 = static_cast< time_t >(val2);
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 {
24165 wxDateTime &_result_ref = (arg1)->Set(arg2);
24166 result = (wxDateTime *) &_result_ref;
24167 }
24168 wxPyEndAllowThreads(__tstate);
24169 if (PyErr_Occurred()) SWIG_fail;
24170 }
24171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24172 return resultobj;
24173 fail:
24174 return NULL;
24175 }
24176
24177
24178 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24179 PyObject *resultobj = 0;
24180 wxDateTime *arg1 = (wxDateTime *) 0 ;
24181 double arg2 ;
24182 wxDateTime *result = 0 ;
24183 void *argp1 = 0 ;
24184 int res1 = 0 ;
24185 double val2 ;
24186 int ecode2 = 0 ;
24187 PyObject * obj0 = 0 ;
24188 PyObject * obj1 = 0 ;
24189 char * kwnames[] = {
24190 (char *) "self",(char *) "jdn", NULL
24191 };
24192
24193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24197 }
24198 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24199 ecode2 = SWIG_AsVal_double(obj1, &val2);
24200 if (!SWIG_IsOK(ecode2)) {
24201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24202 }
24203 arg2 = static_cast< double >(val2);
24204 {
24205 PyThreadState* __tstate = wxPyBeginAllowThreads();
24206 {
24207 wxDateTime &_result_ref = (arg1)->Set(arg2);
24208 result = (wxDateTime *) &_result_ref;
24209 }
24210 wxPyEndAllowThreads(__tstate);
24211 if (PyErr_Occurred()) SWIG_fail;
24212 }
24213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24214 return resultobj;
24215 fail:
24216 return NULL;
24217 }
24218
24219
24220 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24221 PyObject *resultobj = 0;
24222 wxDateTime *arg1 = (wxDateTime *) 0 ;
24223 int arg2 ;
24224 int arg3 = (int) 0 ;
24225 int arg4 = (int) 0 ;
24226 int arg5 = (int) 0 ;
24227 wxDateTime *result = 0 ;
24228 void *argp1 = 0 ;
24229 int res1 = 0 ;
24230 int val2 ;
24231 int ecode2 = 0 ;
24232 int val3 ;
24233 int ecode3 = 0 ;
24234 int val4 ;
24235 int ecode4 = 0 ;
24236 int val5 ;
24237 int ecode5 = 0 ;
24238 PyObject * obj0 = 0 ;
24239 PyObject * obj1 = 0 ;
24240 PyObject * obj2 = 0 ;
24241 PyObject * obj3 = 0 ;
24242 PyObject * obj4 = 0 ;
24243 char * kwnames[] = {
24244 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24245 };
24246
24247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24249 if (!SWIG_IsOK(res1)) {
24250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24251 }
24252 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24253 ecode2 = SWIG_AsVal_int(obj1, &val2);
24254 if (!SWIG_IsOK(ecode2)) {
24255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24256 }
24257 arg2 = static_cast< int >(val2);
24258 if (obj2) {
24259 ecode3 = SWIG_AsVal_int(obj2, &val3);
24260 if (!SWIG_IsOK(ecode3)) {
24261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24262 }
24263 arg3 = static_cast< int >(val3);
24264 }
24265 if (obj3) {
24266 ecode4 = SWIG_AsVal_int(obj3, &val4);
24267 if (!SWIG_IsOK(ecode4)) {
24268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24269 }
24270 arg4 = static_cast< int >(val4);
24271 }
24272 if (obj4) {
24273 ecode5 = SWIG_AsVal_int(obj4, &val5);
24274 if (!SWIG_IsOK(ecode5)) {
24275 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24276 }
24277 arg5 = static_cast< int >(val5);
24278 }
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 {
24282 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24283 result = (wxDateTime *) &_result_ref;
24284 }
24285 wxPyEndAllowThreads(__tstate);
24286 if (PyErr_Occurred()) SWIG_fail;
24287 }
24288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj = 0;
24297 wxDateTime *arg1 = (wxDateTime *) 0 ;
24298 int arg2 ;
24299 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24300 int arg4 = (int) wxDateTime::Inv_Year ;
24301 int arg5 = (int) 0 ;
24302 int arg6 = (int) 0 ;
24303 int arg7 = (int) 0 ;
24304 int arg8 = (int) 0 ;
24305 wxDateTime *result = 0 ;
24306 void *argp1 = 0 ;
24307 int res1 = 0 ;
24308 int val2 ;
24309 int ecode2 = 0 ;
24310 int val3 ;
24311 int ecode3 = 0 ;
24312 int val4 ;
24313 int ecode4 = 0 ;
24314 int val5 ;
24315 int ecode5 = 0 ;
24316 int val6 ;
24317 int ecode6 = 0 ;
24318 int val7 ;
24319 int ecode7 = 0 ;
24320 int val8 ;
24321 int ecode8 = 0 ;
24322 PyObject * obj0 = 0 ;
24323 PyObject * obj1 = 0 ;
24324 PyObject * obj2 = 0 ;
24325 PyObject * obj3 = 0 ;
24326 PyObject * obj4 = 0 ;
24327 PyObject * obj5 = 0 ;
24328 PyObject * obj6 = 0 ;
24329 PyObject * obj7 = 0 ;
24330 char * kwnames[] = {
24331 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24332 };
24333
24334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24336 if (!SWIG_IsOK(res1)) {
24337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24338 }
24339 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24340 ecode2 = SWIG_AsVal_int(obj1, &val2);
24341 if (!SWIG_IsOK(ecode2)) {
24342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24343 }
24344 arg2 = static_cast< int >(val2);
24345 if (obj2) {
24346 ecode3 = SWIG_AsVal_int(obj2, &val3);
24347 if (!SWIG_IsOK(ecode3)) {
24348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24349 }
24350 arg3 = static_cast< wxDateTime::Month >(val3);
24351 }
24352 if (obj3) {
24353 ecode4 = SWIG_AsVal_int(obj3, &val4);
24354 if (!SWIG_IsOK(ecode4)) {
24355 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24356 }
24357 arg4 = static_cast< int >(val4);
24358 }
24359 if (obj4) {
24360 ecode5 = SWIG_AsVal_int(obj4, &val5);
24361 if (!SWIG_IsOK(ecode5)) {
24362 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24363 }
24364 arg5 = static_cast< int >(val5);
24365 }
24366 if (obj5) {
24367 ecode6 = SWIG_AsVal_int(obj5, &val6);
24368 if (!SWIG_IsOK(ecode6)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24370 }
24371 arg6 = static_cast< int >(val6);
24372 }
24373 if (obj6) {
24374 ecode7 = SWIG_AsVal_int(obj6, &val7);
24375 if (!SWIG_IsOK(ecode7)) {
24376 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24377 }
24378 arg7 = static_cast< int >(val7);
24379 }
24380 if (obj7) {
24381 ecode8 = SWIG_AsVal_int(obj7, &val8);
24382 if (!SWIG_IsOK(ecode8)) {
24383 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24384 }
24385 arg8 = static_cast< int >(val8);
24386 }
24387 {
24388 PyThreadState* __tstate = wxPyBeginAllowThreads();
24389 {
24390 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24391 result = (wxDateTime *) &_result_ref;
24392 }
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24404 PyObject *resultobj = 0;
24405 wxDateTime *arg1 = (wxDateTime *) 0 ;
24406 wxDateTime *result = 0 ;
24407 void *argp1 = 0 ;
24408 int res1 = 0 ;
24409 PyObject *swig_obj[1] ;
24410
24411 if (!args) SWIG_fail;
24412 swig_obj[0] = args;
24413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24414 if (!SWIG_IsOK(res1)) {
24415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24416 }
24417 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 {
24421 wxDateTime &_result_ref = (arg1)->ResetTime();
24422 result = (wxDateTime *) &_result_ref;
24423 }
24424 wxPyEndAllowThreads(__tstate);
24425 if (PyErr_Occurred()) SWIG_fail;
24426 }
24427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj = 0;
24436 wxDateTime *arg1 = (wxDateTime *) 0 ;
24437 int arg2 ;
24438 wxDateTime *result = 0 ;
24439 void *argp1 = 0 ;
24440 int res1 = 0 ;
24441 int val2 ;
24442 int ecode2 = 0 ;
24443 PyObject * obj0 = 0 ;
24444 PyObject * obj1 = 0 ;
24445 char * kwnames[] = {
24446 (char *) "self",(char *) "year", NULL
24447 };
24448
24449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24453 }
24454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24455 ecode2 = SWIG_AsVal_int(obj1, &val2);
24456 if (!SWIG_IsOK(ecode2)) {
24457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24458 }
24459 arg2 = static_cast< int >(val2);
24460 {
24461 PyThreadState* __tstate = wxPyBeginAllowThreads();
24462 {
24463 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24464 result = (wxDateTime *) &_result_ref;
24465 }
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj = 0;
24478 wxDateTime *arg1 = (wxDateTime *) 0 ;
24479 wxDateTime::Month arg2 ;
24480 wxDateTime *result = 0 ;
24481 void *argp1 = 0 ;
24482 int res1 = 0 ;
24483 int val2 ;
24484 int ecode2 = 0 ;
24485 PyObject * obj0 = 0 ;
24486 PyObject * obj1 = 0 ;
24487 char * kwnames[] = {
24488 (char *) "self",(char *) "month", NULL
24489 };
24490
24491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24493 if (!SWIG_IsOK(res1)) {
24494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24495 }
24496 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24497 ecode2 = SWIG_AsVal_int(obj1, &val2);
24498 if (!SWIG_IsOK(ecode2)) {
24499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24500 }
24501 arg2 = static_cast< wxDateTime::Month >(val2);
24502 {
24503 PyThreadState* __tstate = wxPyBeginAllowThreads();
24504 {
24505 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24506 result = (wxDateTime *) &_result_ref;
24507 }
24508 wxPyEndAllowThreads(__tstate);
24509 if (PyErr_Occurred()) SWIG_fail;
24510 }
24511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24512 return resultobj;
24513 fail:
24514 return NULL;
24515 }
24516
24517
24518 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24519 PyObject *resultobj = 0;
24520 wxDateTime *arg1 = (wxDateTime *) 0 ;
24521 int arg2 ;
24522 wxDateTime *result = 0 ;
24523 void *argp1 = 0 ;
24524 int res1 = 0 ;
24525 int val2 ;
24526 int ecode2 = 0 ;
24527 PyObject * obj0 = 0 ;
24528 PyObject * obj1 = 0 ;
24529 char * kwnames[] = {
24530 (char *) "self",(char *) "day", NULL
24531 };
24532
24533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24537 }
24538 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24539 ecode2 = SWIG_AsVal_int(obj1, &val2);
24540 if (!SWIG_IsOK(ecode2)) {
24541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24542 }
24543 arg2 = static_cast< int >(val2);
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 {
24547 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24548 result = (wxDateTime *) &_result_ref;
24549 }
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24561 PyObject *resultobj = 0;
24562 wxDateTime *arg1 = (wxDateTime *) 0 ;
24563 int arg2 ;
24564 wxDateTime *result = 0 ;
24565 void *argp1 = 0 ;
24566 int res1 = 0 ;
24567 int val2 ;
24568 int ecode2 = 0 ;
24569 PyObject * obj0 = 0 ;
24570 PyObject * obj1 = 0 ;
24571 char * kwnames[] = {
24572 (char *) "self",(char *) "hour", NULL
24573 };
24574
24575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24579 }
24580 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24581 ecode2 = SWIG_AsVal_int(obj1, &val2);
24582 if (!SWIG_IsOK(ecode2)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24584 }
24585 arg2 = static_cast< int >(val2);
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 {
24589 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24590 result = (wxDateTime *) &_result_ref;
24591 }
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24596 return resultobj;
24597 fail:
24598 return NULL;
24599 }
24600
24601
24602 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24603 PyObject *resultobj = 0;
24604 wxDateTime *arg1 = (wxDateTime *) 0 ;
24605 int arg2 ;
24606 wxDateTime *result = 0 ;
24607 void *argp1 = 0 ;
24608 int res1 = 0 ;
24609 int val2 ;
24610 int ecode2 = 0 ;
24611 PyObject * obj0 = 0 ;
24612 PyObject * obj1 = 0 ;
24613 char * kwnames[] = {
24614 (char *) "self",(char *) "minute", NULL
24615 };
24616
24617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24619 if (!SWIG_IsOK(res1)) {
24620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24621 }
24622 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24623 ecode2 = SWIG_AsVal_int(obj1, &val2);
24624 if (!SWIG_IsOK(ecode2)) {
24625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24626 }
24627 arg2 = static_cast< int >(val2);
24628 {
24629 PyThreadState* __tstate = wxPyBeginAllowThreads();
24630 {
24631 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24632 result = (wxDateTime *) &_result_ref;
24633 }
24634 wxPyEndAllowThreads(__tstate);
24635 if (PyErr_Occurred()) SWIG_fail;
24636 }
24637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24638 return resultobj;
24639 fail:
24640 return NULL;
24641 }
24642
24643
24644 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24645 PyObject *resultobj = 0;
24646 wxDateTime *arg1 = (wxDateTime *) 0 ;
24647 int arg2 ;
24648 wxDateTime *result = 0 ;
24649 void *argp1 = 0 ;
24650 int res1 = 0 ;
24651 int val2 ;
24652 int ecode2 = 0 ;
24653 PyObject * obj0 = 0 ;
24654 PyObject * obj1 = 0 ;
24655 char * kwnames[] = {
24656 (char *) "self",(char *) "second", NULL
24657 };
24658
24659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24661 if (!SWIG_IsOK(res1)) {
24662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24663 }
24664 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24665 ecode2 = SWIG_AsVal_int(obj1, &val2);
24666 if (!SWIG_IsOK(ecode2)) {
24667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24668 }
24669 arg2 = static_cast< int >(val2);
24670 {
24671 PyThreadState* __tstate = wxPyBeginAllowThreads();
24672 {
24673 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24674 result = (wxDateTime *) &_result_ref;
24675 }
24676 wxPyEndAllowThreads(__tstate);
24677 if (PyErr_Occurred()) SWIG_fail;
24678 }
24679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24687 PyObject *resultobj = 0;
24688 wxDateTime *arg1 = (wxDateTime *) 0 ;
24689 int arg2 ;
24690 wxDateTime *result = 0 ;
24691 void *argp1 = 0 ;
24692 int res1 = 0 ;
24693 int val2 ;
24694 int ecode2 = 0 ;
24695 PyObject * obj0 = 0 ;
24696 PyObject * obj1 = 0 ;
24697 char * kwnames[] = {
24698 (char *) "self",(char *) "millisecond", NULL
24699 };
24700
24701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24703 if (!SWIG_IsOK(res1)) {
24704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24705 }
24706 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24707 ecode2 = SWIG_AsVal_int(obj1, &val2);
24708 if (!SWIG_IsOK(ecode2)) {
24709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24710 }
24711 arg2 = static_cast< int >(val2);
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 {
24715 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24716 result = (wxDateTime *) &_result_ref;
24717 }
24718 wxPyEndAllowThreads(__tstate);
24719 if (PyErr_Occurred()) SWIG_fail;
24720 }
24721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24729 PyObject *resultobj = 0;
24730 wxDateTime *arg1 = (wxDateTime *) 0 ;
24731 wxDateTime::WeekDay arg2 ;
24732 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24733 wxDateTime *result = 0 ;
24734 void *argp1 = 0 ;
24735 int res1 = 0 ;
24736 int val2 ;
24737 int ecode2 = 0 ;
24738 int val3 ;
24739 int ecode3 = 0 ;
24740 PyObject * obj0 = 0 ;
24741 PyObject * obj1 = 0 ;
24742 PyObject * obj2 = 0 ;
24743 char * kwnames[] = {
24744 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24745 };
24746
24747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24749 if (!SWIG_IsOK(res1)) {
24750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24751 }
24752 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24753 ecode2 = SWIG_AsVal_int(obj1, &val2);
24754 if (!SWIG_IsOK(ecode2)) {
24755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24756 }
24757 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24758 if (obj2) {
24759 ecode3 = SWIG_AsVal_int(obj2, &val3);
24760 if (!SWIG_IsOK(ecode3)) {
24761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24762 }
24763 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24764 }
24765 {
24766 PyThreadState* __tstate = wxPyBeginAllowThreads();
24767 {
24768 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24769 result = (wxDateTime *) &_result_ref;
24770 }
24771 wxPyEndAllowThreads(__tstate);
24772 if (PyErr_Occurred()) SWIG_fail;
24773 }
24774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24775 return resultobj;
24776 fail:
24777 return NULL;
24778 }
24779
24780
24781 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24782 PyObject *resultobj = 0;
24783 wxDateTime *arg1 = (wxDateTime *) 0 ;
24784 wxDateTime::WeekDay arg2 ;
24785 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24786 wxDateTime result;
24787 void *argp1 = 0 ;
24788 int res1 = 0 ;
24789 int val2 ;
24790 int ecode2 = 0 ;
24791 int val3 ;
24792 int ecode3 = 0 ;
24793 PyObject * obj0 = 0 ;
24794 PyObject * obj1 = 0 ;
24795 PyObject * obj2 = 0 ;
24796 char * kwnames[] = {
24797 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24798 };
24799
24800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24802 if (!SWIG_IsOK(res1)) {
24803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24804 }
24805 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24806 ecode2 = SWIG_AsVal_int(obj1, &val2);
24807 if (!SWIG_IsOK(ecode2)) {
24808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24809 }
24810 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24811 if (obj2) {
24812 ecode3 = SWIG_AsVal_int(obj2, &val3);
24813 if (!SWIG_IsOK(ecode3)) {
24814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24815 }
24816 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24817 }
24818 {
24819 PyThreadState* __tstate = wxPyBeginAllowThreads();
24820 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24821 wxPyEndAllowThreads(__tstate);
24822 if (PyErr_Occurred()) SWIG_fail;
24823 }
24824 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj = 0;
24833 wxDateTime *arg1 = (wxDateTime *) 0 ;
24834 wxDateTime::WeekDay arg2 ;
24835 wxDateTime *result = 0 ;
24836 void *argp1 = 0 ;
24837 int res1 = 0 ;
24838 int val2 ;
24839 int ecode2 = 0 ;
24840 PyObject * obj0 = 0 ;
24841 PyObject * obj1 = 0 ;
24842 char * kwnames[] = {
24843 (char *) "self",(char *) "weekday", NULL
24844 };
24845
24846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24848 if (!SWIG_IsOK(res1)) {
24849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24850 }
24851 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24852 ecode2 = SWIG_AsVal_int(obj1, &val2);
24853 if (!SWIG_IsOK(ecode2)) {
24854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24855 }
24856 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24857 {
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 {
24860 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24861 result = (wxDateTime *) &_result_ref;
24862 }
24863 wxPyEndAllowThreads(__tstate);
24864 if (PyErr_Occurred()) SWIG_fail;
24865 }
24866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24867 return resultobj;
24868 fail:
24869 return NULL;
24870 }
24871
24872
24873 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24874 PyObject *resultobj = 0;
24875 wxDateTime *arg1 = (wxDateTime *) 0 ;
24876 wxDateTime::WeekDay arg2 ;
24877 wxDateTime result;
24878 void *argp1 = 0 ;
24879 int res1 = 0 ;
24880 int val2 ;
24881 int ecode2 = 0 ;
24882 PyObject * obj0 = 0 ;
24883 PyObject * obj1 = 0 ;
24884 char * kwnames[] = {
24885 (char *) "self",(char *) "weekday", NULL
24886 };
24887
24888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24890 if (!SWIG_IsOK(res1)) {
24891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24892 }
24893 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24894 ecode2 = SWIG_AsVal_int(obj1, &val2);
24895 if (!SWIG_IsOK(ecode2)) {
24896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24897 }
24898 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24899 {
24900 PyThreadState* __tstate = wxPyBeginAllowThreads();
24901 result = (arg1)->GetNextWeekDay(arg2);
24902 wxPyEndAllowThreads(__tstate);
24903 if (PyErr_Occurred()) SWIG_fail;
24904 }
24905 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24906 return resultobj;
24907 fail:
24908 return NULL;
24909 }
24910
24911
24912 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24913 PyObject *resultobj = 0;
24914 wxDateTime *arg1 = (wxDateTime *) 0 ;
24915 wxDateTime::WeekDay arg2 ;
24916 wxDateTime *result = 0 ;
24917 void *argp1 = 0 ;
24918 int res1 = 0 ;
24919 int val2 ;
24920 int ecode2 = 0 ;
24921 PyObject * obj0 = 0 ;
24922 PyObject * obj1 = 0 ;
24923 char * kwnames[] = {
24924 (char *) "self",(char *) "weekday", NULL
24925 };
24926
24927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24929 if (!SWIG_IsOK(res1)) {
24930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24931 }
24932 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24933 ecode2 = SWIG_AsVal_int(obj1, &val2);
24934 if (!SWIG_IsOK(ecode2)) {
24935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24936 }
24937 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24938 {
24939 PyThreadState* __tstate = wxPyBeginAllowThreads();
24940 {
24941 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24942 result = (wxDateTime *) &_result_ref;
24943 }
24944 wxPyEndAllowThreads(__tstate);
24945 if (PyErr_Occurred()) SWIG_fail;
24946 }
24947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24948 return resultobj;
24949 fail:
24950 return NULL;
24951 }
24952
24953
24954 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24955 PyObject *resultobj = 0;
24956 wxDateTime *arg1 = (wxDateTime *) 0 ;
24957 wxDateTime::WeekDay arg2 ;
24958 wxDateTime result;
24959 void *argp1 = 0 ;
24960 int res1 = 0 ;
24961 int val2 ;
24962 int ecode2 = 0 ;
24963 PyObject * obj0 = 0 ;
24964 PyObject * obj1 = 0 ;
24965 char * kwnames[] = {
24966 (char *) "self",(char *) "weekday", NULL
24967 };
24968
24969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24971 if (!SWIG_IsOK(res1)) {
24972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24973 }
24974 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24975 ecode2 = SWIG_AsVal_int(obj1, &val2);
24976 if (!SWIG_IsOK(ecode2)) {
24977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24978 }
24979 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24980 {
24981 PyThreadState* __tstate = wxPyBeginAllowThreads();
24982 result = (arg1)->GetPrevWeekDay(arg2);
24983 wxPyEndAllowThreads(__tstate);
24984 if (PyErr_Occurred()) SWIG_fail;
24985 }
24986 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24987 return resultobj;
24988 fail:
24989 return NULL;
24990 }
24991
24992
24993 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24994 PyObject *resultobj = 0;
24995 wxDateTime *arg1 = (wxDateTime *) 0 ;
24996 wxDateTime::WeekDay arg2 ;
24997 int arg3 = (int) 1 ;
24998 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24999 int arg5 = (int) wxDateTime::Inv_Year ;
25000 bool result;
25001 void *argp1 = 0 ;
25002 int res1 = 0 ;
25003 int val2 ;
25004 int ecode2 = 0 ;
25005 int val3 ;
25006 int ecode3 = 0 ;
25007 int val4 ;
25008 int ecode4 = 0 ;
25009 int val5 ;
25010 int ecode5 = 0 ;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 PyObject * obj2 = 0 ;
25014 PyObject * obj3 = 0 ;
25015 PyObject * obj4 = 0 ;
25016 char * kwnames[] = {
25017 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25018 };
25019
25020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25022 if (!SWIG_IsOK(res1)) {
25023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25024 }
25025 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25026 ecode2 = SWIG_AsVal_int(obj1, &val2);
25027 if (!SWIG_IsOK(ecode2)) {
25028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25029 }
25030 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25031 if (obj2) {
25032 ecode3 = SWIG_AsVal_int(obj2, &val3);
25033 if (!SWIG_IsOK(ecode3)) {
25034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25035 }
25036 arg3 = static_cast< int >(val3);
25037 }
25038 if (obj3) {
25039 ecode4 = SWIG_AsVal_int(obj3, &val4);
25040 if (!SWIG_IsOK(ecode4)) {
25041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25042 }
25043 arg4 = static_cast< wxDateTime::Month >(val4);
25044 }
25045 if (obj4) {
25046 ecode5 = SWIG_AsVal_int(obj4, &val5);
25047 if (!SWIG_IsOK(ecode5)) {
25048 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25049 }
25050 arg5 = static_cast< int >(val5);
25051 }
25052 {
25053 PyThreadState* __tstate = wxPyBeginAllowThreads();
25054 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25055 wxPyEndAllowThreads(__tstate);
25056 if (PyErr_Occurred()) SWIG_fail;
25057 }
25058 {
25059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25060 }
25061 return resultobj;
25062 fail:
25063 return NULL;
25064 }
25065
25066
25067 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25068 PyObject *resultobj = 0;
25069 wxDateTime *arg1 = (wxDateTime *) 0 ;
25070 wxDateTime::WeekDay arg2 ;
25071 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25072 int arg4 = (int) wxDateTime::Inv_Year ;
25073 bool result;
25074 void *argp1 = 0 ;
25075 int res1 = 0 ;
25076 int val2 ;
25077 int ecode2 = 0 ;
25078 int val3 ;
25079 int ecode3 = 0 ;
25080 int val4 ;
25081 int ecode4 = 0 ;
25082 PyObject * obj0 = 0 ;
25083 PyObject * obj1 = 0 ;
25084 PyObject * obj2 = 0 ;
25085 PyObject * obj3 = 0 ;
25086 char * kwnames[] = {
25087 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25088 };
25089
25090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25092 if (!SWIG_IsOK(res1)) {
25093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25094 }
25095 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25096 ecode2 = SWIG_AsVal_int(obj1, &val2);
25097 if (!SWIG_IsOK(ecode2)) {
25098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25099 }
25100 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25101 if (obj2) {
25102 ecode3 = SWIG_AsVal_int(obj2, &val3);
25103 if (!SWIG_IsOK(ecode3)) {
25104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25105 }
25106 arg3 = static_cast< wxDateTime::Month >(val3);
25107 }
25108 if (obj3) {
25109 ecode4 = SWIG_AsVal_int(obj3, &val4);
25110 if (!SWIG_IsOK(ecode4)) {
25111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25112 }
25113 arg4 = static_cast< int >(val4);
25114 }
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25118 wxPyEndAllowThreads(__tstate);
25119 if (PyErr_Occurred()) SWIG_fail;
25120 }
25121 {
25122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25123 }
25124 return resultobj;
25125 fail:
25126 return NULL;
25127 }
25128
25129
25130 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25131 PyObject *resultobj = 0;
25132 wxDateTime *arg1 = (wxDateTime *) 0 ;
25133 wxDateTime::WeekDay arg2 ;
25134 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25135 int arg4 = (int) wxDateTime::Inv_Year ;
25136 wxDateTime result;
25137 void *argp1 = 0 ;
25138 int res1 = 0 ;
25139 int val2 ;
25140 int ecode2 = 0 ;
25141 int val3 ;
25142 int ecode3 = 0 ;
25143 int val4 ;
25144 int ecode4 = 0 ;
25145 PyObject * obj0 = 0 ;
25146 PyObject * obj1 = 0 ;
25147 PyObject * obj2 = 0 ;
25148 PyObject * obj3 = 0 ;
25149 char * kwnames[] = {
25150 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25151 };
25152
25153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25155 if (!SWIG_IsOK(res1)) {
25156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25157 }
25158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25159 ecode2 = SWIG_AsVal_int(obj1, &val2);
25160 if (!SWIG_IsOK(ecode2)) {
25161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25162 }
25163 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25164 if (obj2) {
25165 ecode3 = SWIG_AsVal_int(obj2, &val3);
25166 if (!SWIG_IsOK(ecode3)) {
25167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25168 }
25169 arg3 = static_cast< wxDateTime::Month >(val3);
25170 }
25171 if (obj3) {
25172 ecode4 = SWIG_AsVal_int(obj3, &val4);
25173 if (!SWIG_IsOK(ecode4)) {
25174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25175 }
25176 arg4 = static_cast< int >(val4);
25177 }
25178 {
25179 PyThreadState* __tstate = wxPyBeginAllowThreads();
25180 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25181 wxPyEndAllowThreads(__tstate);
25182 if (PyErr_Occurred()) SWIG_fail;
25183 }
25184 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25185 return resultobj;
25186 fail:
25187 return NULL;
25188 }
25189
25190
25191 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25192 PyObject *resultobj = 0;
25193 wxDateTime *arg1 = (wxDateTime *) 0 ;
25194 int arg2 ;
25195 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25196 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25197 bool result;
25198 void *argp1 = 0 ;
25199 int res1 = 0 ;
25200 int val2 ;
25201 int ecode2 = 0 ;
25202 int val3 ;
25203 int ecode3 = 0 ;
25204 int val4 ;
25205 int ecode4 = 0 ;
25206 PyObject * obj0 = 0 ;
25207 PyObject * obj1 = 0 ;
25208 PyObject * obj2 = 0 ;
25209 PyObject * obj3 = 0 ;
25210 char * kwnames[] = {
25211 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25212 };
25213
25214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25216 if (!SWIG_IsOK(res1)) {
25217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25218 }
25219 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25220 ecode2 = SWIG_AsVal_int(obj1, &val2);
25221 if (!SWIG_IsOK(ecode2)) {
25222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25223 }
25224 arg2 = static_cast< int >(val2);
25225 if (obj2) {
25226 ecode3 = SWIG_AsVal_int(obj2, &val3);
25227 if (!SWIG_IsOK(ecode3)) {
25228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25229 }
25230 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25231 }
25232 if (obj3) {
25233 ecode4 = SWIG_AsVal_int(obj3, &val4);
25234 if (!SWIG_IsOK(ecode4)) {
25235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25236 }
25237 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25238 }
25239 {
25240 PyThreadState* __tstate = wxPyBeginAllowThreads();
25241 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25242 wxPyEndAllowThreads(__tstate);
25243 if (PyErr_Occurred()) SWIG_fail;
25244 }
25245 {
25246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25247 }
25248 return resultobj;
25249 fail:
25250 return NULL;
25251 }
25252
25253
25254 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj = 0;
25256 wxDateTime *arg1 = (wxDateTime *) 0 ;
25257 int arg2 ;
25258 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25259 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25260 wxDateTime result;
25261 void *argp1 = 0 ;
25262 int res1 = 0 ;
25263 int val2 ;
25264 int ecode2 = 0 ;
25265 int val3 ;
25266 int ecode3 = 0 ;
25267 int val4 ;
25268 int ecode4 = 0 ;
25269 PyObject * obj0 = 0 ;
25270 PyObject * obj1 = 0 ;
25271 PyObject * obj2 = 0 ;
25272 PyObject * obj3 = 0 ;
25273 char * kwnames[] = {
25274 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25275 };
25276
25277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25279 if (!SWIG_IsOK(res1)) {
25280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25281 }
25282 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25283 ecode2 = SWIG_AsVal_int(obj1, &val2);
25284 if (!SWIG_IsOK(ecode2)) {
25285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25286 }
25287 arg2 = static_cast< int >(val2);
25288 if (obj2) {
25289 ecode3 = SWIG_AsVal_int(obj2, &val3);
25290 if (!SWIG_IsOK(ecode3)) {
25291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25292 }
25293 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25294 }
25295 if (obj3) {
25296 ecode4 = SWIG_AsVal_int(obj3, &val4);
25297 if (!SWIG_IsOK(ecode4)) {
25298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25299 }
25300 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25301 }
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 result = (arg1)->GetWeek(arg2,arg3,arg4);
25305 wxPyEndAllowThreads(__tstate);
25306 if (PyErr_Occurred()) SWIG_fail;
25307 }
25308 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj = 0;
25317 int arg1 ;
25318 int arg2 ;
25319 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25320 wxDateTime result;
25321 int val1 ;
25322 int ecode1 = 0 ;
25323 int val2 ;
25324 int ecode2 = 0 ;
25325 int val3 ;
25326 int ecode3 = 0 ;
25327 PyObject * obj0 = 0 ;
25328 PyObject * obj1 = 0 ;
25329 PyObject * obj2 = 0 ;
25330 char * kwnames[] = {
25331 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25332 };
25333
25334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25335 ecode1 = SWIG_AsVal_int(obj0, &val1);
25336 if (!SWIG_IsOK(ecode1)) {
25337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25338 }
25339 arg1 = static_cast< int >(val1);
25340 ecode2 = SWIG_AsVal_int(obj1, &val2);
25341 if (!SWIG_IsOK(ecode2)) {
25342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25343 }
25344 arg2 = static_cast< int >(val2);
25345 if (obj2) {
25346 ecode3 = SWIG_AsVal_int(obj2, &val3);
25347 if (!SWIG_IsOK(ecode3)) {
25348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25349 }
25350 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25351 }
25352 {
25353 PyThreadState* __tstate = wxPyBeginAllowThreads();
25354 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25355 wxPyEndAllowThreads(__tstate);
25356 if (PyErr_Occurred()) SWIG_fail;
25357 }
25358 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj = 0;
25367 wxDateTime *arg1 = (wxDateTime *) 0 ;
25368 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25369 int arg3 = (int) wxDateTime::Inv_Year ;
25370 wxDateTime *result = 0 ;
25371 void *argp1 = 0 ;
25372 int res1 = 0 ;
25373 int val2 ;
25374 int ecode2 = 0 ;
25375 int val3 ;
25376 int ecode3 = 0 ;
25377 PyObject * obj0 = 0 ;
25378 PyObject * obj1 = 0 ;
25379 PyObject * obj2 = 0 ;
25380 char * kwnames[] = {
25381 (char *) "self",(char *) "month",(char *) "year", NULL
25382 };
25383
25384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25386 if (!SWIG_IsOK(res1)) {
25387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25388 }
25389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25390 if (obj1) {
25391 ecode2 = SWIG_AsVal_int(obj1, &val2);
25392 if (!SWIG_IsOK(ecode2)) {
25393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25394 }
25395 arg2 = static_cast< wxDateTime::Month >(val2);
25396 }
25397 if (obj2) {
25398 ecode3 = SWIG_AsVal_int(obj2, &val3);
25399 if (!SWIG_IsOK(ecode3)) {
25400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25401 }
25402 arg3 = static_cast< int >(val3);
25403 }
25404 {
25405 PyThreadState* __tstate = wxPyBeginAllowThreads();
25406 {
25407 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25408 result = (wxDateTime *) &_result_ref;
25409 }
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25414 return resultobj;
25415 fail:
25416 return NULL;
25417 }
25418
25419
25420 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25421 PyObject *resultobj = 0;
25422 wxDateTime *arg1 = (wxDateTime *) 0 ;
25423 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25424 int arg3 = (int) wxDateTime::Inv_Year ;
25425 wxDateTime result;
25426 void *argp1 = 0 ;
25427 int res1 = 0 ;
25428 int val2 ;
25429 int ecode2 = 0 ;
25430 int val3 ;
25431 int ecode3 = 0 ;
25432 PyObject * obj0 = 0 ;
25433 PyObject * obj1 = 0 ;
25434 PyObject * obj2 = 0 ;
25435 char * kwnames[] = {
25436 (char *) "self",(char *) "month",(char *) "year", NULL
25437 };
25438
25439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25441 if (!SWIG_IsOK(res1)) {
25442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25443 }
25444 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25445 if (obj1) {
25446 ecode2 = SWIG_AsVal_int(obj1, &val2);
25447 if (!SWIG_IsOK(ecode2)) {
25448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25449 }
25450 arg2 = static_cast< wxDateTime::Month >(val2);
25451 }
25452 if (obj2) {
25453 ecode3 = SWIG_AsVal_int(obj2, &val3);
25454 if (!SWIG_IsOK(ecode3)) {
25455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25456 }
25457 arg3 = static_cast< int >(val3);
25458 }
25459 {
25460 PyThreadState* __tstate = wxPyBeginAllowThreads();
25461 result = (arg1)->GetLastMonthDay(arg2,arg3);
25462 wxPyEndAllowThreads(__tstate);
25463 if (PyErr_Occurred()) SWIG_fail;
25464 }
25465 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25466 return resultobj;
25467 fail:
25468 return NULL;
25469 }
25470
25471
25472 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25473 PyObject *resultobj = 0;
25474 wxDateTime *arg1 = (wxDateTime *) 0 ;
25475 int arg2 ;
25476 wxDateTime *result = 0 ;
25477 void *argp1 = 0 ;
25478 int res1 = 0 ;
25479 int val2 ;
25480 int ecode2 = 0 ;
25481 PyObject * obj0 = 0 ;
25482 PyObject * obj1 = 0 ;
25483 char * kwnames[] = {
25484 (char *) "self",(char *) "yday", NULL
25485 };
25486
25487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25489 if (!SWIG_IsOK(res1)) {
25490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25491 }
25492 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25493 ecode2 = SWIG_AsVal_int(obj1, &val2);
25494 if (!SWIG_IsOK(ecode2)) {
25495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25496 }
25497 arg2 = static_cast< int >(val2);
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 {
25501 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25502 result = (wxDateTime *) &_result_ref;
25503 }
25504 wxPyEndAllowThreads(__tstate);
25505 if (PyErr_Occurred()) SWIG_fail;
25506 }
25507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25508 return resultobj;
25509 fail:
25510 return NULL;
25511 }
25512
25513
25514 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25515 PyObject *resultobj = 0;
25516 wxDateTime *arg1 = (wxDateTime *) 0 ;
25517 int arg2 ;
25518 wxDateTime result;
25519 void *argp1 = 0 ;
25520 int res1 = 0 ;
25521 int val2 ;
25522 int ecode2 = 0 ;
25523 PyObject * obj0 = 0 ;
25524 PyObject * obj1 = 0 ;
25525 char * kwnames[] = {
25526 (char *) "self",(char *) "yday", NULL
25527 };
25528
25529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25531 if (!SWIG_IsOK(res1)) {
25532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25533 }
25534 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25535 ecode2 = SWIG_AsVal_int(obj1, &val2);
25536 if (!SWIG_IsOK(ecode2)) {
25537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25538 }
25539 arg2 = static_cast< int >(val2);
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 result = (arg1)->GetYearDay(arg2);
25543 wxPyEndAllowThreads(__tstate);
25544 if (PyErr_Occurred()) SWIG_fail;
25545 }
25546 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25547 return resultobj;
25548 fail:
25549 return NULL;
25550 }
25551
25552
25553 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25554 PyObject *resultobj = 0;
25555 wxDateTime *arg1 = (wxDateTime *) 0 ;
25556 double result;
25557 void *argp1 = 0 ;
25558 int res1 = 0 ;
25559 PyObject *swig_obj[1] ;
25560
25561 if (!args) SWIG_fail;
25562 swig_obj[0] = args;
25563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25564 if (!SWIG_IsOK(res1)) {
25565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25566 }
25567 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25568 {
25569 PyThreadState* __tstate = wxPyBeginAllowThreads();
25570 result = (double)(arg1)->GetJulianDayNumber();
25571 wxPyEndAllowThreads(__tstate);
25572 if (PyErr_Occurred()) SWIG_fail;
25573 }
25574 resultobj = SWIG_From_double(static_cast< double >(result));
25575 return resultobj;
25576 fail:
25577 return NULL;
25578 }
25579
25580
25581 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25582 PyObject *resultobj = 0;
25583 wxDateTime *arg1 = (wxDateTime *) 0 ;
25584 double result;
25585 void *argp1 = 0 ;
25586 int res1 = 0 ;
25587 PyObject *swig_obj[1] ;
25588
25589 if (!args) SWIG_fail;
25590 swig_obj[0] = args;
25591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25592 if (!SWIG_IsOK(res1)) {
25593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25594 }
25595 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 result = (double)(arg1)->GetJDN();
25599 wxPyEndAllowThreads(__tstate);
25600 if (PyErr_Occurred()) SWIG_fail;
25601 }
25602 resultobj = SWIG_From_double(static_cast< double >(result));
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25610 PyObject *resultobj = 0;
25611 wxDateTime *arg1 = (wxDateTime *) 0 ;
25612 double result;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 PyObject *swig_obj[1] ;
25616
25617 if (!args) SWIG_fail;
25618 swig_obj[0] = args;
25619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25620 if (!SWIG_IsOK(res1)) {
25621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25622 }
25623 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 resultobj = SWIG_From_double(static_cast< double >(result));
25631 return resultobj;
25632 fail:
25633 return NULL;
25634 }
25635
25636
25637 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25638 PyObject *resultobj = 0;
25639 wxDateTime *arg1 = (wxDateTime *) 0 ;
25640 double result;
25641 void *argp1 = 0 ;
25642 int res1 = 0 ;
25643 PyObject *swig_obj[1] ;
25644
25645 if (!args) SWIG_fail;
25646 swig_obj[0] = args;
25647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25648 if (!SWIG_IsOK(res1)) {
25649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25650 }
25651 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = (double)(arg1)->GetMJD();
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 resultobj = SWIG_From_double(static_cast< double >(result));
25659 return resultobj;
25660 fail:
25661 return NULL;
25662 }
25663
25664
25665 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25666 PyObject *resultobj = 0;
25667 wxDateTime *arg1 = (wxDateTime *) 0 ;
25668 double result;
25669 void *argp1 = 0 ;
25670 int res1 = 0 ;
25671 PyObject *swig_obj[1] ;
25672
25673 if (!args) SWIG_fail;
25674 swig_obj[0] = args;
25675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25678 }
25679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 result = (double)(arg1)->GetRataDie();
25683 wxPyEndAllowThreads(__tstate);
25684 if (PyErr_Occurred()) SWIG_fail;
25685 }
25686 resultobj = SWIG_From_double(static_cast< double >(result));
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25694 PyObject *resultobj = 0;
25695 wxDateTime *arg1 = (wxDateTime *) 0 ;
25696 wxDateTime::TimeZone *arg2 = 0 ;
25697 bool arg3 = (bool) false ;
25698 wxDateTime result;
25699 void *argp1 = 0 ;
25700 int res1 = 0 ;
25701 bool temp2 = false ;
25702 bool val3 ;
25703 int ecode3 = 0 ;
25704 PyObject * obj0 = 0 ;
25705 PyObject * obj1 = 0 ;
25706 PyObject * obj2 = 0 ;
25707 char * kwnames[] = {
25708 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25709 };
25710
25711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25713 if (!SWIG_IsOK(res1)) {
25714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25715 }
25716 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25717 {
25718 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25719 temp2 = true;
25720 }
25721 if (obj2) {
25722 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25723 if (!SWIG_IsOK(ecode3)) {
25724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25725 }
25726 arg3 = static_cast< bool >(val3);
25727 }
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25735 {
25736 if (temp2) delete arg2;
25737 }
25738 return resultobj;
25739 fail:
25740 {
25741 if (temp2) delete arg2;
25742 }
25743 return NULL;
25744 }
25745
25746
25747 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25748 PyObject *resultobj = 0;
25749 wxDateTime *arg1 = (wxDateTime *) 0 ;
25750 wxDateTime::TimeZone *arg2 = 0 ;
25751 bool arg3 = (bool) false ;
25752 wxDateTime *result = 0 ;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 bool temp2 = false ;
25756 bool val3 ;
25757 int ecode3 = 0 ;
25758 PyObject * obj0 = 0 ;
25759 PyObject * obj1 = 0 ;
25760 PyObject * obj2 = 0 ;
25761 char * kwnames[] = {
25762 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25763 };
25764
25765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25767 if (!SWIG_IsOK(res1)) {
25768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25769 }
25770 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25771 {
25772 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25773 temp2 = true;
25774 }
25775 if (obj2) {
25776 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25777 if (!SWIG_IsOK(ecode3)) {
25778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25779 }
25780 arg3 = static_cast< bool >(val3);
25781 }
25782 {
25783 PyThreadState* __tstate = wxPyBeginAllowThreads();
25784 {
25785 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25786 result = (wxDateTime *) &_result_ref;
25787 }
25788 wxPyEndAllowThreads(__tstate);
25789 if (PyErr_Occurred()) SWIG_fail;
25790 }
25791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25792 {
25793 if (temp2) delete arg2;
25794 }
25795 return resultobj;
25796 fail:
25797 {
25798 if (temp2) delete arg2;
25799 }
25800 return NULL;
25801 }
25802
25803
25804 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25805 PyObject *resultobj = 0;
25806 wxDateTime *arg1 = (wxDateTime *) 0 ;
25807 wxDateTime::TimeZone *arg2 = 0 ;
25808 bool arg3 = (bool) false ;
25809 wxDateTime result;
25810 void *argp1 = 0 ;
25811 int res1 = 0 ;
25812 bool temp2 = false ;
25813 bool val3 ;
25814 int ecode3 = 0 ;
25815 PyObject * obj0 = 0 ;
25816 PyObject * obj1 = 0 ;
25817 PyObject * obj2 = 0 ;
25818 char * kwnames[] = {
25819 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25820 };
25821
25822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25824 if (!SWIG_IsOK(res1)) {
25825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25826 }
25827 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25828 {
25829 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25830 temp2 = true;
25831 }
25832 if (obj2) {
25833 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25834 if (!SWIG_IsOK(ecode3)) {
25835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25836 }
25837 arg3 = static_cast< bool >(val3);
25838 }
25839 {
25840 PyThreadState* __tstate = wxPyBeginAllowThreads();
25841 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25842 wxPyEndAllowThreads(__tstate);
25843 if (PyErr_Occurred()) SWIG_fail;
25844 }
25845 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25846 {
25847 if (temp2) delete arg2;
25848 }
25849 return resultobj;
25850 fail:
25851 {
25852 if (temp2) delete arg2;
25853 }
25854 return NULL;
25855 }
25856
25857
25858 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj = 0;
25860 wxDateTime *arg1 = (wxDateTime *) 0 ;
25861 wxDateTime::TimeZone *arg2 = 0 ;
25862 bool arg3 = (bool) false ;
25863 wxDateTime *result = 0 ;
25864 void *argp1 = 0 ;
25865 int res1 = 0 ;
25866 bool temp2 = false ;
25867 bool val3 ;
25868 int ecode3 = 0 ;
25869 PyObject * obj0 = 0 ;
25870 PyObject * obj1 = 0 ;
25871 PyObject * obj2 = 0 ;
25872 char * kwnames[] = {
25873 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25874 };
25875
25876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25878 if (!SWIG_IsOK(res1)) {
25879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25880 }
25881 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25882 {
25883 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25884 temp2 = true;
25885 }
25886 if (obj2) {
25887 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25888 if (!SWIG_IsOK(ecode3)) {
25889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25890 }
25891 arg3 = static_cast< bool >(val3);
25892 }
25893 {
25894 PyThreadState* __tstate = wxPyBeginAllowThreads();
25895 {
25896 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25897 result = (wxDateTime *) &_result_ref;
25898 }
25899 wxPyEndAllowThreads(__tstate);
25900 if (PyErr_Occurred()) SWIG_fail;
25901 }
25902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25903 {
25904 if (temp2) delete arg2;
25905 }
25906 return resultobj;
25907 fail:
25908 {
25909 if (temp2) delete arg2;
25910 }
25911 return NULL;
25912 }
25913
25914
25915 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25916 PyObject *resultobj = 0;
25917 wxDateTime *arg1 = (wxDateTime *) 0 ;
25918 bool arg2 = (bool) false ;
25919 wxDateTime result;
25920 void *argp1 = 0 ;
25921 int res1 = 0 ;
25922 bool val2 ;
25923 int ecode2 = 0 ;
25924 PyObject * obj0 = 0 ;
25925 PyObject * obj1 = 0 ;
25926 char * kwnames[] = {
25927 (char *) "self",(char *) "noDST", NULL
25928 };
25929
25930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25932 if (!SWIG_IsOK(res1)) {
25933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25934 }
25935 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25936 if (obj1) {
25937 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25938 if (!SWIG_IsOK(ecode2)) {
25939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25940 }
25941 arg2 = static_cast< bool >(val2);
25942 }
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25957 PyObject *resultobj = 0;
25958 wxDateTime *arg1 = (wxDateTime *) 0 ;
25959 bool arg2 = (bool) false ;
25960 wxDateTime *result = 0 ;
25961 void *argp1 = 0 ;
25962 int res1 = 0 ;
25963 bool val2 ;
25964 int ecode2 = 0 ;
25965 PyObject * obj0 = 0 ;
25966 PyObject * obj1 = 0 ;
25967 char * kwnames[] = {
25968 (char *) "self",(char *) "noDST", NULL
25969 };
25970
25971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25973 if (!SWIG_IsOK(res1)) {
25974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25975 }
25976 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25977 if (obj1) {
25978 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25979 if (!SWIG_IsOK(ecode2)) {
25980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25981 }
25982 arg2 = static_cast< bool >(val2);
25983 }
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 {
25987 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25988 result = (wxDateTime *) &_result_ref;
25989 }
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25994 return resultobj;
25995 fail:
25996 return NULL;
25997 }
25998
25999
26000 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26001 PyObject *resultobj = 0;
26002 wxDateTime *arg1 = (wxDateTime *) 0 ;
26003 bool arg2 = (bool) false ;
26004 wxDateTime result;
26005 void *argp1 = 0 ;
26006 int res1 = 0 ;
26007 bool val2 ;
26008 int ecode2 = 0 ;
26009 PyObject * obj0 = 0 ;
26010 PyObject * obj1 = 0 ;
26011 char * kwnames[] = {
26012 (char *) "self",(char *) "noDST", NULL
26013 };
26014
26015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26017 if (!SWIG_IsOK(res1)) {
26018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26019 }
26020 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26021 if (obj1) {
26022 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26023 if (!SWIG_IsOK(ecode2)) {
26024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26025 }
26026 arg2 = static_cast< bool >(val2);
26027 }
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26031 wxPyEndAllowThreads(__tstate);
26032 if (PyErr_Occurred()) SWIG_fail;
26033 }
26034 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26035 return resultobj;
26036 fail:
26037 return NULL;
26038 }
26039
26040
26041 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26042 PyObject *resultobj = 0;
26043 wxDateTime *arg1 = (wxDateTime *) 0 ;
26044 bool arg2 = (bool) false ;
26045 wxDateTime *result = 0 ;
26046 void *argp1 = 0 ;
26047 int res1 = 0 ;
26048 bool val2 ;
26049 int ecode2 = 0 ;
26050 PyObject * obj0 = 0 ;
26051 PyObject * obj1 = 0 ;
26052 char * kwnames[] = {
26053 (char *) "self",(char *) "noDST", NULL
26054 };
26055
26056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26058 if (!SWIG_IsOK(res1)) {
26059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26060 }
26061 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26062 if (obj1) {
26063 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26064 if (!SWIG_IsOK(ecode2)) {
26065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26066 }
26067 arg2 = static_cast< bool >(val2);
26068 }
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 {
26072 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26073 result = (wxDateTime *) &_result_ref;
26074 }
26075 wxPyEndAllowThreads(__tstate);
26076 if (PyErr_Occurred()) SWIG_fail;
26077 }
26078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26079 return resultobj;
26080 fail:
26081 return NULL;
26082 }
26083
26084
26085 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26086 PyObject *resultobj = 0;
26087 wxDateTime *arg1 = (wxDateTime *) 0 ;
26088 bool arg2 = (bool) false ;
26089 wxDateTime result;
26090 void *argp1 = 0 ;
26091 int res1 = 0 ;
26092 bool val2 ;
26093 int ecode2 = 0 ;
26094 PyObject * obj0 = 0 ;
26095 PyObject * obj1 = 0 ;
26096 char * kwnames[] = {
26097 (char *) "self",(char *) "noDST", NULL
26098 };
26099
26100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26102 if (!SWIG_IsOK(res1)) {
26103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26104 }
26105 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26106 if (obj1) {
26107 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26108 if (!SWIG_IsOK(ecode2)) {
26109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26110 }
26111 arg2 = static_cast< bool >(val2);
26112 }
26113 {
26114 PyThreadState* __tstate = wxPyBeginAllowThreads();
26115 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26116 wxPyEndAllowThreads(__tstate);
26117 if (PyErr_Occurred()) SWIG_fail;
26118 }
26119 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26120 return resultobj;
26121 fail:
26122 return NULL;
26123 }
26124
26125
26126 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26127 PyObject *resultobj = 0;
26128 wxDateTime *arg1 = (wxDateTime *) 0 ;
26129 bool arg2 = (bool) false ;
26130 wxDateTime *result = 0 ;
26131 void *argp1 = 0 ;
26132 int res1 = 0 ;
26133 bool val2 ;
26134 int ecode2 = 0 ;
26135 PyObject * obj0 = 0 ;
26136 PyObject * obj1 = 0 ;
26137 char * kwnames[] = {
26138 (char *) "self",(char *) "noDST", NULL
26139 };
26140
26141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26143 if (!SWIG_IsOK(res1)) {
26144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26145 }
26146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26147 if (obj1) {
26148 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26149 if (!SWIG_IsOK(ecode2)) {
26150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26151 }
26152 arg2 = static_cast< bool >(val2);
26153 }
26154 {
26155 PyThreadState* __tstate = wxPyBeginAllowThreads();
26156 {
26157 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26158 result = (wxDateTime *) &_result_ref;
26159 }
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26171 PyObject *resultobj = 0;
26172 wxDateTime *arg1 = (wxDateTime *) 0 ;
26173 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26174 int result;
26175 void *argp1 = 0 ;
26176 int res1 = 0 ;
26177 int val2 ;
26178 int ecode2 = 0 ;
26179 PyObject * obj0 = 0 ;
26180 PyObject * obj1 = 0 ;
26181 char * kwnames[] = {
26182 (char *) "self",(char *) "country", NULL
26183 };
26184
26185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26189 }
26190 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26191 if (obj1) {
26192 ecode2 = SWIG_AsVal_int(obj1, &val2);
26193 if (!SWIG_IsOK(ecode2)) {
26194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26195 }
26196 arg2 = static_cast< wxDateTime::Country >(val2);
26197 }
26198 {
26199 PyThreadState* __tstate = wxPyBeginAllowThreads();
26200 result = (int)(arg1)->IsDST(arg2);
26201 wxPyEndAllowThreads(__tstate);
26202 if (PyErr_Occurred()) SWIG_fail;
26203 }
26204 resultobj = SWIG_From_int(static_cast< int >(result));
26205 return resultobj;
26206 fail:
26207 return NULL;
26208 }
26209
26210
26211 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26212 PyObject *resultobj = 0;
26213 wxDateTime *arg1 = (wxDateTime *) 0 ;
26214 bool result;
26215 void *argp1 = 0 ;
26216 int res1 = 0 ;
26217 PyObject *swig_obj[1] ;
26218
26219 if (!args) SWIG_fail;
26220 swig_obj[0] = args;
26221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26222 if (!SWIG_IsOK(res1)) {
26223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26224 }
26225 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26226 {
26227 PyThreadState* __tstate = wxPyBeginAllowThreads();
26228 result = (bool)((wxDateTime const *)arg1)->IsValid();
26229 wxPyEndAllowThreads(__tstate);
26230 if (PyErr_Occurred()) SWIG_fail;
26231 }
26232 {
26233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26234 }
26235 return resultobj;
26236 fail:
26237 return NULL;
26238 }
26239
26240
26241 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26242 PyObject *resultobj = 0;
26243 wxDateTime *arg1 = (wxDateTime *) 0 ;
26244 time_t result;
26245 void *argp1 = 0 ;
26246 int res1 = 0 ;
26247 PyObject *swig_obj[1] ;
26248
26249 if (!args) SWIG_fail;
26250 swig_obj[0] = args;
26251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26252 if (!SWIG_IsOK(res1)) {
26253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26254 }
26255 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26256 {
26257 PyThreadState* __tstate = wxPyBeginAllowThreads();
26258 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26259 wxPyEndAllowThreads(__tstate);
26260 if (PyErr_Occurred()) SWIG_fail;
26261 }
26262 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26263 return resultobj;
26264 fail:
26265 return NULL;
26266 }
26267
26268
26269 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26270 PyObject *resultobj = 0;
26271 wxDateTime *arg1 = (wxDateTime *) 0 ;
26272 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26273 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26274 int result;
26275 void *argp1 = 0 ;
26276 int res1 = 0 ;
26277 bool temp2 = false ;
26278 PyObject * obj0 = 0 ;
26279 PyObject * obj1 = 0 ;
26280 char * kwnames[] = {
26281 (char *) "self",(char *) "tz", NULL
26282 };
26283
26284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26286 if (!SWIG_IsOK(res1)) {
26287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26288 }
26289 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26290 if (obj1) {
26291 {
26292 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26293 temp2 = true;
26294 }
26295 }
26296 {
26297 PyThreadState* __tstate = wxPyBeginAllowThreads();
26298 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26299 wxPyEndAllowThreads(__tstate);
26300 if (PyErr_Occurred()) SWIG_fail;
26301 }
26302 resultobj = SWIG_From_int(static_cast< int >(result));
26303 {
26304 if (temp2) delete arg2;
26305 }
26306 return resultobj;
26307 fail:
26308 {
26309 if (temp2) delete arg2;
26310 }
26311 return NULL;
26312 }
26313
26314
26315 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj = 0;
26317 wxDateTime *arg1 = (wxDateTime *) 0 ;
26318 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26319 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26320 wxDateTime::Month result;
26321 void *argp1 = 0 ;
26322 int res1 = 0 ;
26323 bool temp2 = false ;
26324 PyObject * obj0 = 0 ;
26325 PyObject * obj1 = 0 ;
26326 char * kwnames[] = {
26327 (char *) "self",(char *) "tz", NULL
26328 };
26329
26330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26332 if (!SWIG_IsOK(res1)) {
26333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26334 }
26335 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26336 if (obj1) {
26337 {
26338 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26339 temp2 = true;
26340 }
26341 }
26342 {
26343 PyThreadState* __tstate = wxPyBeginAllowThreads();
26344 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26345 wxPyEndAllowThreads(__tstate);
26346 if (PyErr_Occurred()) SWIG_fail;
26347 }
26348 resultobj = SWIG_From_int(static_cast< int >(result));
26349 {
26350 if (temp2) delete arg2;
26351 }
26352 return resultobj;
26353 fail:
26354 {
26355 if (temp2) delete arg2;
26356 }
26357 return NULL;
26358 }
26359
26360
26361 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26362 PyObject *resultobj = 0;
26363 wxDateTime *arg1 = (wxDateTime *) 0 ;
26364 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26365 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26366 int result;
26367 void *argp1 = 0 ;
26368 int res1 = 0 ;
26369 bool temp2 = false ;
26370 PyObject * obj0 = 0 ;
26371 PyObject * obj1 = 0 ;
26372 char * kwnames[] = {
26373 (char *) "self",(char *) "tz", NULL
26374 };
26375
26376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26378 if (!SWIG_IsOK(res1)) {
26379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26380 }
26381 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26382 if (obj1) {
26383 {
26384 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26385 temp2 = true;
26386 }
26387 }
26388 {
26389 PyThreadState* __tstate = wxPyBeginAllowThreads();
26390 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26391 wxPyEndAllowThreads(__tstate);
26392 if (PyErr_Occurred()) SWIG_fail;
26393 }
26394 resultobj = SWIG_From_int(static_cast< int >(result));
26395 {
26396 if (temp2) delete arg2;
26397 }
26398 return resultobj;
26399 fail:
26400 {
26401 if (temp2) delete arg2;
26402 }
26403 return NULL;
26404 }
26405
26406
26407 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26408 PyObject *resultobj = 0;
26409 wxDateTime *arg1 = (wxDateTime *) 0 ;
26410 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26411 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26412 wxDateTime::WeekDay result;
26413 void *argp1 = 0 ;
26414 int res1 = 0 ;
26415 bool temp2 = false ;
26416 PyObject * obj0 = 0 ;
26417 PyObject * obj1 = 0 ;
26418 char * kwnames[] = {
26419 (char *) "self",(char *) "tz", NULL
26420 };
26421
26422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26424 if (!SWIG_IsOK(res1)) {
26425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26426 }
26427 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26428 if (obj1) {
26429 {
26430 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26431 temp2 = true;
26432 }
26433 }
26434 {
26435 PyThreadState* __tstate = wxPyBeginAllowThreads();
26436 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26437 wxPyEndAllowThreads(__tstate);
26438 if (PyErr_Occurred()) SWIG_fail;
26439 }
26440 resultobj = SWIG_From_int(static_cast< int >(result));
26441 {
26442 if (temp2) delete arg2;
26443 }
26444 return resultobj;
26445 fail:
26446 {
26447 if (temp2) delete arg2;
26448 }
26449 return NULL;
26450 }
26451
26452
26453 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26454 PyObject *resultobj = 0;
26455 wxDateTime *arg1 = (wxDateTime *) 0 ;
26456 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26457 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26458 int result;
26459 void *argp1 = 0 ;
26460 int res1 = 0 ;
26461 bool temp2 = false ;
26462 PyObject * obj0 = 0 ;
26463 PyObject * obj1 = 0 ;
26464 char * kwnames[] = {
26465 (char *) "self",(char *) "tz", NULL
26466 };
26467
26468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26470 if (!SWIG_IsOK(res1)) {
26471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26472 }
26473 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26474 if (obj1) {
26475 {
26476 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26477 temp2 = true;
26478 }
26479 }
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26483 wxPyEndAllowThreads(__tstate);
26484 if (PyErr_Occurred()) SWIG_fail;
26485 }
26486 resultobj = SWIG_From_int(static_cast< int >(result));
26487 {
26488 if (temp2) delete arg2;
26489 }
26490 return resultobj;
26491 fail:
26492 {
26493 if (temp2) delete arg2;
26494 }
26495 return NULL;
26496 }
26497
26498
26499 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26500 PyObject *resultobj = 0;
26501 wxDateTime *arg1 = (wxDateTime *) 0 ;
26502 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26503 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26504 int result;
26505 void *argp1 = 0 ;
26506 int res1 = 0 ;
26507 bool temp2 = false ;
26508 PyObject * obj0 = 0 ;
26509 PyObject * obj1 = 0 ;
26510 char * kwnames[] = {
26511 (char *) "self",(char *) "tz", NULL
26512 };
26513
26514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26516 if (!SWIG_IsOK(res1)) {
26517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26518 }
26519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26520 if (obj1) {
26521 {
26522 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26523 temp2 = true;
26524 }
26525 }
26526 {
26527 PyThreadState* __tstate = wxPyBeginAllowThreads();
26528 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26529 wxPyEndAllowThreads(__tstate);
26530 if (PyErr_Occurred()) SWIG_fail;
26531 }
26532 resultobj = SWIG_From_int(static_cast< int >(result));
26533 {
26534 if (temp2) delete arg2;
26535 }
26536 return resultobj;
26537 fail:
26538 {
26539 if (temp2) delete arg2;
26540 }
26541 return NULL;
26542 }
26543
26544
26545 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26546 PyObject *resultobj = 0;
26547 wxDateTime *arg1 = (wxDateTime *) 0 ;
26548 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26549 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26550 int result;
26551 void *argp1 = 0 ;
26552 int res1 = 0 ;
26553 bool temp2 = false ;
26554 PyObject * obj0 = 0 ;
26555 PyObject * obj1 = 0 ;
26556 char * kwnames[] = {
26557 (char *) "self",(char *) "tz", NULL
26558 };
26559
26560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26562 if (!SWIG_IsOK(res1)) {
26563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26564 }
26565 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26566 if (obj1) {
26567 {
26568 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26569 temp2 = true;
26570 }
26571 }
26572 {
26573 PyThreadState* __tstate = wxPyBeginAllowThreads();
26574 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26575 wxPyEndAllowThreads(__tstate);
26576 if (PyErr_Occurred()) SWIG_fail;
26577 }
26578 resultobj = SWIG_From_int(static_cast< int >(result));
26579 {
26580 if (temp2) delete arg2;
26581 }
26582 return resultobj;
26583 fail:
26584 {
26585 if (temp2) delete arg2;
26586 }
26587 return NULL;
26588 }
26589
26590
26591 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26592 PyObject *resultobj = 0;
26593 wxDateTime *arg1 = (wxDateTime *) 0 ;
26594 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26595 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26596 int result;
26597 void *argp1 = 0 ;
26598 int res1 = 0 ;
26599 bool temp2 = false ;
26600 PyObject * obj0 = 0 ;
26601 PyObject * obj1 = 0 ;
26602 char * kwnames[] = {
26603 (char *) "self",(char *) "tz", NULL
26604 };
26605
26606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26608 if (!SWIG_IsOK(res1)) {
26609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26610 }
26611 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26612 if (obj1) {
26613 {
26614 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26615 temp2 = true;
26616 }
26617 }
26618 {
26619 PyThreadState* __tstate = wxPyBeginAllowThreads();
26620 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 resultobj = SWIG_From_int(static_cast< int >(result));
26625 {
26626 if (temp2) delete arg2;
26627 }
26628 return resultobj;
26629 fail:
26630 {
26631 if (temp2) delete arg2;
26632 }
26633 return NULL;
26634 }
26635
26636
26637 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26638 PyObject *resultobj = 0;
26639 wxDateTime *arg1 = (wxDateTime *) 0 ;
26640 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26641 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26642 int result;
26643 void *argp1 = 0 ;
26644 int res1 = 0 ;
26645 bool temp2 = false ;
26646 PyObject * obj0 = 0 ;
26647 PyObject * obj1 = 0 ;
26648 char * kwnames[] = {
26649 (char *) "self",(char *) "tz", NULL
26650 };
26651
26652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26654 if (!SWIG_IsOK(res1)) {
26655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26656 }
26657 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26658 if (obj1) {
26659 {
26660 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26661 temp2 = true;
26662 }
26663 }
26664 {
26665 PyThreadState* __tstate = wxPyBeginAllowThreads();
26666 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 resultobj = SWIG_From_int(static_cast< int >(result));
26671 {
26672 if (temp2) delete arg2;
26673 }
26674 return resultobj;
26675 fail:
26676 {
26677 if (temp2) delete arg2;
26678 }
26679 return NULL;
26680 }
26681
26682
26683 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26684 PyObject *resultobj = 0;
26685 wxDateTime *arg1 = (wxDateTime *) 0 ;
26686 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26687 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26688 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26689 int result;
26690 void *argp1 = 0 ;
26691 int res1 = 0 ;
26692 int val2 ;
26693 int ecode2 = 0 ;
26694 bool temp3 = false ;
26695 PyObject * obj0 = 0 ;
26696 PyObject * obj1 = 0 ;
26697 PyObject * obj2 = 0 ;
26698 char * kwnames[] = {
26699 (char *) "self",(char *) "flags",(char *) "tz", NULL
26700 };
26701
26702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26704 if (!SWIG_IsOK(res1)) {
26705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26706 }
26707 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26708 if (obj1) {
26709 ecode2 = SWIG_AsVal_int(obj1, &val2);
26710 if (!SWIG_IsOK(ecode2)) {
26711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26712 }
26713 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26714 }
26715 if (obj2) {
26716 {
26717 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26718 temp3 = true;
26719 }
26720 }
26721 {
26722 PyThreadState* __tstate = wxPyBeginAllowThreads();
26723 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26724 wxPyEndAllowThreads(__tstate);
26725 if (PyErr_Occurred()) SWIG_fail;
26726 }
26727 resultobj = SWIG_From_int(static_cast< int >(result));
26728 {
26729 if (temp3) delete arg3;
26730 }
26731 return resultobj;
26732 fail:
26733 {
26734 if (temp3) delete arg3;
26735 }
26736 return NULL;
26737 }
26738
26739
26740 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26741 PyObject *resultobj = 0;
26742 wxDateTime *arg1 = (wxDateTime *) 0 ;
26743 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26744 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26745 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26746 int result;
26747 void *argp1 = 0 ;
26748 int res1 = 0 ;
26749 int val2 ;
26750 int ecode2 = 0 ;
26751 bool temp3 = false ;
26752 PyObject * obj0 = 0 ;
26753 PyObject * obj1 = 0 ;
26754 PyObject * obj2 = 0 ;
26755 char * kwnames[] = {
26756 (char *) "self",(char *) "flags",(char *) "tz", NULL
26757 };
26758
26759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26761 if (!SWIG_IsOK(res1)) {
26762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26763 }
26764 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26765 if (obj1) {
26766 ecode2 = SWIG_AsVal_int(obj1, &val2);
26767 if (!SWIG_IsOK(ecode2)) {
26768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26769 }
26770 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26771 }
26772 if (obj2) {
26773 {
26774 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26775 temp3 = true;
26776 }
26777 }
26778 {
26779 PyThreadState* __tstate = wxPyBeginAllowThreads();
26780 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26781 wxPyEndAllowThreads(__tstate);
26782 if (PyErr_Occurred()) SWIG_fail;
26783 }
26784 resultobj = SWIG_From_int(static_cast< int >(result));
26785 {
26786 if (temp3) delete arg3;
26787 }
26788 return resultobj;
26789 fail:
26790 {
26791 if (temp3) delete arg3;
26792 }
26793 return NULL;
26794 }
26795
26796
26797 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26798 PyObject *resultobj = 0;
26799 wxDateTime *arg1 = (wxDateTime *) 0 ;
26800 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26801 bool result;
26802 void *argp1 = 0 ;
26803 int res1 = 0 ;
26804 int val2 ;
26805 int ecode2 = 0 ;
26806 PyObject * obj0 = 0 ;
26807 PyObject * obj1 = 0 ;
26808 char * kwnames[] = {
26809 (char *) "self",(char *) "country", NULL
26810 };
26811
26812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26814 if (!SWIG_IsOK(res1)) {
26815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26816 }
26817 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26818 if (obj1) {
26819 ecode2 = SWIG_AsVal_int(obj1, &val2);
26820 if (!SWIG_IsOK(ecode2)) {
26821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26822 }
26823 arg2 = static_cast< wxDateTime::Country >(val2);
26824 }
26825 {
26826 PyThreadState* __tstate = wxPyBeginAllowThreads();
26827 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26828 wxPyEndAllowThreads(__tstate);
26829 if (PyErr_Occurred()) SWIG_fail;
26830 }
26831 {
26832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26833 }
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj = 0;
26842 wxDateTime *arg1 = (wxDateTime *) 0 ;
26843 wxDateTime *arg2 = 0 ;
26844 bool result;
26845 void *argp1 = 0 ;
26846 int res1 = 0 ;
26847 void *argp2 = 0 ;
26848 int res2 = 0 ;
26849 PyObject * obj0 = 0 ;
26850 PyObject * obj1 = 0 ;
26851 char * kwnames[] = {
26852 (char *) "self",(char *) "datetime", NULL
26853 };
26854
26855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26857 if (!SWIG_IsOK(res1)) {
26858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26859 }
26860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26862 if (!SWIG_IsOK(res2)) {
26863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26864 }
26865 if (!argp2) {
26866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26867 }
26868 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 {
26876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26877 }
26878 return resultobj;
26879 fail:
26880 return NULL;
26881 }
26882
26883
26884 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26885 PyObject *resultobj = 0;
26886 wxDateTime *arg1 = (wxDateTime *) 0 ;
26887 wxDateTime *arg2 = 0 ;
26888 bool result;
26889 void *argp1 = 0 ;
26890 int res1 = 0 ;
26891 void *argp2 = 0 ;
26892 int res2 = 0 ;
26893 PyObject * obj0 = 0 ;
26894 PyObject * obj1 = 0 ;
26895 char * kwnames[] = {
26896 (char *) "self",(char *) "datetime", NULL
26897 };
26898
26899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26901 if (!SWIG_IsOK(res1)) {
26902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26903 }
26904 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26905 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26906 if (!SWIG_IsOK(res2)) {
26907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26908 }
26909 if (!argp2) {
26910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26911 }
26912 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 {
26920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26921 }
26922 return resultobj;
26923 fail:
26924 return NULL;
26925 }
26926
26927
26928 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26929 PyObject *resultobj = 0;
26930 wxDateTime *arg1 = (wxDateTime *) 0 ;
26931 wxDateTime *arg2 = 0 ;
26932 bool result;
26933 void *argp1 = 0 ;
26934 int res1 = 0 ;
26935 void *argp2 = 0 ;
26936 int res2 = 0 ;
26937 PyObject * obj0 = 0 ;
26938 PyObject * obj1 = 0 ;
26939 char * kwnames[] = {
26940 (char *) "self",(char *) "datetime", NULL
26941 };
26942
26943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26945 if (!SWIG_IsOK(res1)) {
26946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26947 }
26948 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26950 if (!SWIG_IsOK(res2)) {
26951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26952 }
26953 if (!argp2) {
26954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26955 }
26956 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26960 wxPyEndAllowThreads(__tstate);
26961 if (PyErr_Occurred()) SWIG_fail;
26962 }
26963 {
26964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26965 }
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26973 PyObject *resultobj = 0;
26974 wxDateTime *arg1 = (wxDateTime *) 0 ;
26975 wxDateTime *arg2 = 0 ;
26976 wxDateTime *arg3 = 0 ;
26977 bool result;
26978 void *argp1 = 0 ;
26979 int res1 = 0 ;
26980 void *argp2 = 0 ;
26981 int res2 = 0 ;
26982 void *argp3 = 0 ;
26983 int res3 = 0 ;
26984 PyObject * obj0 = 0 ;
26985 PyObject * obj1 = 0 ;
26986 PyObject * obj2 = 0 ;
26987 char * kwnames[] = {
26988 (char *) "self",(char *) "t1",(char *) "t2", NULL
26989 };
26990
26991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26993 if (!SWIG_IsOK(res1)) {
26994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26995 }
26996 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26997 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26998 if (!SWIG_IsOK(res2)) {
26999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27000 }
27001 if (!argp2) {
27002 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27003 }
27004 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27005 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27006 if (!SWIG_IsOK(res3)) {
27007 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27008 }
27009 if (!argp3) {
27010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27011 }
27012 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27016 wxPyEndAllowThreads(__tstate);
27017 if (PyErr_Occurred()) SWIG_fail;
27018 }
27019 {
27020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27021 }
27022 return resultobj;
27023 fail:
27024 return NULL;
27025 }
27026
27027
27028 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27029 PyObject *resultobj = 0;
27030 wxDateTime *arg1 = (wxDateTime *) 0 ;
27031 wxDateTime *arg2 = 0 ;
27032 wxDateTime *arg3 = 0 ;
27033 bool result;
27034 void *argp1 = 0 ;
27035 int res1 = 0 ;
27036 void *argp2 = 0 ;
27037 int res2 = 0 ;
27038 void *argp3 = 0 ;
27039 int res3 = 0 ;
27040 PyObject * obj0 = 0 ;
27041 PyObject * obj1 = 0 ;
27042 PyObject * obj2 = 0 ;
27043 char * kwnames[] = {
27044 (char *) "self",(char *) "t1",(char *) "t2", NULL
27045 };
27046
27047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27049 if (!SWIG_IsOK(res1)) {
27050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27051 }
27052 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27054 if (!SWIG_IsOK(res2)) {
27055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27056 }
27057 if (!argp2) {
27058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27059 }
27060 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27061 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27062 if (!SWIG_IsOK(res3)) {
27063 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27064 }
27065 if (!argp3) {
27066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27067 }
27068 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 {
27076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27077 }
27078 return resultobj;
27079 fail:
27080 return NULL;
27081 }
27082
27083
27084 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27085 PyObject *resultobj = 0;
27086 wxDateTime *arg1 = (wxDateTime *) 0 ;
27087 wxDateTime *arg2 = 0 ;
27088 bool result;
27089 void *argp1 = 0 ;
27090 int res1 = 0 ;
27091 void *argp2 = 0 ;
27092 int res2 = 0 ;
27093 PyObject * obj0 = 0 ;
27094 PyObject * obj1 = 0 ;
27095 char * kwnames[] = {
27096 (char *) "self",(char *) "dt", NULL
27097 };
27098
27099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27101 if (!SWIG_IsOK(res1)) {
27102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27103 }
27104 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27105 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27106 if (!SWIG_IsOK(res2)) {
27107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27108 }
27109 if (!argp2) {
27110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27111 }
27112 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27113 {
27114 PyThreadState* __tstate = wxPyBeginAllowThreads();
27115 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 {
27120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27121 }
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj = 0;
27130 wxDateTime *arg1 = (wxDateTime *) 0 ;
27131 wxDateTime *arg2 = 0 ;
27132 bool result;
27133 void *argp1 = 0 ;
27134 int res1 = 0 ;
27135 void *argp2 = 0 ;
27136 int res2 = 0 ;
27137 PyObject * obj0 = 0 ;
27138 PyObject * obj1 = 0 ;
27139 char * kwnames[] = {
27140 (char *) "self",(char *) "dt", NULL
27141 };
27142
27143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27145 if (!SWIG_IsOK(res1)) {
27146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27147 }
27148 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27149 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27150 if (!SWIG_IsOK(res2)) {
27151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27152 }
27153 if (!argp2) {
27154 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27155 }
27156 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27160 wxPyEndAllowThreads(__tstate);
27161 if (PyErr_Occurred()) SWIG_fail;
27162 }
27163 {
27164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27165 }
27166 return resultobj;
27167 fail:
27168 return NULL;
27169 }
27170
27171
27172 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27173 PyObject *resultobj = 0;
27174 wxDateTime *arg1 = (wxDateTime *) 0 ;
27175 wxDateTime *arg2 = 0 ;
27176 wxTimeSpan *arg3 = 0 ;
27177 bool result;
27178 void *argp1 = 0 ;
27179 int res1 = 0 ;
27180 void *argp2 = 0 ;
27181 int res2 = 0 ;
27182 void *argp3 = 0 ;
27183 int res3 = 0 ;
27184 PyObject * obj0 = 0 ;
27185 PyObject * obj1 = 0 ;
27186 PyObject * obj2 = 0 ;
27187 char * kwnames[] = {
27188 (char *) "self",(char *) "dt",(char *) "ts", NULL
27189 };
27190
27191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27193 if (!SWIG_IsOK(res1)) {
27194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27195 }
27196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27197 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27198 if (!SWIG_IsOK(res2)) {
27199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27200 }
27201 if (!argp2) {
27202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27203 }
27204 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27205 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27206 if (!SWIG_IsOK(res3)) {
27207 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27208 }
27209 if (!argp3) {
27210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27211 }
27212 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27216 wxPyEndAllowThreads(__tstate);
27217 if (PyErr_Occurred()) SWIG_fail;
27218 }
27219 {
27220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27221 }
27222 return resultobj;
27223 fail:
27224 return NULL;
27225 }
27226
27227
27228 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27229 PyObject *resultobj = 0;
27230 wxDateTime *arg1 = (wxDateTime *) 0 ;
27231 wxTimeSpan *arg2 = 0 ;
27232 wxDateTime *result = 0 ;
27233 void *argp1 = 0 ;
27234 int res1 = 0 ;
27235 void *argp2 = 0 ;
27236 int res2 = 0 ;
27237 PyObject * obj0 = 0 ;
27238 PyObject * obj1 = 0 ;
27239 char * kwnames[] = {
27240 (char *) "self",(char *) "diff", NULL
27241 };
27242
27243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27245 if (!SWIG_IsOK(res1)) {
27246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27247 }
27248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27249 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27250 if (!SWIG_IsOK(res2)) {
27251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27252 }
27253 if (!argp2) {
27254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27255 }
27256 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 {
27260 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27261 result = (wxDateTime *) &_result_ref;
27262 }
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27267 return resultobj;
27268 fail:
27269 return NULL;
27270 }
27271
27272
27273 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27274 PyObject *resultobj = 0;
27275 wxDateTime *arg1 = (wxDateTime *) 0 ;
27276 wxDateSpan *arg2 = 0 ;
27277 wxDateTime *result = 0 ;
27278 void *argp1 = 0 ;
27279 int res1 = 0 ;
27280 void *argp2 = 0 ;
27281 int res2 = 0 ;
27282 PyObject * obj0 = 0 ;
27283 PyObject * obj1 = 0 ;
27284 char * kwnames[] = {
27285 (char *) "self",(char *) "diff", NULL
27286 };
27287
27288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27290 if (!SWIG_IsOK(res1)) {
27291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27292 }
27293 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27294 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27295 if (!SWIG_IsOK(res2)) {
27296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27297 }
27298 if (!argp2) {
27299 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27300 }
27301 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27302 {
27303 PyThreadState* __tstate = wxPyBeginAllowThreads();
27304 {
27305 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27306 result = (wxDateTime *) &_result_ref;
27307 }
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27312 return resultobj;
27313 fail:
27314 return NULL;
27315 }
27316
27317
27318 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27319 PyObject *resultobj = 0;
27320 wxDateTime *arg1 = (wxDateTime *) 0 ;
27321 wxTimeSpan *arg2 = 0 ;
27322 wxDateTime *result = 0 ;
27323 void *argp1 = 0 ;
27324 int res1 = 0 ;
27325 void *argp2 = 0 ;
27326 int res2 = 0 ;
27327 PyObject * obj0 = 0 ;
27328 PyObject * obj1 = 0 ;
27329 char * kwnames[] = {
27330 (char *) "self",(char *) "diff", NULL
27331 };
27332
27333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27335 if (!SWIG_IsOK(res1)) {
27336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27337 }
27338 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27339 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27340 if (!SWIG_IsOK(res2)) {
27341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27342 }
27343 if (!argp2) {
27344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27345 }
27346 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 {
27350 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27351 result = (wxDateTime *) &_result_ref;
27352 }
27353 wxPyEndAllowThreads(__tstate);
27354 if (PyErr_Occurred()) SWIG_fail;
27355 }
27356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27357 return resultobj;
27358 fail:
27359 return NULL;
27360 }
27361
27362
27363 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27364 PyObject *resultobj = 0;
27365 wxDateTime *arg1 = (wxDateTime *) 0 ;
27366 wxDateSpan *arg2 = 0 ;
27367 wxDateTime *result = 0 ;
27368 void *argp1 = 0 ;
27369 int res1 = 0 ;
27370 void *argp2 = 0 ;
27371 int res2 = 0 ;
27372 PyObject * obj0 = 0 ;
27373 PyObject * obj1 = 0 ;
27374 char * kwnames[] = {
27375 (char *) "self",(char *) "diff", NULL
27376 };
27377
27378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27380 if (!SWIG_IsOK(res1)) {
27381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27382 }
27383 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27384 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27385 if (!SWIG_IsOK(res2)) {
27386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27387 }
27388 if (!argp2) {
27389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27390 }
27391 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27392 {
27393 PyThreadState* __tstate = wxPyBeginAllowThreads();
27394 {
27395 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27396 result = (wxDateTime *) &_result_ref;
27397 }
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27402 return resultobj;
27403 fail:
27404 return NULL;
27405 }
27406
27407
27408 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27409 PyObject *resultobj = 0;
27410 wxDateTime *arg1 = (wxDateTime *) 0 ;
27411 wxDateTime *arg2 = 0 ;
27412 wxTimeSpan result;
27413 void *argp1 = 0 ;
27414 int res1 = 0 ;
27415 void *argp2 = 0 ;
27416 int res2 = 0 ;
27417 PyObject * obj0 = 0 ;
27418 PyObject * obj1 = 0 ;
27419 char * kwnames[] = {
27420 (char *) "self",(char *) "dt", NULL
27421 };
27422
27423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27425 if (!SWIG_IsOK(res1)) {
27426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27427 }
27428 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27429 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27430 if (!SWIG_IsOK(res2)) {
27431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27432 }
27433 if (!argp2) {
27434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27435 }
27436 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27437 {
27438 PyThreadState* __tstate = wxPyBeginAllowThreads();
27439 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27440 wxPyEndAllowThreads(__tstate);
27441 if (PyErr_Occurred()) SWIG_fail;
27442 }
27443 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27444 return resultobj;
27445 fail:
27446 return NULL;
27447 }
27448
27449
27450 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27451 PyObject *resultobj = 0;
27452 wxDateTime *arg1 = (wxDateTime *) 0 ;
27453 wxTimeSpan *arg2 = 0 ;
27454 wxDateTime *result = 0 ;
27455 void *argp1 = 0 ;
27456 int res1 = 0 ;
27457 void *argp2 = 0 ;
27458 int res2 = 0 ;
27459
27460 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27462 if (!SWIG_IsOK(res1)) {
27463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27464 }
27465 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27466 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27467 if (!SWIG_IsOK(res2)) {
27468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27469 }
27470 if (!argp2) {
27471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27472 }
27473 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27474 {
27475 PyThreadState* __tstate = wxPyBeginAllowThreads();
27476 {
27477 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27478 result = (wxDateTime *) &_result_ref;
27479 }
27480 wxPyEndAllowThreads(__tstate);
27481 if (PyErr_Occurred()) SWIG_fail;
27482 }
27483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27484 return resultobj;
27485 fail:
27486 return NULL;
27487 }
27488
27489
27490 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27491 PyObject *resultobj = 0;
27492 wxDateTime *arg1 = (wxDateTime *) 0 ;
27493 wxDateSpan *arg2 = 0 ;
27494 wxDateTime *result = 0 ;
27495 void *argp1 = 0 ;
27496 int res1 = 0 ;
27497 void *argp2 = 0 ;
27498 int res2 = 0 ;
27499
27500 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27502 if (!SWIG_IsOK(res1)) {
27503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27504 }
27505 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27506 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27507 if (!SWIG_IsOK(res2)) {
27508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27509 }
27510 if (!argp2) {
27511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27512 }
27513 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 {
27517 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27518 result = (wxDateTime *) &_result_ref;
27519 }
27520 wxPyEndAllowThreads(__tstate);
27521 if (PyErr_Occurred()) SWIG_fail;
27522 }
27523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27524 return resultobj;
27525 fail:
27526 return NULL;
27527 }
27528
27529
27530 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27531 int argc;
27532 PyObject *argv[3];
27533
27534 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27535 --argc;
27536 if (argc == 2) {
27537 int _v = 0;
27538 {
27539 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27540 _v = SWIG_CheckState(res);
27541 }
27542 if (!_v) goto check_1;
27543 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27544 }
27545 check_1:
27546
27547 if (argc == 2) {
27548 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27549 }
27550
27551 fail:
27552 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27553 return NULL;
27554 }
27555
27556
27557 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27558 PyObject *resultobj = 0;
27559 wxDateTime *arg1 = (wxDateTime *) 0 ;
27560 wxTimeSpan *arg2 = 0 ;
27561 wxDateTime *result = 0 ;
27562 void *argp1 = 0 ;
27563 int res1 = 0 ;
27564 void *argp2 = 0 ;
27565 int res2 = 0 ;
27566
27567 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27569 if (!SWIG_IsOK(res1)) {
27570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27571 }
27572 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27573 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27574 if (!SWIG_IsOK(res2)) {
27575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27576 }
27577 if (!argp2) {
27578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27579 }
27580 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 {
27584 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27585 result = (wxDateTime *) &_result_ref;
27586 }
27587 wxPyEndAllowThreads(__tstate);
27588 if (PyErr_Occurred()) SWIG_fail;
27589 }
27590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27598 PyObject *resultobj = 0;
27599 wxDateTime *arg1 = (wxDateTime *) 0 ;
27600 wxDateSpan *arg2 = 0 ;
27601 wxDateTime *result = 0 ;
27602 void *argp1 = 0 ;
27603 int res1 = 0 ;
27604 void *argp2 = 0 ;
27605 int res2 = 0 ;
27606
27607 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27609 if (!SWIG_IsOK(res1)) {
27610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27611 }
27612 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27613 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27614 if (!SWIG_IsOK(res2)) {
27615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27616 }
27617 if (!argp2) {
27618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27619 }
27620 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27621 {
27622 PyThreadState* __tstate = wxPyBeginAllowThreads();
27623 {
27624 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27625 result = (wxDateTime *) &_result_ref;
27626 }
27627 wxPyEndAllowThreads(__tstate);
27628 if (PyErr_Occurred()) SWIG_fail;
27629 }
27630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27631 return resultobj;
27632 fail:
27633 return NULL;
27634 }
27635
27636
27637 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27638 int argc;
27639 PyObject *argv[3];
27640
27641 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27642 --argc;
27643 if (argc == 2) {
27644 int _v = 0;
27645 {
27646 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27647 _v = SWIG_CheckState(res);
27648 }
27649 if (!_v) goto check_1;
27650 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27651 }
27652 check_1:
27653
27654 if (argc == 2) {
27655 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27656 }
27657
27658 fail:
27659 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27660 return NULL;
27661 }
27662
27663
27664 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27665 PyObject *resultobj = 0;
27666 wxDateTime *arg1 = (wxDateTime *) 0 ;
27667 wxTimeSpan *arg2 = 0 ;
27668 wxDateTime result;
27669 void *argp1 = 0 ;
27670 int res1 = 0 ;
27671 void *argp2 = 0 ;
27672 int res2 = 0 ;
27673
27674 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27676 if (!SWIG_IsOK(res1)) {
27677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27678 }
27679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27680 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27681 if (!SWIG_IsOK(res2)) {
27682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27683 }
27684 if (!argp2) {
27685 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27686 }
27687 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27695 return resultobj;
27696 fail:
27697 return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27702 PyObject *resultobj = 0;
27703 wxDateTime *arg1 = (wxDateTime *) 0 ;
27704 wxDateSpan *arg2 = 0 ;
27705 wxDateTime result;
27706 void *argp1 = 0 ;
27707 int res1 = 0 ;
27708 void *argp2 = 0 ;
27709 int res2 = 0 ;
27710
27711 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27713 if (!SWIG_IsOK(res1)) {
27714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27715 }
27716 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27717 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27718 if (!SWIG_IsOK(res2)) {
27719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27720 }
27721 if (!argp2) {
27722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27723 }
27724 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27728 wxPyEndAllowThreads(__tstate);
27729 if (PyErr_Occurred()) SWIG_fail;
27730 }
27731 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27739 int argc;
27740 PyObject *argv[3];
27741
27742 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27743 --argc;
27744 if (argc == 2) {
27745 int _v = 0;
27746 {
27747 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27748 _v = SWIG_CheckState(res);
27749 }
27750 if (!_v) goto check_1;
27751 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27752 }
27753 check_1:
27754
27755 if (argc == 2) {
27756 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27757 }
27758
27759 fail:
27760 Py_INCREF(Py_NotImplemented);
27761 return Py_NotImplemented;
27762 }
27763
27764
27765 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27766 PyObject *resultobj = 0;
27767 wxDateTime *arg1 = (wxDateTime *) 0 ;
27768 wxDateTime *arg2 = 0 ;
27769 wxTimeSpan result;
27770 void *argp1 = 0 ;
27771 int res1 = 0 ;
27772 void *argp2 = 0 ;
27773 int res2 = 0 ;
27774
27775 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27777 if (!SWIG_IsOK(res1)) {
27778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27779 }
27780 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27781 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27782 if (!SWIG_IsOK(res2)) {
27783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27784 }
27785 if (!argp2) {
27786 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27787 }
27788 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27789 {
27790 PyThreadState* __tstate = wxPyBeginAllowThreads();
27791 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27792 wxPyEndAllowThreads(__tstate);
27793 if (PyErr_Occurred()) SWIG_fail;
27794 }
27795 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27803 PyObject *resultobj = 0;
27804 wxDateTime *arg1 = (wxDateTime *) 0 ;
27805 wxTimeSpan *arg2 = 0 ;
27806 wxDateTime result;
27807 void *argp1 = 0 ;
27808 int res1 = 0 ;
27809 void *argp2 = 0 ;
27810 int res2 = 0 ;
27811
27812 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27814 if (!SWIG_IsOK(res1)) {
27815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27816 }
27817 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27818 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27819 if (!SWIG_IsOK(res2)) {
27820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27821 }
27822 if (!argp2) {
27823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27824 }
27825 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27826 {
27827 PyThreadState* __tstate = wxPyBeginAllowThreads();
27828 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27829 wxPyEndAllowThreads(__tstate);
27830 if (PyErr_Occurred()) SWIG_fail;
27831 }
27832 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27833 return resultobj;
27834 fail:
27835 return NULL;
27836 }
27837
27838
27839 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27840 PyObject *resultobj = 0;
27841 wxDateTime *arg1 = (wxDateTime *) 0 ;
27842 wxDateSpan *arg2 = 0 ;
27843 wxDateTime result;
27844 void *argp1 = 0 ;
27845 int res1 = 0 ;
27846 void *argp2 = 0 ;
27847 int res2 = 0 ;
27848
27849 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27851 if (!SWIG_IsOK(res1)) {
27852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27853 }
27854 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27855 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27856 if (!SWIG_IsOK(res2)) {
27857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27858 }
27859 if (!argp2) {
27860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27861 }
27862 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27863 {
27864 PyThreadState* __tstate = wxPyBeginAllowThreads();
27865 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27866 wxPyEndAllowThreads(__tstate);
27867 if (PyErr_Occurred()) SWIG_fail;
27868 }
27869 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27877 int argc;
27878 PyObject *argv[3];
27879
27880 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27881 --argc;
27882 if (argc == 2) {
27883 int _v = 0;
27884 {
27885 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27886 _v = SWIG_CheckState(res);
27887 }
27888 if (!_v) goto check_1;
27889 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27890 }
27891 check_1:
27892
27893 if (argc == 2) {
27894 int _v = 0;
27895 {
27896 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27897 _v = SWIG_CheckState(res);
27898 }
27899 if (!_v) goto check_2;
27900 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27901 }
27902 check_2:
27903
27904 if (argc == 2) {
27905 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27906 }
27907
27908 fail:
27909 Py_INCREF(Py_NotImplemented);
27910 return Py_NotImplemented;
27911 }
27912
27913
27914 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27915 PyObject *resultobj = 0;
27916 wxDateTime *arg1 = (wxDateTime *) 0 ;
27917 wxDateTime *arg2 = (wxDateTime *) 0 ;
27918 bool result;
27919 void *argp1 = 0 ;
27920 int res1 = 0 ;
27921 void *argp2 = 0 ;
27922 int res2 = 0 ;
27923 PyObject * obj0 = 0 ;
27924 PyObject * obj1 = 0 ;
27925 char * kwnames[] = {
27926 (char *) "self",(char *) "other", NULL
27927 };
27928
27929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27931 if (!SWIG_IsOK(res1)) {
27932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27933 }
27934 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27936 if (!SWIG_IsOK(res2)) {
27937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27938 }
27939 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27940 {
27941 PyThreadState* __tstate = wxPyBeginAllowThreads();
27942 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27943 wxPyEndAllowThreads(__tstate);
27944 if (PyErr_Occurred()) SWIG_fail;
27945 }
27946 {
27947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27948 }
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27956 PyObject *resultobj = 0;
27957 wxDateTime *arg1 = (wxDateTime *) 0 ;
27958 wxDateTime *arg2 = (wxDateTime *) 0 ;
27959 bool result;
27960 void *argp1 = 0 ;
27961 int res1 = 0 ;
27962 void *argp2 = 0 ;
27963 int res2 = 0 ;
27964 PyObject * obj0 = 0 ;
27965 PyObject * obj1 = 0 ;
27966 char * kwnames[] = {
27967 (char *) "self",(char *) "other", NULL
27968 };
27969
27970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27972 if (!SWIG_IsOK(res1)) {
27973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27974 }
27975 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27977 if (!SWIG_IsOK(res2)) {
27978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27979 }
27980 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27981 {
27982 PyThreadState* __tstate = wxPyBeginAllowThreads();
27983 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27984 wxPyEndAllowThreads(__tstate);
27985 if (PyErr_Occurred()) SWIG_fail;
27986 }
27987 {
27988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27989 }
27990 return resultobj;
27991 fail:
27992 return NULL;
27993 }
27994
27995
27996 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27997 PyObject *resultobj = 0;
27998 wxDateTime *arg1 = (wxDateTime *) 0 ;
27999 wxDateTime *arg2 = (wxDateTime *) 0 ;
28000 bool result;
28001 void *argp1 = 0 ;
28002 int res1 = 0 ;
28003 void *argp2 = 0 ;
28004 int res2 = 0 ;
28005 PyObject * obj0 = 0 ;
28006 PyObject * obj1 = 0 ;
28007 char * kwnames[] = {
28008 (char *) "self",(char *) "other", NULL
28009 };
28010
28011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28013 if (!SWIG_IsOK(res1)) {
28014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28015 }
28016 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28017 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28018 if (!SWIG_IsOK(res2)) {
28019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28020 }
28021 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 {
28029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28030 }
28031 return resultobj;
28032 fail:
28033 return NULL;
28034 }
28035
28036
28037 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28038 PyObject *resultobj = 0;
28039 wxDateTime *arg1 = (wxDateTime *) 0 ;
28040 wxDateTime *arg2 = (wxDateTime *) 0 ;
28041 bool result;
28042 void *argp1 = 0 ;
28043 int res1 = 0 ;
28044 void *argp2 = 0 ;
28045 int res2 = 0 ;
28046 PyObject * obj0 = 0 ;
28047 PyObject * obj1 = 0 ;
28048 char * kwnames[] = {
28049 (char *) "self",(char *) "other", NULL
28050 };
28051
28052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28054 if (!SWIG_IsOK(res1)) {
28055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28056 }
28057 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28058 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28059 if (!SWIG_IsOK(res2)) {
28060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28061 }
28062 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28063 {
28064 PyThreadState* __tstate = wxPyBeginAllowThreads();
28065 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28066 wxPyEndAllowThreads(__tstate);
28067 if (PyErr_Occurred()) SWIG_fail;
28068 }
28069 {
28070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28071 }
28072 return resultobj;
28073 fail:
28074 return NULL;
28075 }
28076
28077
28078 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28079 PyObject *resultobj = 0;
28080 wxDateTime *arg1 = (wxDateTime *) 0 ;
28081 wxDateTime *arg2 = (wxDateTime *) 0 ;
28082 bool result;
28083 void *argp1 = 0 ;
28084 int res1 = 0 ;
28085 void *argp2 = 0 ;
28086 int res2 = 0 ;
28087 PyObject * obj0 = 0 ;
28088 PyObject * obj1 = 0 ;
28089 char * kwnames[] = {
28090 (char *) "self",(char *) "other", NULL
28091 };
28092
28093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28095 if (!SWIG_IsOK(res1)) {
28096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28097 }
28098 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28099 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28100 if (!SWIG_IsOK(res2)) {
28101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28102 }
28103 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 {
28111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28112 }
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj = 0;
28121 wxDateTime *arg1 = (wxDateTime *) 0 ;
28122 wxDateTime *arg2 = (wxDateTime *) 0 ;
28123 bool result;
28124 void *argp1 = 0 ;
28125 int res1 = 0 ;
28126 void *argp2 = 0 ;
28127 int res2 = 0 ;
28128 PyObject * obj0 = 0 ;
28129 PyObject * obj1 = 0 ;
28130 char * kwnames[] = {
28131 (char *) "self",(char *) "other", NULL
28132 };
28133
28134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28136 if (!SWIG_IsOK(res1)) {
28137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28138 }
28139 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28141 if (!SWIG_IsOK(res2)) {
28142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28143 }
28144 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 {
28152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28153 }
28154 return resultobj;
28155 fail:
28156 return NULL;
28157 }
28158
28159
28160 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28161 PyObject *resultobj = 0;
28162 wxDateTime *arg1 = (wxDateTime *) 0 ;
28163 wxString *arg2 = 0 ;
28164 int result;
28165 void *argp1 = 0 ;
28166 int res1 = 0 ;
28167 bool temp2 = false ;
28168 PyObject * obj0 = 0 ;
28169 PyObject * obj1 = 0 ;
28170 char * kwnames[] = {
28171 (char *) "self",(char *) "date", NULL
28172 };
28173
28174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28176 if (!SWIG_IsOK(res1)) {
28177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28178 }
28179 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28180 {
28181 arg2 = wxString_in_helper(obj1);
28182 if (arg2 == NULL) SWIG_fail;
28183 temp2 = true;
28184 }
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28188 wxPyEndAllowThreads(__tstate);
28189 if (PyErr_Occurred()) SWIG_fail;
28190 }
28191 resultobj = SWIG_From_int(static_cast< int >(result));
28192 {
28193 if (temp2)
28194 delete arg2;
28195 }
28196 return resultobj;
28197 fail:
28198 {
28199 if (temp2)
28200 delete arg2;
28201 }
28202 return NULL;
28203 }
28204
28205
28206 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28207 PyObject *resultobj = 0;
28208 wxDateTime *arg1 = (wxDateTime *) 0 ;
28209 wxString *arg2 = 0 ;
28210 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28211 wxString *arg3 = (wxString *) &arg3_defvalue ;
28212 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28213 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28214 int result;
28215 void *argp1 = 0 ;
28216 int res1 = 0 ;
28217 bool temp2 = false ;
28218 bool temp3 = false ;
28219 void *argp4 = 0 ;
28220 int res4 = 0 ;
28221 PyObject * obj0 = 0 ;
28222 PyObject * obj1 = 0 ;
28223 PyObject * obj2 = 0 ;
28224 PyObject * obj3 = 0 ;
28225 char * kwnames[] = {
28226 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28227 };
28228
28229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28231 if (!SWIG_IsOK(res1)) {
28232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28233 }
28234 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28235 {
28236 arg2 = wxString_in_helper(obj1);
28237 if (arg2 == NULL) SWIG_fail;
28238 temp2 = true;
28239 }
28240 if (obj2) {
28241 {
28242 arg3 = wxString_in_helper(obj2);
28243 if (arg3 == NULL) SWIG_fail;
28244 temp3 = true;
28245 }
28246 }
28247 if (obj3) {
28248 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28249 if (!SWIG_IsOK(res4)) {
28250 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28251 }
28252 if (!argp4) {
28253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28254 }
28255 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28256 }
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 resultobj = SWIG_From_int(static_cast< int >(result));
28264 {
28265 if (temp2)
28266 delete arg2;
28267 }
28268 {
28269 if (temp3)
28270 delete arg3;
28271 }
28272 return resultobj;
28273 fail:
28274 {
28275 if (temp2)
28276 delete arg2;
28277 }
28278 {
28279 if (temp3)
28280 delete arg3;
28281 }
28282 return NULL;
28283 }
28284
28285
28286 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28287 PyObject *resultobj = 0;
28288 wxDateTime *arg1 = (wxDateTime *) 0 ;
28289 wxString *arg2 = 0 ;
28290 int result;
28291 void *argp1 = 0 ;
28292 int res1 = 0 ;
28293 bool temp2 = false ;
28294 PyObject * obj0 = 0 ;
28295 PyObject * obj1 = 0 ;
28296 char * kwnames[] = {
28297 (char *) "self",(char *) "datetime", NULL
28298 };
28299
28300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28302 if (!SWIG_IsOK(res1)) {
28303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28304 }
28305 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28306 {
28307 arg2 = wxString_in_helper(obj1);
28308 if (arg2 == NULL) SWIG_fail;
28309 temp2 = true;
28310 }
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_From_int(static_cast< int >(result));
28318 {
28319 if (temp2)
28320 delete arg2;
28321 }
28322 return resultobj;
28323 fail:
28324 {
28325 if (temp2)
28326 delete arg2;
28327 }
28328 return NULL;
28329 }
28330
28331
28332 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj = 0;
28334 wxDateTime *arg1 = (wxDateTime *) 0 ;
28335 wxString *arg2 = 0 ;
28336 int result;
28337 void *argp1 = 0 ;
28338 int res1 = 0 ;
28339 bool temp2 = false ;
28340 PyObject * obj0 = 0 ;
28341 PyObject * obj1 = 0 ;
28342 char * kwnames[] = {
28343 (char *) "self",(char *) "date", NULL
28344 };
28345
28346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28348 if (!SWIG_IsOK(res1)) {
28349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28350 }
28351 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28352 {
28353 arg2 = wxString_in_helper(obj1);
28354 if (arg2 == NULL) SWIG_fail;
28355 temp2 = true;
28356 }
28357 {
28358 PyThreadState* __tstate = wxPyBeginAllowThreads();
28359 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 resultobj = SWIG_From_int(static_cast< int >(result));
28364 {
28365 if (temp2)
28366 delete arg2;
28367 }
28368 return resultobj;
28369 fail:
28370 {
28371 if (temp2)
28372 delete arg2;
28373 }
28374 return NULL;
28375 }
28376
28377
28378 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj = 0;
28380 wxDateTime *arg1 = (wxDateTime *) 0 ;
28381 wxString *arg2 = 0 ;
28382 int result;
28383 void *argp1 = 0 ;
28384 int res1 = 0 ;
28385 bool temp2 = false ;
28386 PyObject * obj0 = 0 ;
28387 PyObject * obj1 = 0 ;
28388 char * kwnames[] = {
28389 (char *) "self",(char *) "time", NULL
28390 };
28391
28392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28394 if (!SWIG_IsOK(res1)) {
28395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28396 }
28397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28398 {
28399 arg2 = wxString_in_helper(obj1);
28400 if (arg2 == NULL) SWIG_fail;
28401 temp2 = true;
28402 }
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 resultobj = SWIG_From_int(static_cast< int >(result));
28410 {
28411 if (temp2)
28412 delete arg2;
28413 }
28414 return resultobj;
28415 fail:
28416 {
28417 if (temp2)
28418 delete arg2;
28419 }
28420 return NULL;
28421 }
28422
28423
28424 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28425 PyObject *resultobj = 0;
28426 wxDateTime *arg1 = (wxDateTime *) 0 ;
28427 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28428 wxString *arg2 = (wxString *) &arg2_defvalue ;
28429 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28430 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28431 wxString result;
28432 void *argp1 = 0 ;
28433 int res1 = 0 ;
28434 bool temp2 = false ;
28435 bool temp3 = false ;
28436 PyObject * obj0 = 0 ;
28437 PyObject * obj1 = 0 ;
28438 PyObject * obj2 = 0 ;
28439 char * kwnames[] = {
28440 (char *) "self",(char *) "format",(char *) "tz", NULL
28441 };
28442
28443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28445 if (!SWIG_IsOK(res1)) {
28446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28447 }
28448 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28449 if (obj1) {
28450 {
28451 arg2 = wxString_in_helper(obj1);
28452 if (arg2 == NULL) SWIG_fail;
28453 temp2 = true;
28454 }
28455 }
28456 if (obj2) {
28457 {
28458 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28459 temp3 = true;
28460 }
28461 }
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 {
28469 #if wxUSE_UNICODE
28470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28471 #else
28472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28473 #endif
28474 }
28475 {
28476 if (temp2)
28477 delete arg2;
28478 }
28479 {
28480 if (temp3) delete arg3;
28481 }
28482 return resultobj;
28483 fail:
28484 {
28485 if (temp2)
28486 delete arg2;
28487 }
28488 {
28489 if (temp3) delete arg3;
28490 }
28491 return NULL;
28492 }
28493
28494
28495 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28496 PyObject *resultobj = 0;
28497 wxDateTime *arg1 = (wxDateTime *) 0 ;
28498 wxString result;
28499 void *argp1 = 0 ;
28500 int res1 = 0 ;
28501 PyObject *swig_obj[1] ;
28502
28503 if (!args) SWIG_fail;
28504 swig_obj[0] = args;
28505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28506 if (!SWIG_IsOK(res1)) {
28507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28508 }
28509 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28510 {
28511 PyThreadState* __tstate = wxPyBeginAllowThreads();
28512 result = ((wxDateTime const *)arg1)->FormatDate();
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 {
28517 #if wxUSE_UNICODE
28518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28519 #else
28520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28521 #endif
28522 }
28523 return resultobj;
28524 fail:
28525 return NULL;
28526 }
28527
28528
28529 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28530 PyObject *resultobj = 0;
28531 wxDateTime *arg1 = (wxDateTime *) 0 ;
28532 wxString result;
28533 void *argp1 = 0 ;
28534 int res1 = 0 ;
28535 PyObject *swig_obj[1] ;
28536
28537 if (!args) SWIG_fail;
28538 swig_obj[0] = args;
28539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28540 if (!SWIG_IsOK(res1)) {
28541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28542 }
28543 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28544 {
28545 PyThreadState* __tstate = wxPyBeginAllowThreads();
28546 result = ((wxDateTime const *)arg1)->FormatTime();
28547 wxPyEndAllowThreads(__tstate);
28548 if (PyErr_Occurred()) SWIG_fail;
28549 }
28550 {
28551 #if wxUSE_UNICODE
28552 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28553 #else
28554 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28555 #endif
28556 }
28557 return resultobj;
28558 fail:
28559 return NULL;
28560 }
28561
28562
28563 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28564 PyObject *resultobj = 0;
28565 wxDateTime *arg1 = (wxDateTime *) 0 ;
28566 wxString result;
28567 void *argp1 = 0 ;
28568 int res1 = 0 ;
28569 PyObject *swig_obj[1] ;
28570
28571 if (!args) SWIG_fail;
28572 swig_obj[0] = args;
28573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28574 if (!SWIG_IsOK(res1)) {
28575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28576 }
28577 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 result = ((wxDateTime const *)arg1)->FormatISODate();
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 {
28585 #if wxUSE_UNICODE
28586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28587 #else
28588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28589 #endif
28590 }
28591 return resultobj;
28592 fail:
28593 return NULL;
28594 }
28595
28596
28597 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28598 PyObject *resultobj = 0;
28599 wxDateTime *arg1 = (wxDateTime *) 0 ;
28600 wxString result;
28601 void *argp1 = 0 ;
28602 int res1 = 0 ;
28603 PyObject *swig_obj[1] ;
28604
28605 if (!args) SWIG_fail;
28606 swig_obj[0] = args;
28607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28608 if (!SWIG_IsOK(res1)) {
28609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28610 }
28611 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 result = ((wxDateTime const *)arg1)->FormatISOTime();
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 {
28619 #if wxUSE_UNICODE
28620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28621 #else
28622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28623 #endif
28624 }
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *obj;
28633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28634 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28635 return SWIG_Py_Void();
28636 }
28637
28638 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28639 return SWIG_Python_InitShadowInstance(args);
28640 }
28641
28642 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj = 0;
28644 long arg1 ;
28645 wxTimeSpan result;
28646 long val1 ;
28647 int ecode1 = 0 ;
28648 PyObject * obj0 = 0 ;
28649 char * kwnames[] = {
28650 (char *) "ms", NULL
28651 };
28652
28653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28654 ecode1 = SWIG_AsVal_long(obj0, &val1);
28655 if (!SWIG_IsOK(ecode1)) {
28656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28657 }
28658 arg1 = static_cast< long >(val1);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = wxTimeSpan::Milliseconds(arg1);
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28673 PyObject *resultobj = 0;
28674 wxTimeSpan result;
28675
28676 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 result = wxTimeSpan::Millisecond();
28680 wxPyEndAllowThreads(__tstate);
28681 if (PyErr_Occurred()) SWIG_fail;
28682 }
28683 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28684 return resultobj;
28685 fail:
28686 return NULL;
28687 }
28688
28689
28690 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28691 PyObject *resultobj = 0;
28692 long arg1 ;
28693 wxTimeSpan result;
28694 long val1 ;
28695 int ecode1 = 0 ;
28696 PyObject * obj0 = 0 ;
28697 char * kwnames[] = {
28698 (char *) "sec", NULL
28699 };
28700
28701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28702 ecode1 = SWIG_AsVal_long(obj0, &val1);
28703 if (!SWIG_IsOK(ecode1)) {
28704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28705 }
28706 arg1 = static_cast< long >(val1);
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 result = wxTimeSpan::Seconds(arg1);
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28721 PyObject *resultobj = 0;
28722 wxTimeSpan result;
28723
28724 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 result = wxTimeSpan::Second();
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj = 0;
28740 long arg1 ;
28741 wxTimeSpan result;
28742 long val1 ;
28743 int ecode1 = 0 ;
28744 PyObject * obj0 = 0 ;
28745 char * kwnames[] = {
28746 (char *) "min", NULL
28747 };
28748
28749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28750 ecode1 = SWIG_AsVal_long(obj0, &val1);
28751 if (!SWIG_IsOK(ecode1)) {
28752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28753 }
28754 arg1 = static_cast< long >(val1);
28755 {
28756 PyThreadState* __tstate = wxPyBeginAllowThreads();
28757 result = wxTimeSpan::Minutes(arg1);
28758 wxPyEndAllowThreads(__tstate);
28759 if (PyErr_Occurred()) SWIG_fail;
28760 }
28761 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28762 return resultobj;
28763 fail:
28764 return NULL;
28765 }
28766
28767
28768 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28769 PyObject *resultobj = 0;
28770 wxTimeSpan result;
28771
28772 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = wxTimeSpan::Minute();
28776 wxPyEndAllowThreads(__tstate);
28777 if (PyErr_Occurred()) SWIG_fail;
28778 }
28779 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28780 return resultobj;
28781 fail:
28782 return NULL;
28783 }
28784
28785
28786 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28787 PyObject *resultobj = 0;
28788 long arg1 ;
28789 wxTimeSpan result;
28790 long val1 ;
28791 int ecode1 = 0 ;
28792 PyObject * obj0 = 0 ;
28793 char * kwnames[] = {
28794 (char *) "hours", NULL
28795 };
28796
28797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28798 ecode1 = SWIG_AsVal_long(obj0, &val1);
28799 if (!SWIG_IsOK(ecode1)) {
28800 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28801 }
28802 arg1 = static_cast< long >(val1);
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 result = wxTimeSpan::Hours(arg1);
28806 wxPyEndAllowThreads(__tstate);
28807 if (PyErr_Occurred()) SWIG_fail;
28808 }
28809 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28810 return resultobj;
28811 fail:
28812 return NULL;
28813 }
28814
28815
28816 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28817 PyObject *resultobj = 0;
28818 wxTimeSpan result;
28819
28820 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 result = wxTimeSpan::Hour();
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28828 return resultobj;
28829 fail:
28830 return NULL;
28831 }
28832
28833
28834 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28835 PyObject *resultobj = 0;
28836 long arg1 ;
28837 wxTimeSpan result;
28838 long val1 ;
28839 int ecode1 = 0 ;
28840 PyObject * obj0 = 0 ;
28841 char * kwnames[] = {
28842 (char *) "days", NULL
28843 };
28844
28845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28846 ecode1 = SWIG_AsVal_long(obj0, &val1);
28847 if (!SWIG_IsOK(ecode1)) {
28848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28849 }
28850 arg1 = static_cast< long >(val1);
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 result = wxTimeSpan::Days(arg1);
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28865 PyObject *resultobj = 0;
28866 wxTimeSpan result;
28867
28868 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 result = wxTimeSpan::Day();
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj = 0;
28884 long arg1 ;
28885 wxTimeSpan result;
28886 long val1 ;
28887 int ecode1 = 0 ;
28888 PyObject * obj0 = 0 ;
28889 char * kwnames[] = {
28890 (char *) "days", NULL
28891 };
28892
28893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28894 ecode1 = SWIG_AsVal_long(obj0, &val1);
28895 if (!SWIG_IsOK(ecode1)) {
28896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28897 }
28898 arg1 = static_cast< long >(val1);
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 result = wxTimeSpan::Weeks(arg1);
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28906 return resultobj;
28907 fail:
28908 return NULL;
28909 }
28910
28911
28912 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28913 PyObject *resultobj = 0;
28914 wxTimeSpan result;
28915
28916 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = wxTimeSpan::Week();
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28924 return resultobj;
28925 fail:
28926 return NULL;
28927 }
28928
28929
28930 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28931 PyObject *resultobj = 0;
28932 long arg1 = (long) 0 ;
28933 long arg2 = (long) 0 ;
28934 long arg3 = (long) 0 ;
28935 long arg4 = (long) 0 ;
28936 wxTimeSpan *result = 0 ;
28937 long val1 ;
28938 int ecode1 = 0 ;
28939 long val2 ;
28940 int ecode2 = 0 ;
28941 long val3 ;
28942 int ecode3 = 0 ;
28943 long val4 ;
28944 int ecode4 = 0 ;
28945 PyObject * obj0 = 0 ;
28946 PyObject * obj1 = 0 ;
28947 PyObject * obj2 = 0 ;
28948 PyObject * obj3 = 0 ;
28949 char * kwnames[] = {
28950 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28951 };
28952
28953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28954 if (obj0) {
28955 ecode1 = SWIG_AsVal_long(obj0, &val1);
28956 if (!SWIG_IsOK(ecode1)) {
28957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28958 }
28959 arg1 = static_cast< long >(val1);
28960 }
28961 if (obj1) {
28962 ecode2 = SWIG_AsVal_long(obj1, &val2);
28963 if (!SWIG_IsOK(ecode2)) {
28964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28965 }
28966 arg2 = static_cast< long >(val2);
28967 }
28968 if (obj2) {
28969 ecode3 = SWIG_AsVal_long(obj2, &val3);
28970 if (!SWIG_IsOK(ecode3)) {
28971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28972 }
28973 arg3 = static_cast< long >(val3);
28974 }
28975 if (obj3) {
28976 ecode4 = SWIG_AsVal_long(obj3, &val4);
28977 if (!SWIG_IsOK(ecode4)) {
28978 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28979 }
28980 arg4 = static_cast< long >(val4);
28981 }
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28996 PyObject *resultobj = 0;
28997 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28998 void *argp1 = 0 ;
28999 int res1 = 0 ;
29000 PyObject *swig_obj[1] ;
29001
29002 if (!args) SWIG_fail;
29003 swig_obj[0] = args;
29004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29005 if (!SWIG_IsOK(res1)) {
29006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29007 }
29008 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29009 {
29010 PyThreadState* __tstate = wxPyBeginAllowThreads();
29011 delete arg1;
29012
29013 wxPyEndAllowThreads(__tstate);
29014 if (PyErr_Occurred()) SWIG_fail;
29015 }
29016 resultobj = SWIG_Py_Void();
29017 return resultobj;
29018 fail:
29019 return NULL;
29020 }
29021
29022
29023 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29024 PyObject *resultobj = 0;
29025 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29026 wxTimeSpan *arg2 = 0 ;
29027 wxTimeSpan *result = 0 ;
29028 void *argp1 = 0 ;
29029 int res1 = 0 ;
29030 void *argp2 = 0 ;
29031 int res2 = 0 ;
29032 PyObject * obj0 = 0 ;
29033 PyObject * obj1 = 0 ;
29034 char * kwnames[] = {
29035 (char *) "self",(char *) "diff", NULL
29036 };
29037
29038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29040 if (!SWIG_IsOK(res1)) {
29041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29042 }
29043 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29044 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29045 if (!SWIG_IsOK(res2)) {
29046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29047 }
29048 if (!argp2) {
29049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29050 }
29051 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 {
29055 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29056 result = (wxTimeSpan *) &_result_ref;
29057 }
29058 wxPyEndAllowThreads(__tstate);
29059 if (PyErr_Occurred()) SWIG_fail;
29060 }
29061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29069 PyObject *resultobj = 0;
29070 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29071 wxTimeSpan *arg2 = 0 ;
29072 wxTimeSpan *result = 0 ;
29073 void *argp1 = 0 ;
29074 int res1 = 0 ;
29075 void *argp2 = 0 ;
29076 int res2 = 0 ;
29077 PyObject * obj0 = 0 ;
29078 PyObject * obj1 = 0 ;
29079 char * kwnames[] = {
29080 (char *) "self",(char *) "diff", NULL
29081 };
29082
29083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29085 if (!SWIG_IsOK(res1)) {
29086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29087 }
29088 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29089 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29090 if (!SWIG_IsOK(res2)) {
29091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29092 }
29093 if (!argp2) {
29094 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29095 }
29096 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29097 {
29098 PyThreadState* __tstate = wxPyBeginAllowThreads();
29099 {
29100 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29101 result = (wxTimeSpan *) &_result_ref;
29102 }
29103 wxPyEndAllowThreads(__tstate);
29104 if (PyErr_Occurred()) SWIG_fail;
29105 }
29106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29114 PyObject *resultobj = 0;
29115 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29116 int arg2 ;
29117 wxTimeSpan *result = 0 ;
29118 void *argp1 = 0 ;
29119 int res1 = 0 ;
29120 int val2 ;
29121 int ecode2 = 0 ;
29122 PyObject * obj0 = 0 ;
29123 PyObject * obj1 = 0 ;
29124 char * kwnames[] = {
29125 (char *) "self",(char *) "n", NULL
29126 };
29127
29128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29130 if (!SWIG_IsOK(res1)) {
29131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29132 }
29133 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29134 ecode2 = SWIG_AsVal_int(obj1, &val2);
29135 if (!SWIG_IsOK(ecode2)) {
29136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29137 }
29138 arg2 = static_cast< int >(val2);
29139 {
29140 PyThreadState* __tstate = wxPyBeginAllowThreads();
29141 {
29142 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29143 result = (wxTimeSpan *) &_result_ref;
29144 }
29145 wxPyEndAllowThreads(__tstate);
29146 if (PyErr_Occurred()) SWIG_fail;
29147 }
29148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29149 return resultobj;
29150 fail:
29151 return NULL;
29152 }
29153
29154
29155 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29156 PyObject *resultobj = 0;
29157 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29158 wxTimeSpan *result = 0 ;
29159 void *argp1 = 0 ;
29160 int res1 = 0 ;
29161 PyObject *swig_obj[1] ;
29162
29163 if (!args) SWIG_fail;
29164 swig_obj[0] = args;
29165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29166 if (!SWIG_IsOK(res1)) {
29167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29168 }
29169 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 {
29173 wxTimeSpan &_result_ref = (arg1)->Neg();
29174 result = (wxTimeSpan *) &_result_ref;
29175 }
29176 wxPyEndAllowThreads(__tstate);
29177 if (PyErr_Occurred()) SWIG_fail;
29178 }
29179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29187 PyObject *resultobj = 0;
29188 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29189 wxTimeSpan result;
29190 void *argp1 = 0 ;
29191 int res1 = 0 ;
29192 PyObject *swig_obj[1] ;
29193
29194 if (!args) SWIG_fail;
29195 swig_obj[0] = args;
29196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29197 if (!SWIG_IsOK(res1)) {
29198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29199 }
29200 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29201 {
29202 PyThreadState* __tstate = wxPyBeginAllowThreads();
29203 result = ((wxTimeSpan const *)arg1)->Abs();
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29215 PyObject *resultobj = 0;
29216 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29217 wxTimeSpan *arg2 = 0 ;
29218 wxTimeSpan *result = 0 ;
29219 void *argp1 = 0 ;
29220 int res1 = 0 ;
29221 void *argp2 = 0 ;
29222 int res2 = 0 ;
29223 PyObject * obj0 = 0 ;
29224 PyObject * obj1 = 0 ;
29225 char * kwnames[] = {
29226 (char *) "self",(char *) "diff", NULL
29227 };
29228
29229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29231 if (!SWIG_IsOK(res1)) {
29232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29233 }
29234 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29236 if (!SWIG_IsOK(res2)) {
29237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29238 }
29239 if (!argp2) {
29240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29241 }
29242 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29243 {
29244 PyThreadState* __tstate = wxPyBeginAllowThreads();
29245 {
29246 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29247 result = (wxTimeSpan *) &_result_ref;
29248 }
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29260 PyObject *resultobj = 0;
29261 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29262 wxTimeSpan *arg2 = 0 ;
29263 wxTimeSpan *result = 0 ;
29264 void *argp1 = 0 ;
29265 int res1 = 0 ;
29266 void *argp2 = 0 ;
29267 int res2 = 0 ;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 char * kwnames[] = {
29271 (char *) "self",(char *) "diff", NULL
29272 };
29273
29274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29276 if (!SWIG_IsOK(res1)) {
29277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29278 }
29279 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29281 if (!SWIG_IsOK(res2)) {
29282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29283 }
29284 if (!argp2) {
29285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29286 }
29287 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29288 {
29289 PyThreadState* __tstate = wxPyBeginAllowThreads();
29290 {
29291 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29292 result = (wxTimeSpan *) &_result_ref;
29293 }
29294 wxPyEndAllowThreads(__tstate);
29295 if (PyErr_Occurred()) SWIG_fail;
29296 }
29297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29298 return resultobj;
29299 fail:
29300 return NULL;
29301 }
29302
29303
29304 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29305 PyObject *resultobj = 0;
29306 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29307 int arg2 ;
29308 wxTimeSpan *result = 0 ;
29309 void *argp1 = 0 ;
29310 int res1 = 0 ;
29311 int val2 ;
29312 int ecode2 = 0 ;
29313 PyObject * obj0 = 0 ;
29314 PyObject * obj1 = 0 ;
29315 char * kwnames[] = {
29316 (char *) "self",(char *) "n", NULL
29317 };
29318
29319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29321 if (!SWIG_IsOK(res1)) {
29322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29323 }
29324 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29325 ecode2 = SWIG_AsVal_int(obj1, &val2);
29326 if (!SWIG_IsOK(ecode2)) {
29327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29328 }
29329 arg2 = static_cast< int >(val2);
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 {
29333 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29334 result = (wxTimeSpan *) &_result_ref;
29335 }
29336 wxPyEndAllowThreads(__tstate);
29337 if (PyErr_Occurred()) SWIG_fail;
29338 }
29339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29347 PyObject *resultobj = 0;
29348 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29349 wxTimeSpan *result = 0 ;
29350 void *argp1 = 0 ;
29351 int res1 = 0 ;
29352 PyObject *swig_obj[1] ;
29353
29354 if (!args) SWIG_fail;
29355 swig_obj[0] = args;
29356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29357 if (!SWIG_IsOK(res1)) {
29358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29359 }
29360 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 {
29364 wxTimeSpan &_result_ref = (arg1)->operator -();
29365 result = (wxTimeSpan *) &_result_ref;
29366 }
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj = 0;
29379 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29380 wxTimeSpan *arg2 = 0 ;
29381 wxTimeSpan result;
29382 void *argp1 = 0 ;
29383 int res1 = 0 ;
29384 void *argp2 = 0 ;
29385 int res2 = 0 ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 char * kwnames[] = {
29389 (char *) "self",(char *) "other", NULL
29390 };
29391
29392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29396 }
29397 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29398 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29399 if (!SWIG_IsOK(res2)) {
29400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29401 }
29402 if (!argp2) {
29403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29404 }
29405 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29406 {
29407 PyThreadState* __tstate = wxPyBeginAllowThreads();
29408 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29409 wxPyEndAllowThreads(__tstate);
29410 if (PyErr_Occurred()) SWIG_fail;
29411 }
29412 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29413 return resultobj;
29414 fail:
29415 return NULL;
29416 }
29417
29418
29419 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29420 PyObject *resultobj = 0;
29421 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29422 wxTimeSpan *arg2 = 0 ;
29423 wxTimeSpan result;
29424 void *argp1 = 0 ;
29425 int res1 = 0 ;
29426 void *argp2 = 0 ;
29427 int res2 = 0 ;
29428 PyObject * obj0 = 0 ;
29429 PyObject * obj1 = 0 ;
29430 char * kwnames[] = {
29431 (char *) "self",(char *) "other", NULL
29432 };
29433
29434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29436 if (!SWIG_IsOK(res1)) {
29437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29438 }
29439 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29440 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29441 if (!SWIG_IsOK(res2)) {
29442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29443 }
29444 if (!argp2) {
29445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29446 }
29447 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29448 {
29449 PyThreadState* __tstate = wxPyBeginAllowThreads();
29450 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29451 wxPyEndAllowThreads(__tstate);
29452 if (PyErr_Occurred()) SWIG_fail;
29453 }
29454 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29455 return resultobj;
29456 fail:
29457 return NULL;
29458 }
29459
29460
29461 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29462 PyObject *resultobj = 0;
29463 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29464 int arg2 ;
29465 wxTimeSpan result;
29466 void *argp1 = 0 ;
29467 int res1 = 0 ;
29468 int val2 ;
29469 int ecode2 = 0 ;
29470 PyObject * obj0 = 0 ;
29471 PyObject * obj1 = 0 ;
29472 char * kwnames[] = {
29473 (char *) "self",(char *) "n", NULL
29474 };
29475
29476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29478 if (!SWIG_IsOK(res1)) {
29479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29480 }
29481 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29482 ecode2 = SWIG_AsVal_int(obj1, &val2);
29483 if (!SWIG_IsOK(ecode2)) {
29484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29485 }
29486 arg2 = static_cast< int >(val2);
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 result = wxTimeSpan___mul__(arg1,arg2);
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29494 return resultobj;
29495 fail:
29496 return NULL;
29497 }
29498
29499
29500 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj = 0;
29502 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29503 int arg2 ;
29504 wxTimeSpan result;
29505 void *argp1 = 0 ;
29506 int res1 = 0 ;
29507 int val2 ;
29508 int ecode2 = 0 ;
29509 PyObject * obj0 = 0 ;
29510 PyObject * obj1 = 0 ;
29511 char * kwnames[] = {
29512 (char *) "self",(char *) "n", NULL
29513 };
29514
29515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29517 if (!SWIG_IsOK(res1)) {
29518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29519 }
29520 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29521 ecode2 = SWIG_AsVal_int(obj1, &val2);
29522 if (!SWIG_IsOK(ecode2)) {
29523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29524 }
29525 arg2 = static_cast< int >(val2);
29526 {
29527 PyThreadState* __tstate = wxPyBeginAllowThreads();
29528 result = wxTimeSpan___rmul__(arg1,arg2);
29529 wxPyEndAllowThreads(__tstate);
29530 if (PyErr_Occurred()) SWIG_fail;
29531 }
29532 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29533 return resultobj;
29534 fail:
29535 return NULL;
29536 }
29537
29538
29539 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29540 PyObject *resultobj = 0;
29541 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29542 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29543 bool result;
29544 void *argp1 = 0 ;
29545 int res1 = 0 ;
29546 void *argp2 = 0 ;
29547 int res2 = 0 ;
29548 PyObject * obj0 = 0 ;
29549 PyObject * obj1 = 0 ;
29550 char * kwnames[] = {
29551 (char *) "self",(char *) "other", NULL
29552 };
29553
29554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29556 if (!SWIG_IsOK(res1)) {
29557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29558 }
29559 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29560 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29561 if (!SWIG_IsOK(res2)) {
29562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29563 }
29564 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 {
29572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29573 }
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj = 0;
29582 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29583 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29584 bool result;
29585 void *argp1 = 0 ;
29586 int res1 = 0 ;
29587 void *argp2 = 0 ;
29588 int res2 = 0 ;
29589 PyObject * obj0 = 0 ;
29590 PyObject * obj1 = 0 ;
29591 char * kwnames[] = {
29592 (char *) "self",(char *) "other", NULL
29593 };
29594
29595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29597 if (!SWIG_IsOK(res1)) {
29598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29599 }
29600 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29602 if (!SWIG_IsOK(res2)) {
29603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29604 }
29605 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29606 {
29607 PyThreadState* __tstate = wxPyBeginAllowThreads();
29608 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29609 wxPyEndAllowThreads(__tstate);
29610 if (PyErr_Occurred()) SWIG_fail;
29611 }
29612 {
29613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29614 }
29615 return resultobj;
29616 fail:
29617 return NULL;
29618 }
29619
29620
29621 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29622 PyObject *resultobj = 0;
29623 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29624 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29625 bool result;
29626 void *argp1 = 0 ;
29627 int res1 = 0 ;
29628 void *argp2 = 0 ;
29629 int res2 = 0 ;
29630 PyObject * obj0 = 0 ;
29631 PyObject * obj1 = 0 ;
29632 char * kwnames[] = {
29633 (char *) "self",(char *) "other", NULL
29634 };
29635
29636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29638 if (!SWIG_IsOK(res1)) {
29639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29640 }
29641 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29642 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29643 if (!SWIG_IsOK(res2)) {
29644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29645 }
29646 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29647 {
29648 PyThreadState* __tstate = wxPyBeginAllowThreads();
29649 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 {
29654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29655 }
29656 return resultobj;
29657 fail:
29658 return NULL;
29659 }
29660
29661
29662 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29663 PyObject *resultobj = 0;
29664 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29665 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29666 bool result;
29667 void *argp1 = 0 ;
29668 int res1 = 0 ;
29669 void *argp2 = 0 ;
29670 int res2 = 0 ;
29671 PyObject * obj0 = 0 ;
29672 PyObject * obj1 = 0 ;
29673 char * kwnames[] = {
29674 (char *) "self",(char *) "other", NULL
29675 };
29676
29677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29679 if (!SWIG_IsOK(res1)) {
29680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29681 }
29682 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29684 if (!SWIG_IsOK(res2)) {
29685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29686 }
29687 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29688 {
29689 PyThreadState* __tstate = wxPyBeginAllowThreads();
29690 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29691 wxPyEndAllowThreads(__tstate);
29692 if (PyErr_Occurred()) SWIG_fail;
29693 }
29694 {
29695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29696 }
29697 return resultobj;
29698 fail:
29699 return NULL;
29700 }
29701
29702
29703 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29704 PyObject *resultobj = 0;
29705 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29706 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29707 bool result;
29708 void *argp1 = 0 ;
29709 int res1 = 0 ;
29710 void *argp2 = 0 ;
29711 int res2 = 0 ;
29712 PyObject * obj0 = 0 ;
29713 PyObject * obj1 = 0 ;
29714 char * kwnames[] = {
29715 (char *) "self",(char *) "other", NULL
29716 };
29717
29718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29720 if (!SWIG_IsOK(res1)) {
29721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29722 }
29723 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29724 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29725 if (!SWIG_IsOK(res2)) {
29726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29727 }
29728 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29732 wxPyEndAllowThreads(__tstate);
29733 if (PyErr_Occurred()) SWIG_fail;
29734 }
29735 {
29736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29737 }
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29745 PyObject *resultobj = 0;
29746 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29747 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29748 bool result;
29749 void *argp1 = 0 ;
29750 int res1 = 0 ;
29751 void *argp2 = 0 ;
29752 int res2 = 0 ;
29753 PyObject * obj0 = 0 ;
29754 PyObject * obj1 = 0 ;
29755 char * kwnames[] = {
29756 (char *) "self",(char *) "other", NULL
29757 };
29758
29759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29761 if (!SWIG_IsOK(res1)) {
29762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29763 }
29764 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29766 if (!SWIG_IsOK(res2)) {
29767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29768 }
29769 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29770 {
29771 PyThreadState* __tstate = wxPyBeginAllowThreads();
29772 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29773 wxPyEndAllowThreads(__tstate);
29774 if (PyErr_Occurred()) SWIG_fail;
29775 }
29776 {
29777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29778 }
29779 return resultobj;
29780 fail:
29781 return NULL;
29782 }
29783
29784
29785 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29786 PyObject *resultobj = 0;
29787 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29788 bool result;
29789 void *argp1 = 0 ;
29790 int res1 = 0 ;
29791 PyObject *swig_obj[1] ;
29792
29793 if (!args) SWIG_fail;
29794 swig_obj[0] = args;
29795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29796 if (!SWIG_IsOK(res1)) {
29797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29798 }
29799 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29803 wxPyEndAllowThreads(__tstate);
29804 if (PyErr_Occurred()) SWIG_fail;
29805 }
29806 {
29807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29808 }
29809 return resultobj;
29810 fail:
29811 return NULL;
29812 }
29813
29814
29815 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29816 PyObject *resultobj = 0;
29817 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29818 bool result;
29819 void *argp1 = 0 ;
29820 int res1 = 0 ;
29821 PyObject *swig_obj[1] ;
29822
29823 if (!args) SWIG_fail;
29824 swig_obj[0] = args;
29825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29826 if (!SWIG_IsOK(res1)) {
29827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29828 }
29829 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29830 {
29831 PyThreadState* __tstate = wxPyBeginAllowThreads();
29832 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29833 wxPyEndAllowThreads(__tstate);
29834 if (PyErr_Occurred()) SWIG_fail;
29835 }
29836 {
29837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29838 }
29839 return resultobj;
29840 fail:
29841 return NULL;
29842 }
29843
29844
29845 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29846 PyObject *resultobj = 0;
29847 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29848 bool result;
29849 void *argp1 = 0 ;
29850 int res1 = 0 ;
29851 PyObject *swig_obj[1] ;
29852
29853 if (!args) SWIG_fail;
29854 swig_obj[0] = args;
29855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29856 if (!SWIG_IsOK(res1)) {
29857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29858 }
29859 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29860 {
29861 PyThreadState* __tstate = wxPyBeginAllowThreads();
29862 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29863 wxPyEndAllowThreads(__tstate);
29864 if (PyErr_Occurred()) SWIG_fail;
29865 }
29866 {
29867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29868 }
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj = 0;
29877 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29878 wxTimeSpan *arg2 = 0 ;
29879 bool result;
29880 void *argp1 = 0 ;
29881 int res1 = 0 ;
29882 void *argp2 = 0 ;
29883 int res2 = 0 ;
29884 PyObject * obj0 = 0 ;
29885 PyObject * obj1 = 0 ;
29886 char * kwnames[] = {
29887 (char *) "self",(char *) "ts", NULL
29888 };
29889
29890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29892 if (!SWIG_IsOK(res1)) {
29893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29894 }
29895 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29897 if (!SWIG_IsOK(res2)) {
29898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29899 }
29900 if (!argp2) {
29901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29902 }
29903 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29907 wxPyEndAllowThreads(__tstate);
29908 if (PyErr_Occurred()) SWIG_fail;
29909 }
29910 {
29911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29912 }
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29920 PyObject *resultobj = 0;
29921 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29922 wxTimeSpan *arg2 = 0 ;
29923 bool result;
29924 void *argp1 = 0 ;
29925 int res1 = 0 ;
29926 void *argp2 = 0 ;
29927 int res2 = 0 ;
29928 PyObject * obj0 = 0 ;
29929 PyObject * obj1 = 0 ;
29930 char * kwnames[] = {
29931 (char *) "self",(char *) "ts", NULL
29932 };
29933
29934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29936 if (!SWIG_IsOK(res1)) {
29937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29938 }
29939 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29940 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29941 if (!SWIG_IsOK(res2)) {
29942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29943 }
29944 if (!argp2) {
29945 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29946 }
29947 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29948 {
29949 PyThreadState* __tstate = wxPyBeginAllowThreads();
29950 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 {
29955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29956 }
29957 return resultobj;
29958 fail:
29959 return NULL;
29960 }
29961
29962
29963 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29964 PyObject *resultobj = 0;
29965 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29966 wxTimeSpan *arg2 = 0 ;
29967 bool result;
29968 void *argp1 = 0 ;
29969 int res1 = 0 ;
29970 void *argp2 = 0 ;
29971 int res2 = 0 ;
29972 PyObject * obj0 = 0 ;
29973 PyObject * obj1 = 0 ;
29974 char * kwnames[] = {
29975 (char *) "self",(char *) "t", NULL
29976 };
29977
29978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29980 if (!SWIG_IsOK(res1)) {
29981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29982 }
29983 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29984 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29985 if (!SWIG_IsOK(res2)) {
29986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29987 }
29988 if (!argp2) {
29989 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29990 }
29991 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 {
29999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30000 }
30001 return resultobj;
30002 fail:
30003 return NULL;
30004 }
30005
30006
30007 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30008 PyObject *resultobj = 0;
30009 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30010 int result;
30011 void *argp1 = 0 ;
30012 int res1 = 0 ;
30013 PyObject *swig_obj[1] ;
30014
30015 if (!args) SWIG_fail;
30016 swig_obj[0] = args;
30017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30018 if (!SWIG_IsOK(res1)) {
30019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30020 }
30021 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30025 wxPyEndAllowThreads(__tstate);
30026 if (PyErr_Occurred()) SWIG_fail;
30027 }
30028 resultobj = SWIG_From_int(static_cast< int >(result));
30029 return resultobj;
30030 fail:
30031 return NULL;
30032 }
30033
30034
30035 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30036 PyObject *resultobj = 0;
30037 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30038 int result;
30039 void *argp1 = 0 ;
30040 int res1 = 0 ;
30041 PyObject *swig_obj[1] ;
30042
30043 if (!args) SWIG_fail;
30044 swig_obj[0] = args;
30045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30046 if (!SWIG_IsOK(res1)) {
30047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30048 }
30049 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30050 {
30051 PyThreadState* __tstate = wxPyBeginAllowThreads();
30052 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30053 wxPyEndAllowThreads(__tstate);
30054 if (PyErr_Occurred()) SWIG_fail;
30055 }
30056 resultobj = SWIG_From_int(static_cast< int >(result));
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30064 PyObject *resultobj = 0;
30065 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30066 int result;
30067 void *argp1 = 0 ;
30068 int res1 = 0 ;
30069 PyObject *swig_obj[1] ;
30070
30071 if (!args) SWIG_fail;
30072 swig_obj[0] = args;
30073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30074 if (!SWIG_IsOK(res1)) {
30075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30076 }
30077 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30078 {
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 resultobj = SWIG_From_int(static_cast< int >(result));
30085 return resultobj;
30086 fail:
30087 return NULL;
30088 }
30089
30090
30091 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30092 PyObject *resultobj = 0;
30093 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30094 int result;
30095 void *argp1 = 0 ;
30096 int res1 = 0 ;
30097 PyObject *swig_obj[1] ;
30098
30099 if (!args) SWIG_fail;
30100 swig_obj[0] = args;
30101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30102 if (!SWIG_IsOK(res1)) {
30103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30104 }
30105 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30106 {
30107 PyThreadState* __tstate = wxPyBeginAllowThreads();
30108 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 resultobj = SWIG_From_int(static_cast< int >(result));
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30120 PyObject *resultobj = 0;
30121 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30122 wxLongLong result;
30123 void *argp1 = 0 ;
30124 int res1 = 0 ;
30125 PyObject *swig_obj[1] ;
30126
30127 if (!args) SWIG_fail;
30128 swig_obj[0] = args;
30129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30130 if (!SWIG_IsOK(res1)) {
30131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30132 }
30133 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 {
30141 PyObject *hi, *lo, *shifter, *shifted;
30142 hi = PyLong_FromLong( (&result)->GetHi() );
30143 lo = PyLong_FromLong( (&result)->GetLo() );
30144 shifter = PyLong_FromLong(32);
30145 shifted = PyNumber_Lshift(hi, shifter);
30146 resultobj = PyNumber_Or(shifted, lo);
30147 Py_DECREF(hi);
30148 Py_DECREF(lo);
30149 Py_DECREF(shifter);
30150 Py_DECREF(shifted);
30151 }
30152 return resultobj;
30153 fail:
30154 return NULL;
30155 }
30156
30157
30158 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30159 PyObject *resultobj = 0;
30160 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30161 wxLongLong result;
30162 void *argp1 = 0 ;
30163 int res1 = 0 ;
30164 PyObject *swig_obj[1] ;
30165
30166 if (!args) SWIG_fail;
30167 swig_obj[0] = args;
30168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30169 if (!SWIG_IsOK(res1)) {
30170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30171 }
30172 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30173 {
30174 PyThreadState* __tstate = wxPyBeginAllowThreads();
30175 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30176 wxPyEndAllowThreads(__tstate);
30177 if (PyErr_Occurred()) SWIG_fail;
30178 }
30179 {
30180 PyObject *hi, *lo, *shifter, *shifted;
30181 hi = PyLong_FromLong( (&result)->GetHi() );
30182 lo = PyLong_FromLong( (&result)->GetLo() );
30183 shifter = PyLong_FromLong(32);
30184 shifted = PyNumber_Lshift(hi, shifter);
30185 resultobj = PyNumber_Or(shifted, lo);
30186 Py_DECREF(hi);
30187 Py_DECREF(lo);
30188 Py_DECREF(shifter);
30189 Py_DECREF(shifted);
30190 }
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj = 0;
30199 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30200 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30201 wxString *arg2 = (wxString *) &arg2_defvalue ;
30202 wxString result;
30203 void *argp1 = 0 ;
30204 int res1 = 0 ;
30205 bool temp2 = false ;
30206 PyObject * obj0 = 0 ;
30207 PyObject * obj1 = 0 ;
30208 char * kwnames[] = {
30209 (char *) "self",(char *) "format", NULL
30210 };
30211
30212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30214 if (!SWIG_IsOK(res1)) {
30215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30216 }
30217 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30218 if (obj1) {
30219 {
30220 arg2 = wxString_in_helper(obj1);
30221 if (arg2 == NULL) SWIG_fail;
30222 temp2 = true;
30223 }
30224 }
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 {
30232 #if wxUSE_UNICODE
30233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30234 #else
30235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30236 #endif
30237 }
30238 {
30239 if (temp2)
30240 delete arg2;
30241 }
30242 return resultobj;
30243 fail:
30244 {
30245 if (temp2)
30246 delete arg2;
30247 }
30248 return NULL;
30249 }
30250
30251
30252 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30253 PyObject *obj;
30254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30255 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30256 return SWIG_Py_Void();
30257 }
30258
30259 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30260 return SWIG_Python_InitShadowInstance(args);
30261 }
30262
30263 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30264 PyObject *resultobj = 0;
30265 int arg1 = (int) 0 ;
30266 int arg2 = (int) 0 ;
30267 int arg3 = (int) 0 ;
30268 int arg4 = (int) 0 ;
30269 wxDateSpan *result = 0 ;
30270 int val1 ;
30271 int ecode1 = 0 ;
30272 int val2 ;
30273 int ecode2 = 0 ;
30274 int val3 ;
30275 int ecode3 = 0 ;
30276 int val4 ;
30277 int ecode4 = 0 ;
30278 PyObject * obj0 = 0 ;
30279 PyObject * obj1 = 0 ;
30280 PyObject * obj2 = 0 ;
30281 PyObject * obj3 = 0 ;
30282 char * kwnames[] = {
30283 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30284 };
30285
30286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30287 if (obj0) {
30288 ecode1 = SWIG_AsVal_int(obj0, &val1);
30289 if (!SWIG_IsOK(ecode1)) {
30290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30291 }
30292 arg1 = static_cast< int >(val1);
30293 }
30294 if (obj1) {
30295 ecode2 = SWIG_AsVal_int(obj1, &val2);
30296 if (!SWIG_IsOK(ecode2)) {
30297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30298 }
30299 arg2 = static_cast< int >(val2);
30300 }
30301 if (obj2) {
30302 ecode3 = SWIG_AsVal_int(obj2, &val3);
30303 if (!SWIG_IsOK(ecode3)) {
30304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30305 }
30306 arg3 = static_cast< int >(val3);
30307 }
30308 if (obj3) {
30309 ecode4 = SWIG_AsVal_int(obj3, &val4);
30310 if (!SWIG_IsOK(ecode4)) {
30311 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30312 }
30313 arg4 = static_cast< int >(val4);
30314 }
30315 {
30316 PyThreadState* __tstate = wxPyBeginAllowThreads();
30317 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30318 wxPyEndAllowThreads(__tstate);
30319 if (PyErr_Occurred()) SWIG_fail;
30320 }
30321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30329 PyObject *resultobj = 0;
30330 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30331 void *argp1 = 0 ;
30332 int res1 = 0 ;
30333 PyObject *swig_obj[1] ;
30334
30335 if (!args) SWIG_fail;
30336 swig_obj[0] = args;
30337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30338 if (!SWIG_IsOK(res1)) {
30339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30340 }
30341 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30342 {
30343 PyThreadState* __tstate = wxPyBeginAllowThreads();
30344 delete arg1;
30345
30346 wxPyEndAllowThreads(__tstate);
30347 if (PyErr_Occurred()) SWIG_fail;
30348 }
30349 resultobj = SWIG_Py_Void();
30350 return resultobj;
30351 fail:
30352 return NULL;
30353 }
30354
30355
30356 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30357 PyObject *resultobj = 0;
30358 int arg1 ;
30359 wxDateSpan result;
30360 int val1 ;
30361 int ecode1 = 0 ;
30362 PyObject * obj0 = 0 ;
30363 char * kwnames[] = {
30364 (char *) "days", NULL
30365 };
30366
30367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30368 ecode1 = SWIG_AsVal_int(obj0, &val1);
30369 if (!SWIG_IsOK(ecode1)) {
30370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30371 }
30372 arg1 = static_cast< int >(val1);
30373 {
30374 PyThreadState* __tstate = wxPyBeginAllowThreads();
30375 result = wxDateSpan::Days(arg1);
30376 wxPyEndAllowThreads(__tstate);
30377 if (PyErr_Occurred()) SWIG_fail;
30378 }
30379 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30380 return resultobj;
30381 fail:
30382 return NULL;
30383 }
30384
30385
30386 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30387 PyObject *resultobj = 0;
30388 wxDateSpan result;
30389
30390 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30391 {
30392 PyThreadState* __tstate = wxPyBeginAllowThreads();
30393 result = wxDateSpan::Day();
30394 wxPyEndAllowThreads(__tstate);
30395 if (PyErr_Occurred()) SWIG_fail;
30396 }
30397 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30398 return resultobj;
30399 fail:
30400 return NULL;
30401 }
30402
30403
30404 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30405 PyObject *resultobj = 0;
30406 int arg1 ;
30407 wxDateSpan result;
30408 int val1 ;
30409 int ecode1 = 0 ;
30410 PyObject * obj0 = 0 ;
30411 char * kwnames[] = {
30412 (char *) "weeks", NULL
30413 };
30414
30415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30416 ecode1 = SWIG_AsVal_int(obj0, &val1);
30417 if (!SWIG_IsOK(ecode1)) {
30418 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30419 }
30420 arg1 = static_cast< int >(val1);
30421 {
30422 PyThreadState* __tstate = wxPyBeginAllowThreads();
30423 result = wxDateSpan::Weeks(arg1);
30424 wxPyEndAllowThreads(__tstate);
30425 if (PyErr_Occurred()) SWIG_fail;
30426 }
30427 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30435 PyObject *resultobj = 0;
30436 wxDateSpan result;
30437
30438 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30439 {
30440 PyThreadState* __tstate = wxPyBeginAllowThreads();
30441 result = wxDateSpan::Week();
30442 wxPyEndAllowThreads(__tstate);
30443 if (PyErr_Occurred()) SWIG_fail;
30444 }
30445 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30446 return resultobj;
30447 fail:
30448 return NULL;
30449 }
30450
30451
30452 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30453 PyObject *resultobj = 0;
30454 int arg1 ;
30455 wxDateSpan result;
30456 int val1 ;
30457 int ecode1 = 0 ;
30458 PyObject * obj0 = 0 ;
30459 char * kwnames[] = {
30460 (char *) "mon", NULL
30461 };
30462
30463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30464 ecode1 = SWIG_AsVal_int(obj0, &val1);
30465 if (!SWIG_IsOK(ecode1)) {
30466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30467 }
30468 arg1 = static_cast< int >(val1);
30469 {
30470 PyThreadState* __tstate = wxPyBeginAllowThreads();
30471 result = wxDateSpan::Months(arg1);
30472 wxPyEndAllowThreads(__tstate);
30473 if (PyErr_Occurred()) SWIG_fail;
30474 }
30475 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30476 return resultobj;
30477 fail:
30478 return NULL;
30479 }
30480
30481
30482 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30483 PyObject *resultobj = 0;
30484 wxDateSpan result;
30485
30486 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30487 {
30488 PyThreadState* __tstate = wxPyBeginAllowThreads();
30489 result = wxDateSpan::Month();
30490 wxPyEndAllowThreads(__tstate);
30491 if (PyErr_Occurred()) SWIG_fail;
30492 }
30493 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30501 PyObject *resultobj = 0;
30502 int arg1 ;
30503 wxDateSpan result;
30504 int val1 ;
30505 int ecode1 = 0 ;
30506 PyObject * obj0 = 0 ;
30507 char * kwnames[] = {
30508 (char *) "years", NULL
30509 };
30510
30511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30512 ecode1 = SWIG_AsVal_int(obj0, &val1);
30513 if (!SWIG_IsOK(ecode1)) {
30514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30515 }
30516 arg1 = static_cast< int >(val1);
30517 {
30518 PyThreadState* __tstate = wxPyBeginAllowThreads();
30519 result = wxDateSpan::Years(arg1);
30520 wxPyEndAllowThreads(__tstate);
30521 if (PyErr_Occurred()) SWIG_fail;
30522 }
30523 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30531 PyObject *resultobj = 0;
30532 wxDateSpan result;
30533
30534 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30535 {
30536 PyThreadState* __tstate = wxPyBeginAllowThreads();
30537 result = wxDateSpan::Year();
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj = 0;
30550 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30551 int arg2 ;
30552 wxDateSpan *result = 0 ;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 int val2 ;
30556 int ecode2 = 0 ;
30557 PyObject * obj0 = 0 ;
30558 PyObject * obj1 = 0 ;
30559 char * kwnames[] = {
30560 (char *) "self",(char *) "n", NULL
30561 };
30562
30563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30565 if (!SWIG_IsOK(res1)) {
30566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30567 }
30568 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30569 ecode2 = SWIG_AsVal_int(obj1, &val2);
30570 if (!SWIG_IsOK(ecode2)) {
30571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30572 }
30573 arg2 = static_cast< int >(val2);
30574 {
30575 PyThreadState* __tstate = wxPyBeginAllowThreads();
30576 {
30577 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30578 result = (wxDateSpan *) &_result_ref;
30579 }
30580 wxPyEndAllowThreads(__tstate);
30581 if (PyErr_Occurred()) SWIG_fail;
30582 }
30583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30584 return resultobj;
30585 fail:
30586 return NULL;
30587 }
30588
30589
30590 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30591 PyObject *resultobj = 0;
30592 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30593 int arg2 ;
30594 wxDateSpan *result = 0 ;
30595 void *argp1 = 0 ;
30596 int res1 = 0 ;
30597 int val2 ;
30598 int ecode2 = 0 ;
30599 PyObject * obj0 = 0 ;
30600 PyObject * obj1 = 0 ;
30601 char * kwnames[] = {
30602 (char *) "self",(char *) "n", NULL
30603 };
30604
30605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30607 if (!SWIG_IsOK(res1)) {
30608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30609 }
30610 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30611 ecode2 = SWIG_AsVal_int(obj1, &val2);
30612 if (!SWIG_IsOK(ecode2)) {
30613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30614 }
30615 arg2 = static_cast< int >(val2);
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 {
30619 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30620 result = (wxDateSpan *) &_result_ref;
30621 }
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30626 return resultobj;
30627 fail:
30628 return NULL;
30629 }
30630
30631
30632 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30633 PyObject *resultobj = 0;
30634 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30635 int arg2 ;
30636 wxDateSpan *result = 0 ;
30637 void *argp1 = 0 ;
30638 int res1 = 0 ;
30639 int val2 ;
30640 int ecode2 = 0 ;
30641 PyObject * obj0 = 0 ;
30642 PyObject * obj1 = 0 ;
30643 char * kwnames[] = {
30644 (char *) "self",(char *) "n", NULL
30645 };
30646
30647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30649 if (!SWIG_IsOK(res1)) {
30650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30651 }
30652 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30653 ecode2 = SWIG_AsVal_int(obj1, &val2);
30654 if (!SWIG_IsOK(ecode2)) {
30655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30656 }
30657 arg2 = static_cast< int >(val2);
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 {
30661 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30662 result = (wxDateSpan *) &_result_ref;
30663 }
30664 wxPyEndAllowThreads(__tstate);
30665 if (PyErr_Occurred()) SWIG_fail;
30666 }
30667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30668 return resultobj;
30669 fail:
30670 return NULL;
30671 }
30672
30673
30674 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj = 0;
30676 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30677 int arg2 ;
30678 wxDateSpan *result = 0 ;
30679 void *argp1 = 0 ;
30680 int res1 = 0 ;
30681 int val2 ;
30682 int ecode2 = 0 ;
30683 PyObject * obj0 = 0 ;
30684 PyObject * obj1 = 0 ;
30685 char * kwnames[] = {
30686 (char *) "self",(char *) "n", NULL
30687 };
30688
30689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30691 if (!SWIG_IsOK(res1)) {
30692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30693 }
30694 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30695 ecode2 = SWIG_AsVal_int(obj1, &val2);
30696 if (!SWIG_IsOK(ecode2)) {
30697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30698 }
30699 arg2 = static_cast< int >(val2);
30700 {
30701 PyThreadState* __tstate = wxPyBeginAllowThreads();
30702 {
30703 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30704 result = (wxDateSpan *) &_result_ref;
30705 }
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30717 PyObject *resultobj = 0;
30718 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30719 int result;
30720 void *argp1 = 0 ;
30721 int res1 = 0 ;
30722 PyObject *swig_obj[1] ;
30723
30724 if (!args) SWIG_fail;
30725 swig_obj[0] = args;
30726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30727 if (!SWIG_IsOK(res1)) {
30728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30729 }
30730 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 result = (int)((wxDateSpan const *)arg1)->GetYears();
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 resultobj = SWIG_From_int(static_cast< int >(result));
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30745 PyObject *resultobj = 0;
30746 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30747 int result;
30748 void *argp1 = 0 ;
30749 int res1 = 0 ;
30750 PyObject *swig_obj[1] ;
30751
30752 if (!args) SWIG_fail;
30753 swig_obj[0] = args;
30754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30755 if (!SWIG_IsOK(res1)) {
30756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30757 }
30758 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 resultobj = SWIG_From_int(static_cast< int >(result));
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30775 int result;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 PyObject *swig_obj[1] ;
30779
30780 if (!args) SWIG_fail;
30781 swig_obj[0] = args;
30782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30783 if (!SWIG_IsOK(res1)) {
30784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30785 }
30786 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 resultobj = SWIG_From_int(static_cast< int >(result));
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30801 PyObject *resultobj = 0;
30802 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30803 int result;
30804 void *argp1 = 0 ;
30805 int res1 = 0 ;
30806 PyObject *swig_obj[1] ;
30807
30808 if (!args) SWIG_fail;
30809 swig_obj[0] = args;
30810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30813 }
30814 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = (int)((wxDateSpan const *)arg1)->GetDays();
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 resultobj = SWIG_From_int(static_cast< int >(result));
30822 return resultobj;
30823 fail:
30824 return NULL;
30825 }
30826
30827
30828 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30829 PyObject *resultobj = 0;
30830 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30831 int result;
30832 void *argp1 = 0 ;
30833 int res1 = 0 ;
30834 PyObject *swig_obj[1] ;
30835
30836 if (!args) SWIG_fail;
30837 swig_obj[0] = args;
30838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30839 if (!SWIG_IsOK(res1)) {
30840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30841 }
30842 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30843 {
30844 PyThreadState* __tstate = wxPyBeginAllowThreads();
30845 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 resultobj = SWIG_From_int(static_cast< int >(result));
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30857 PyObject *resultobj = 0;
30858 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30859 wxDateSpan *arg2 = 0 ;
30860 wxDateSpan *result = 0 ;
30861 void *argp1 = 0 ;
30862 int res1 = 0 ;
30863 void *argp2 = 0 ;
30864 int res2 = 0 ;
30865 PyObject * obj0 = 0 ;
30866 PyObject * obj1 = 0 ;
30867 char * kwnames[] = {
30868 (char *) "self",(char *) "other", NULL
30869 };
30870
30871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30873 if (!SWIG_IsOK(res1)) {
30874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30875 }
30876 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30877 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30878 if (!SWIG_IsOK(res2)) {
30879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30880 }
30881 if (!argp2) {
30882 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30883 }
30884 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 {
30888 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30889 result = (wxDateSpan *) &_result_ref;
30890 }
30891 wxPyEndAllowThreads(__tstate);
30892 if (PyErr_Occurred()) SWIG_fail;
30893 }
30894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30895 return resultobj;
30896 fail:
30897 return NULL;
30898 }
30899
30900
30901 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30902 PyObject *resultobj = 0;
30903 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30904 wxDateSpan *arg2 = 0 ;
30905 wxDateSpan *result = 0 ;
30906 void *argp1 = 0 ;
30907 int res1 = 0 ;
30908 void *argp2 = 0 ;
30909 int res2 = 0 ;
30910 PyObject * obj0 = 0 ;
30911 PyObject * obj1 = 0 ;
30912 char * kwnames[] = {
30913 (char *) "self",(char *) "other", NULL
30914 };
30915
30916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30918 if (!SWIG_IsOK(res1)) {
30919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30920 }
30921 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30922 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30923 if (!SWIG_IsOK(res2)) {
30924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30925 }
30926 if (!argp2) {
30927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30928 }
30929 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30930 {
30931 PyThreadState* __tstate = wxPyBeginAllowThreads();
30932 {
30933 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30934 result = (wxDateSpan *) &_result_ref;
30935 }
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30940 return resultobj;
30941 fail:
30942 return NULL;
30943 }
30944
30945
30946 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30947 PyObject *resultobj = 0;
30948 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30949 wxDateSpan *result = 0 ;
30950 void *argp1 = 0 ;
30951 int res1 = 0 ;
30952 PyObject *swig_obj[1] ;
30953
30954 if (!args) SWIG_fail;
30955 swig_obj[0] = args;
30956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30957 if (!SWIG_IsOK(res1)) {
30958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30959 }
30960 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 {
30964 wxDateSpan &_result_ref = (arg1)->Neg();
30965 result = (wxDateSpan *) &_result_ref;
30966 }
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30971 return resultobj;
30972 fail:
30973 return NULL;
30974 }
30975
30976
30977 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30978 PyObject *resultobj = 0;
30979 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30980 int arg2 ;
30981 wxDateSpan *result = 0 ;
30982 void *argp1 = 0 ;
30983 int res1 = 0 ;
30984 int val2 ;
30985 int ecode2 = 0 ;
30986 PyObject * obj0 = 0 ;
30987 PyObject * obj1 = 0 ;
30988 char * kwnames[] = {
30989 (char *) "self",(char *) "factor", NULL
30990 };
30991
30992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30994 if (!SWIG_IsOK(res1)) {
30995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30996 }
30997 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30998 ecode2 = SWIG_AsVal_int(obj1, &val2);
30999 if (!SWIG_IsOK(ecode2)) {
31000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31001 }
31002 arg2 = static_cast< int >(val2);
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 {
31006 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31007 result = (wxDateSpan *) &_result_ref;
31008 }
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31020 PyObject *resultobj = 0;
31021 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31022 wxDateSpan *arg2 = 0 ;
31023 wxDateSpan *result = 0 ;
31024 void *argp1 = 0 ;
31025 int res1 = 0 ;
31026 void *argp2 = 0 ;
31027 int res2 = 0 ;
31028 PyObject * obj0 = 0 ;
31029 PyObject * obj1 = 0 ;
31030 char * kwnames[] = {
31031 (char *) "self",(char *) "other", NULL
31032 };
31033
31034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31036 if (!SWIG_IsOK(res1)) {
31037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31038 }
31039 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31040 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31041 if (!SWIG_IsOK(res2)) {
31042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31043 }
31044 if (!argp2) {
31045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31046 }
31047 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31048 {
31049 PyThreadState* __tstate = wxPyBeginAllowThreads();
31050 {
31051 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31052 result = (wxDateSpan *) &_result_ref;
31053 }
31054 wxPyEndAllowThreads(__tstate);
31055 if (PyErr_Occurred()) SWIG_fail;
31056 }
31057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31058 return resultobj;
31059 fail:
31060 return NULL;
31061 }
31062
31063
31064 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31065 PyObject *resultobj = 0;
31066 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31067 wxDateSpan *arg2 = 0 ;
31068 wxDateSpan *result = 0 ;
31069 void *argp1 = 0 ;
31070 int res1 = 0 ;
31071 void *argp2 = 0 ;
31072 int res2 = 0 ;
31073 PyObject * obj0 = 0 ;
31074 PyObject * obj1 = 0 ;
31075 char * kwnames[] = {
31076 (char *) "self",(char *) "other", NULL
31077 };
31078
31079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31081 if (!SWIG_IsOK(res1)) {
31082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31083 }
31084 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31085 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31086 if (!SWIG_IsOK(res2)) {
31087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31088 }
31089 if (!argp2) {
31090 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31091 }
31092 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31093 {
31094 PyThreadState* __tstate = wxPyBeginAllowThreads();
31095 {
31096 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31097 result = (wxDateSpan *) &_result_ref;
31098 }
31099 wxPyEndAllowThreads(__tstate);
31100 if (PyErr_Occurred()) SWIG_fail;
31101 }
31102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31103 return resultobj;
31104 fail:
31105 return NULL;
31106 }
31107
31108
31109 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31110 PyObject *resultobj = 0;
31111 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31112 wxDateSpan *result = 0 ;
31113 void *argp1 = 0 ;
31114 int res1 = 0 ;
31115 PyObject *swig_obj[1] ;
31116
31117 if (!args) SWIG_fail;
31118 swig_obj[0] = args;
31119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31120 if (!SWIG_IsOK(res1)) {
31121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31122 }
31123 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 {
31127 wxDateSpan &_result_ref = (arg1)->operator -();
31128 result = (wxDateSpan *) &_result_ref;
31129 }
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj = 0;
31142 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31143 int arg2 ;
31144 wxDateSpan *result = 0 ;
31145 void *argp1 = 0 ;
31146 int res1 = 0 ;
31147 int val2 ;
31148 int ecode2 = 0 ;
31149 PyObject * obj0 = 0 ;
31150 PyObject * obj1 = 0 ;
31151 char * kwnames[] = {
31152 (char *) "self",(char *) "factor", NULL
31153 };
31154
31155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31157 if (!SWIG_IsOK(res1)) {
31158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31159 }
31160 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31161 ecode2 = SWIG_AsVal_int(obj1, &val2);
31162 if (!SWIG_IsOK(ecode2)) {
31163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31164 }
31165 arg2 = static_cast< int >(val2);
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 {
31169 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31170 result = (wxDateSpan *) &_result_ref;
31171 }
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31183 PyObject *resultobj = 0;
31184 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31185 wxDateSpan *arg2 = 0 ;
31186 wxDateSpan result;
31187 void *argp1 = 0 ;
31188 int res1 = 0 ;
31189 void *argp2 = 0 ;
31190 int res2 = 0 ;
31191 PyObject * obj0 = 0 ;
31192 PyObject * obj1 = 0 ;
31193 char * kwnames[] = {
31194 (char *) "self",(char *) "other", NULL
31195 };
31196
31197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31199 if (!SWIG_IsOK(res1)) {
31200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31201 }
31202 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31203 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31204 if (!SWIG_IsOK(res2)) {
31205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31206 }
31207 if (!argp2) {
31208 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31209 }
31210 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31211 {
31212 PyThreadState* __tstate = wxPyBeginAllowThreads();
31213 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31225 PyObject *resultobj = 0;
31226 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31227 wxDateSpan *arg2 = 0 ;
31228 wxDateSpan result;
31229 void *argp1 = 0 ;
31230 int res1 = 0 ;
31231 void *argp2 = 0 ;
31232 int res2 = 0 ;
31233 PyObject * obj0 = 0 ;
31234 PyObject * obj1 = 0 ;
31235 char * kwnames[] = {
31236 (char *) "self",(char *) "other", NULL
31237 };
31238
31239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31241 if (!SWIG_IsOK(res1)) {
31242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31243 }
31244 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31246 if (!SWIG_IsOK(res2)) {
31247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31248 }
31249 if (!argp2) {
31250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31251 }
31252 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31253 {
31254 PyThreadState* __tstate = wxPyBeginAllowThreads();
31255 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31256 wxPyEndAllowThreads(__tstate);
31257 if (PyErr_Occurred()) SWIG_fail;
31258 }
31259 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31260 return resultobj;
31261 fail:
31262 return NULL;
31263 }
31264
31265
31266 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31267 PyObject *resultobj = 0;
31268 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31269 int arg2 ;
31270 wxDateSpan result;
31271 void *argp1 = 0 ;
31272 int res1 = 0 ;
31273 int val2 ;
31274 int ecode2 = 0 ;
31275 PyObject * obj0 = 0 ;
31276 PyObject * obj1 = 0 ;
31277 char * kwnames[] = {
31278 (char *) "self",(char *) "n", NULL
31279 };
31280
31281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31283 if (!SWIG_IsOK(res1)) {
31284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31285 }
31286 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31287 ecode2 = SWIG_AsVal_int(obj1, &val2);
31288 if (!SWIG_IsOK(ecode2)) {
31289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31290 }
31291 arg2 = static_cast< int >(val2);
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 result = wxDateSpan___mul__(arg1,arg2);
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj = 0;
31307 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31308 int arg2 ;
31309 wxDateSpan result;
31310 void *argp1 = 0 ;
31311 int res1 = 0 ;
31312 int val2 ;
31313 int ecode2 = 0 ;
31314 PyObject * obj0 = 0 ;
31315 PyObject * obj1 = 0 ;
31316 char * kwnames[] = {
31317 (char *) "self",(char *) "n", NULL
31318 };
31319
31320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31322 if (!SWIG_IsOK(res1)) {
31323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31324 }
31325 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31326 ecode2 = SWIG_AsVal_int(obj1, &val2);
31327 if (!SWIG_IsOK(ecode2)) {
31328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31329 }
31330 arg2 = static_cast< int >(val2);
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 result = wxDateSpan___rmul__(arg1,arg2);
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31345 PyObject *resultobj = 0;
31346 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31347 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31348 bool result;
31349 void *argp1 = 0 ;
31350 int res1 = 0 ;
31351 void *argp2 = 0 ;
31352 int res2 = 0 ;
31353 PyObject * obj0 = 0 ;
31354 PyObject * obj1 = 0 ;
31355 char * kwnames[] = {
31356 (char *) "self",(char *) "other", NULL
31357 };
31358
31359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31361 if (!SWIG_IsOK(res1)) {
31362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31363 }
31364 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31365 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31366 if (!SWIG_IsOK(res2)) {
31367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31368 }
31369 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31370 {
31371 PyThreadState* __tstate = wxPyBeginAllowThreads();
31372 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31373 wxPyEndAllowThreads(__tstate);
31374 if (PyErr_Occurred()) SWIG_fail;
31375 }
31376 {
31377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31378 }
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31386 PyObject *resultobj = 0;
31387 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31388 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31389 bool result;
31390 void *argp1 = 0 ;
31391 int res1 = 0 ;
31392 void *argp2 = 0 ;
31393 int res2 = 0 ;
31394 PyObject * obj0 = 0 ;
31395 PyObject * obj1 = 0 ;
31396 char * kwnames[] = {
31397 (char *) "self",(char *) "other", NULL
31398 };
31399
31400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31402 if (!SWIG_IsOK(res1)) {
31403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31404 }
31405 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31406 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31407 if (!SWIG_IsOK(res2)) {
31408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31409 }
31410 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31411 {
31412 PyThreadState* __tstate = wxPyBeginAllowThreads();
31413 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31414 wxPyEndAllowThreads(__tstate);
31415 if (PyErr_Occurred()) SWIG_fail;
31416 }
31417 {
31418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31419 }
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31427 PyObject *obj;
31428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31429 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31430 return SWIG_Py_Void();
31431 }
31432
31433 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31434 return SWIG_Python_InitShadowInstance(args);
31435 }
31436
31437 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31438 PyObject *resultobj = 0;
31439 long result;
31440
31441 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31442 {
31443 PyThreadState* __tstate = wxPyBeginAllowThreads();
31444 result = (long)wxGetLocalTime();
31445 wxPyEndAllowThreads(__tstate);
31446 if (PyErr_Occurred()) SWIG_fail;
31447 }
31448 resultobj = SWIG_From_long(static_cast< long >(result));
31449 return resultobj;
31450 fail:
31451 return NULL;
31452 }
31453
31454
31455 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31456 PyObject *resultobj = 0;
31457 long result;
31458
31459 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 result = (long)wxGetUTCTime();
31463 wxPyEndAllowThreads(__tstate);
31464 if (PyErr_Occurred()) SWIG_fail;
31465 }
31466 resultobj = SWIG_From_long(static_cast< long >(result));
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31474 PyObject *resultobj = 0;
31475 long result;
31476
31477 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31478 {
31479 PyThreadState* __tstate = wxPyBeginAllowThreads();
31480 result = (long)wxGetCurrentTime();
31481 wxPyEndAllowThreads(__tstate);
31482 if (PyErr_Occurred()) SWIG_fail;
31483 }
31484 resultobj = SWIG_From_long(static_cast< long >(result));
31485 return resultobj;
31486 fail:
31487 return NULL;
31488 }
31489
31490
31491 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31492 PyObject *resultobj = 0;
31493 wxLongLong result;
31494
31495 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 result = wxGetLocalTimeMillis();
31499 wxPyEndAllowThreads(__tstate);
31500 if (PyErr_Occurred()) SWIG_fail;
31501 }
31502 {
31503 PyObject *hi, *lo, *shifter, *shifted;
31504 hi = PyLong_FromLong( (&result)->GetHi() );
31505 lo = PyLong_FromLong( (&result)->GetLo() );
31506 shifter = PyLong_FromLong(32);
31507 shifted = PyNumber_Lshift(hi, shifter);
31508 resultobj = PyNumber_Or(shifted, lo);
31509 Py_DECREF(hi);
31510 Py_DECREF(lo);
31511 Py_DECREF(shifter);
31512 Py_DECREF(shifted);
31513 }
31514 return resultobj;
31515 fail:
31516 return NULL;
31517 }
31518
31519
31520 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31521 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31522 return 1;
31523 }
31524
31525
31526 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31527 PyObject *pyobj = 0;
31528
31529 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31530 return pyobj;
31531 }
31532
31533
31534 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31535 PyObject *resultobj = 0;
31536 wxDataFormatId arg1 ;
31537 wxDataFormat *result = 0 ;
31538 int val1 ;
31539 int ecode1 = 0 ;
31540 PyObject * obj0 = 0 ;
31541 char * kwnames[] = {
31542 (char *) "type", NULL
31543 };
31544
31545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31546 ecode1 = SWIG_AsVal_int(obj0, &val1);
31547 if (!SWIG_IsOK(ecode1)) {
31548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31549 }
31550 arg1 = static_cast< wxDataFormatId >(val1);
31551 {
31552 PyThreadState* __tstate = wxPyBeginAllowThreads();
31553 result = (wxDataFormat *)new wxDataFormat(arg1);
31554 wxPyEndAllowThreads(__tstate);
31555 if (PyErr_Occurred()) SWIG_fail;
31556 }
31557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31558 return resultobj;
31559 fail:
31560 return NULL;
31561 }
31562
31563
31564 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31565 PyObject *resultobj = 0;
31566 wxString *arg1 = 0 ;
31567 wxDataFormat *result = 0 ;
31568 bool temp1 = false ;
31569 PyObject * obj0 = 0 ;
31570 char * kwnames[] = {
31571 (char *) "format", NULL
31572 };
31573
31574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31575 {
31576 arg1 = wxString_in_helper(obj0);
31577 if (arg1 == NULL) SWIG_fail;
31578 temp1 = true;
31579 }
31580 {
31581 PyThreadState* __tstate = wxPyBeginAllowThreads();
31582 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31583 wxPyEndAllowThreads(__tstate);
31584 if (PyErr_Occurred()) SWIG_fail;
31585 }
31586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31587 {
31588 if (temp1)
31589 delete arg1;
31590 }
31591 return resultobj;
31592 fail:
31593 {
31594 if (temp1)
31595 delete arg1;
31596 }
31597 return NULL;
31598 }
31599
31600
31601 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31602 PyObject *resultobj = 0;
31603 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31604 void *argp1 = 0 ;
31605 int res1 = 0 ;
31606 PyObject *swig_obj[1] ;
31607
31608 if (!args) SWIG_fail;
31609 swig_obj[0] = args;
31610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31611 if (!SWIG_IsOK(res1)) {
31612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31613 }
31614 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31615 {
31616 PyThreadState* __tstate = wxPyBeginAllowThreads();
31617 delete arg1;
31618
31619 wxPyEndAllowThreads(__tstate);
31620 if (PyErr_Occurred()) SWIG_fail;
31621 }
31622 resultobj = SWIG_Py_Void();
31623 return resultobj;
31624 fail:
31625 return NULL;
31626 }
31627
31628
31629 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31630 PyObject *resultobj = 0;
31631 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31632 wxDataFormatId arg2 ;
31633 bool result;
31634 void *argp1 = 0 ;
31635 int res1 = 0 ;
31636 int val2 ;
31637 int ecode2 = 0 ;
31638
31639 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31641 if (!SWIG_IsOK(res1)) {
31642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31643 }
31644 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31645 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31646 if (!SWIG_IsOK(ecode2)) {
31647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31648 }
31649 arg2 = static_cast< wxDataFormatId >(val2);
31650 {
31651 PyThreadState* __tstate = wxPyBeginAllowThreads();
31652 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31653 wxPyEndAllowThreads(__tstate);
31654 if (PyErr_Occurred()) SWIG_fail;
31655 }
31656 {
31657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31658 }
31659 return resultobj;
31660 fail:
31661 return NULL;
31662 }
31663
31664
31665 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31666 PyObject *resultobj = 0;
31667 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31668 wxDataFormatId arg2 ;
31669 bool result;
31670 void *argp1 = 0 ;
31671 int res1 = 0 ;
31672 int val2 ;
31673 int ecode2 = 0 ;
31674
31675 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31677 if (!SWIG_IsOK(res1)) {
31678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31679 }
31680 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31681 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31682 if (!SWIG_IsOK(ecode2)) {
31683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31684 }
31685 arg2 = static_cast< wxDataFormatId >(val2);
31686 {
31687 PyThreadState* __tstate = wxPyBeginAllowThreads();
31688 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31689 wxPyEndAllowThreads(__tstate);
31690 if (PyErr_Occurred()) SWIG_fail;
31691 }
31692 {
31693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31694 }
31695 return resultobj;
31696 fail:
31697 return NULL;
31698 }
31699
31700
31701 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31702 PyObject *resultobj = 0;
31703 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31704 wxDataFormat *arg2 = 0 ;
31705 bool result;
31706 void *argp1 = 0 ;
31707 int res1 = 0 ;
31708 void *argp2 = 0 ;
31709 int res2 = 0 ;
31710
31711 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31713 if (!SWIG_IsOK(res1)) {
31714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31715 }
31716 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31717 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31718 if (!SWIG_IsOK(res2)) {
31719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31720 }
31721 if (!argp2) {
31722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31723 }
31724 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31725 {
31726 PyThreadState* __tstate = wxPyBeginAllowThreads();
31727 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 {
31732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31733 }
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31741 int argc;
31742 PyObject *argv[3];
31743
31744 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31745 --argc;
31746 if (argc == 2) {
31747 int _v = 0;
31748 {
31749 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31750 _v = SWIG_CheckState(res);
31751 }
31752 if (!_v) goto check_1;
31753 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31754 }
31755 check_1:
31756
31757 if (argc == 2) {
31758 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31759 }
31760
31761 fail:
31762 Py_INCREF(Py_NotImplemented);
31763 return Py_NotImplemented;
31764 }
31765
31766
31767 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31768 PyObject *resultobj = 0;
31769 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31770 wxDataFormat *arg2 = 0 ;
31771 bool result;
31772 void *argp1 = 0 ;
31773 int res1 = 0 ;
31774 void *argp2 = 0 ;
31775 int res2 = 0 ;
31776
31777 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31779 if (!SWIG_IsOK(res1)) {
31780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31781 }
31782 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31783 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31784 if (!SWIG_IsOK(res2)) {
31785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31786 }
31787 if (!argp2) {
31788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31789 }
31790 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31794 wxPyEndAllowThreads(__tstate);
31795 if (PyErr_Occurred()) SWIG_fail;
31796 }
31797 {
31798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31799 }
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31807 int argc;
31808 PyObject *argv[3];
31809
31810 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31811 --argc;
31812 if (argc == 2) {
31813 int _v = 0;
31814 {
31815 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31816 _v = SWIG_CheckState(res);
31817 }
31818 if (!_v) goto check_1;
31819 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31820 }
31821 check_1:
31822
31823 if (argc == 2) {
31824 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31825 }
31826
31827 fail:
31828 Py_INCREF(Py_NotImplemented);
31829 return Py_NotImplemented;
31830 }
31831
31832
31833 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31834 PyObject *resultobj = 0;
31835 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31836 wxDataFormatId arg2 ;
31837 void *argp1 = 0 ;
31838 int res1 = 0 ;
31839 int val2 ;
31840 int ecode2 = 0 ;
31841 PyObject * obj0 = 0 ;
31842 PyObject * obj1 = 0 ;
31843 char * kwnames[] = {
31844 (char *) "self",(char *) "format", NULL
31845 };
31846
31847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31849 if (!SWIG_IsOK(res1)) {
31850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31851 }
31852 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31853 ecode2 = SWIG_AsVal_int(obj1, &val2);
31854 if (!SWIG_IsOK(ecode2)) {
31855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31856 }
31857 arg2 = static_cast< wxDataFormatId >(val2);
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 (arg1)->SetType(arg2);
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 resultobj = SWIG_Py_Void();
31865 return resultobj;
31866 fail:
31867 return NULL;
31868 }
31869
31870
31871 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31872 PyObject *resultobj = 0;
31873 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31874 wxDataFormatId result;
31875 void *argp1 = 0 ;
31876 int res1 = 0 ;
31877 PyObject *swig_obj[1] ;
31878
31879 if (!args) SWIG_fail;
31880 swig_obj[0] = args;
31881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31882 if (!SWIG_IsOK(res1)) {
31883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31884 }
31885 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31886 {
31887 PyThreadState* __tstate = wxPyBeginAllowThreads();
31888 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31889 wxPyEndAllowThreads(__tstate);
31890 if (PyErr_Occurred()) SWIG_fail;
31891 }
31892 resultobj = SWIG_From_int(static_cast< int >(result));
31893 return resultobj;
31894 fail:
31895 return NULL;
31896 }
31897
31898
31899 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31900 PyObject *resultobj = 0;
31901 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31902 wxString result;
31903 void *argp1 = 0 ;
31904 int res1 = 0 ;
31905 PyObject *swig_obj[1] ;
31906
31907 if (!args) SWIG_fail;
31908 swig_obj[0] = args;
31909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31910 if (!SWIG_IsOK(res1)) {
31911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31912 }
31913 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31914 {
31915 PyThreadState* __tstate = wxPyBeginAllowThreads();
31916 result = ((wxDataFormat const *)arg1)->GetId();
31917 wxPyEndAllowThreads(__tstate);
31918 if (PyErr_Occurred()) SWIG_fail;
31919 }
31920 {
31921 #if wxUSE_UNICODE
31922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31923 #else
31924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31925 #endif
31926 }
31927 return resultobj;
31928 fail:
31929 return NULL;
31930 }
31931
31932
31933 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31934 PyObject *resultobj = 0;
31935 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31936 wxString *arg2 = 0 ;
31937 void *argp1 = 0 ;
31938 int res1 = 0 ;
31939 bool temp2 = false ;
31940 PyObject * obj0 = 0 ;
31941 PyObject * obj1 = 0 ;
31942 char * kwnames[] = {
31943 (char *) "self",(char *) "format", NULL
31944 };
31945
31946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31948 if (!SWIG_IsOK(res1)) {
31949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31950 }
31951 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31952 {
31953 arg2 = wxString_in_helper(obj1);
31954 if (arg2 == NULL) SWIG_fail;
31955 temp2 = true;
31956 }
31957 {
31958 PyThreadState* __tstate = wxPyBeginAllowThreads();
31959 (arg1)->SetId((wxString const &)*arg2);
31960 wxPyEndAllowThreads(__tstate);
31961 if (PyErr_Occurred()) SWIG_fail;
31962 }
31963 resultobj = SWIG_Py_Void();
31964 {
31965 if (temp2)
31966 delete arg2;
31967 }
31968 return resultobj;
31969 fail:
31970 {
31971 if (temp2)
31972 delete arg2;
31973 }
31974 return NULL;
31975 }
31976
31977
31978 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31979 PyObject *obj;
31980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31981 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31982 return SWIG_Py_Void();
31983 }
31984
31985 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31986 return SWIG_Python_InitShadowInstance(args);
31987 }
31988
31989 SWIGINTERN int FormatInvalid_set(PyObject *) {
31990 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31991 return 1;
31992 }
31993
31994
31995 SWIGINTERN PyObject *FormatInvalid_get(void) {
31996 PyObject *pyobj = 0;
31997
31998 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31999 return pyobj;
32000 }
32001
32002
32003 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32004 PyObject *resultobj = 0;
32005 wxDataObject *arg1 = (wxDataObject *) 0 ;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 PyObject *swig_obj[1] ;
32009
32010 if (!args) SWIG_fail;
32011 swig_obj[0] = args;
32012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32015 }
32016 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 delete arg1;
32020
32021 wxPyEndAllowThreads(__tstate);
32022 if (PyErr_Occurred()) SWIG_fail;
32023 }
32024 resultobj = SWIG_Py_Void();
32025 return resultobj;
32026 fail:
32027 return NULL;
32028 }
32029
32030
32031 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32032 PyObject *resultobj = 0;
32033 wxDataObject *arg1 = (wxDataObject *) 0 ;
32034 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32035 SwigValueWrapper<wxDataFormat > result;
32036 void *argp1 = 0 ;
32037 int res1 = 0 ;
32038 int val2 ;
32039 int ecode2 = 0 ;
32040 PyObject * obj0 = 0 ;
32041 PyObject * obj1 = 0 ;
32042 char * kwnames[] = {
32043 (char *) "self",(char *) "dir", NULL
32044 };
32045
32046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32048 if (!SWIG_IsOK(res1)) {
32049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32050 }
32051 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32052 if (obj1) {
32053 ecode2 = SWIG_AsVal_int(obj1, &val2);
32054 if (!SWIG_IsOK(ecode2)) {
32055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32056 }
32057 arg2 = static_cast< wxDataObject::Direction >(val2);
32058 }
32059 {
32060 PyThreadState* __tstate = wxPyBeginAllowThreads();
32061 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32066 return resultobj;
32067 fail:
32068 return NULL;
32069 }
32070
32071
32072 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32073 PyObject *resultobj = 0;
32074 wxDataObject *arg1 = (wxDataObject *) 0 ;
32075 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32076 size_t result;
32077 void *argp1 = 0 ;
32078 int res1 = 0 ;
32079 int val2 ;
32080 int ecode2 = 0 ;
32081 PyObject * obj0 = 0 ;
32082 PyObject * obj1 = 0 ;
32083 char * kwnames[] = {
32084 (char *) "self",(char *) "dir", NULL
32085 };
32086
32087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32089 if (!SWIG_IsOK(res1)) {
32090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32091 }
32092 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32093 if (obj1) {
32094 ecode2 = SWIG_AsVal_int(obj1, &val2);
32095 if (!SWIG_IsOK(ecode2)) {
32096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32097 }
32098 arg2 = static_cast< wxDataObject::Direction >(val2);
32099 }
32100 {
32101 PyThreadState* __tstate = wxPyBeginAllowThreads();
32102 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32103 wxPyEndAllowThreads(__tstate);
32104 if (PyErr_Occurred()) SWIG_fail;
32105 }
32106 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32107 return resultobj;
32108 fail:
32109 return NULL;
32110 }
32111
32112
32113 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32114 PyObject *resultobj = 0;
32115 wxDataObject *arg1 = (wxDataObject *) 0 ;
32116 wxDataFormat *arg2 = 0 ;
32117 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32118 bool result;
32119 void *argp1 = 0 ;
32120 int res1 = 0 ;
32121 void *argp2 = 0 ;
32122 int res2 = 0 ;
32123 int val3 ;
32124 int ecode3 = 0 ;
32125 PyObject * obj0 = 0 ;
32126 PyObject * obj1 = 0 ;
32127 PyObject * obj2 = 0 ;
32128 char * kwnames[] = {
32129 (char *) "self",(char *) "format",(char *) "dir", NULL
32130 };
32131
32132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32134 if (!SWIG_IsOK(res1)) {
32135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32136 }
32137 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32138 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32139 if (!SWIG_IsOK(res2)) {
32140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32141 }
32142 if (!argp2) {
32143 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32144 }
32145 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32146 if (obj2) {
32147 ecode3 = SWIG_AsVal_int(obj2, &val3);
32148 if (!SWIG_IsOK(ecode3)) {
32149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32150 }
32151 arg3 = static_cast< wxDataObject::Direction >(val3);
32152 }
32153 {
32154 PyThreadState* __tstate = wxPyBeginAllowThreads();
32155 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32156 wxPyEndAllowThreads(__tstate);
32157 if (PyErr_Occurred()) SWIG_fail;
32158 }
32159 {
32160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32161 }
32162 return resultobj;
32163 fail:
32164 return NULL;
32165 }
32166
32167
32168 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32169 PyObject *resultobj = 0;
32170 wxDataObject *arg1 = (wxDataObject *) 0 ;
32171 wxDataFormat *arg2 = 0 ;
32172 size_t result;
32173 void *argp1 = 0 ;
32174 int res1 = 0 ;
32175 void *argp2 = 0 ;
32176 int res2 = 0 ;
32177 PyObject * obj0 = 0 ;
32178 PyObject * obj1 = 0 ;
32179 char * kwnames[] = {
32180 (char *) "self",(char *) "format", NULL
32181 };
32182
32183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32185 if (!SWIG_IsOK(res1)) {
32186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32187 }
32188 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32190 if (!SWIG_IsOK(res2)) {
32191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32192 }
32193 if (!argp2) {
32194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32195 }
32196 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32197 {
32198 PyThreadState* __tstate = wxPyBeginAllowThreads();
32199 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32200 wxPyEndAllowThreads(__tstate);
32201 if (PyErr_Occurred()) SWIG_fail;
32202 }
32203 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32204 return resultobj;
32205 fail:
32206 return NULL;
32207 }
32208
32209
32210 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32211 PyObject *resultobj = 0;
32212 wxDataObject *arg1 = (wxDataObject *) 0 ;
32213 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32214 PyObject *result = 0 ;
32215 void *argp1 = 0 ;
32216 int res1 = 0 ;
32217 int val2 ;
32218 int ecode2 = 0 ;
32219 PyObject * obj0 = 0 ;
32220 PyObject * obj1 = 0 ;
32221 char * kwnames[] = {
32222 (char *) "self",(char *) "dir", NULL
32223 };
32224
32225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32227 if (!SWIG_IsOK(res1)) {
32228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32229 }
32230 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32231 if (obj1) {
32232 ecode2 = SWIG_AsVal_int(obj1, &val2);
32233 if (!SWIG_IsOK(ecode2)) {
32234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32235 }
32236 arg2 = static_cast< wxDataObject::Direction >(val2);
32237 }
32238 {
32239 PyThreadState* __tstate = wxPyBeginAllowThreads();
32240 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32241 wxPyEndAllowThreads(__tstate);
32242 if (PyErr_Occurred()) SWIG_fail;
32243 }
32244 resultobj = result;
32245 return resultobj;
32246 fail:
32247 return NULL;
32248 }
32249
32250
32251 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32252 PyObject *resultobj = 0;
32253 wxDataObject *arg1 = (wxDataObject *) 0 ;
32254 wxDataFormat *arg2 = 0 ;
32255 PyObject *result = 0 ;
32256 void *argp1 = 0 ;
32257 int res1 = 0 ;
32258 void *argp2 = 0 ;
32259 int res2 = 0 ;
32260 PyObject * obj0 = 0 ;
32261 PyObject * obj1 = 0 ;
32262 char * kwnames[] = {
32263 (char *) "self",(char *) "format", NULL
32264 };
32265
32266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32268 if (!SWIG_IsOK(res1)) {
32269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32270 }
32271 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32273 if (!SWIG_IsOK(res2)) {
32274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32275 }
32276 if (!argp2) {
32277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32278 }
32279 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32280 {
32281 PyThreadState* __tstate = wxPyBeginAllowThreads();
32282 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32283 wxPyEndAllowThreads(__tstate);
32284 if (PyErr_Occurred()) SWIG_fail;
32285 }
32286 resultobj = result;
32287 return resultobj;
32288 fail:
32289 return NULL;
32290 }
32291
32292
32293 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32294 PyObject *resultobj = 0;
32295 wxDataObject *arg1 = (wxDataObject *) 0 ;
32296 wxDataFormat *arg2 = 0 ;
32297 PyObject *arg3 = (PyObject *) 0 ;
32298 bool result;
32299 void *argp1 = 0 ;
32300 int res1 = 0 ;
32301 void *argp2 = 0 ;
32302 int res2 = 0 ;
32303 PyObject * obj0 = 0 ;
32304 PyObject * obj1 = 0 ;
32305 PyObject * obj2 = 0 ;
32306 char * kwnames[] = {
32307 (char *) "self",(char *) "format",(char *) "data", NULL
32308 };
32309
32310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32312 if (!SWIG_IsOK(res1)) {
32313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32314 }
32315 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32316 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32317 if (!SWIG_IsOK(res2)) {
32318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32319 }
32320 if (!argp2) {
32321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32322 }
32323 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32324 arg3 = obj2;
32325 {
32326 PyThreadState* __tstate = wxPyBeginAllowThreads();
32327 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32328 wxPyEndAllowThreads(__tstate);
32329 if (PyErr_Occurred()) SWIG_fail;
32330 }
32331 {
32332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32333 }
32334 return resultobj;
32335 fail:
32336 return NULL;
32337 }
32338
32339
32340 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32341 PyObject *obj;
32342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32343 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32344 return SWIG_Py_Void();
32345 }
32346
32347 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32348 PyObject *resultobj = 0;
32349 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32350 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32351 wxDataObjectSimple *result = 0 ;
32352 void *argp1 = 0 ;
32353 int res1 = 0 ;
32354 PyObject * obj0 = 0 ;
32355 char * kwnames[] = {
32356 (char *) "format", NULL
32357 };
32358
32359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32360 if (obj0) {
32361 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32362 if (!SWIG_IsOK(res1)) {
32363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32364 }
32365 if (!argp1) {
32366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32367 }
32368 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32369 }
32370 {
32371 PyThreadState* __tstate = wxPyBeginAllowThreads();
32372 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32373 wxPyEndAllowThreads(__tstate);
32374 if (PyErr_Occurred()) SWIG_fail;
32375 }
32376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32377 return resultobj;
32378 fail:
32379 return NULL;
32380 }
32381
32382
32383 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32384 PyObject *resultobj = 0;
32385 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32386 wxDataFormat *result = 0 ;
32387 void *argp1 = 0 ;
32388 int res1 = 0 ;
32389 PyObject *swig_obj[1] ;
32390
32391 if (!args) SWIG_fail;
32392 swig_obj[0] = args;
32393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32394 if (!SWIG_IsOK(res1)) {
32395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32396 }
32397 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32398 {
32399 PyThreadState* __tstate = wxPyBeginAllowThreads();
32400 {
32401 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32402 result = (wxDataFormat *) &_result_ref;
32403 }
32404 wxPyEndAllowThreads(__tstate);
32405 if (PyErr_Occurred()) SWIG_fail;
32406 }
32407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32408 return resultobj;
32409 fail:
32410 return NULL;
32411 }
32412
32413
32414 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32415 PyObject *resultobj = 0;
32416 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32417 wxDataFormat *arg2 = 0 ;
32418 void *argp1 = 0 ;
32419 int res1 = 0 ;
32420 void *argp2 = 0 ;
32421 int res2 = 0 ;
32422 PyObject * obj0 = 0 ;
32423 PyObject * obj1 = 0 ;
32424 char * kwnames[] = {
32425 (char *) "self",(char *) "format", NULL
32426 };
32427
32428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32430 if (!SWIG_IsOK(res1)) {
32431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32432 }
32433 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32434 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32435 if (!SWIG_IsOK(res2)) {
32436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32437 }
32438 if (!argp2) {
32439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32440 }
32441 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 resultobj = SWIG_Py_Void();
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 PyObject *resultobj = 0;
32457 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32458 size_t result;
32459 void *argp1 = 0 ;
32460 int res1 = 0 ;
32461 PyObject *swig_obj[1] ;
32462
32463 if (!args) SWIG_fail;
32464 swig_obj[0] = args;
32465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32466 if (!SWIG_IsOK(res1)) {
32467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32468 }
32469 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32477 return resultobj;
32478 fail:
32479 return NULL;
32480 }
32481
32482
32483 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32484 PyObject *resultobj = 0;
32485 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32486 PyObject *result = 0 ;
32487 void *argp1 = 0 ;
32488 int res1 = 0 ;
32489 PyObject *swig_obj[1] ;
32490
32491 if (!args) SWIG_fail;
32492 swig_obj[0] = args;
32493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32494 if (!SWIG_IsOK(res1)) {
32495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32496 }
32497 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32498 {
32499 PyThreadState* __tstate = wxPyBeginAllowThreads();
32500 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32501 wxPyEndAllowThreads(__tstate);
32502 if (PyErr_Occurred()) SWIG_fail;
32503 }
32504 resultobj = result;
32505 return resultobj;
32506 fail:
32507 return NULL;
32508 }
32509
32510
32511 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32512 PyObject *resultobj = 0;
32513 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32514 PyObject *arg2 = (PyObject *) 0 ;
32515 bool result;
32516 void *argp1 = 0 ;
32517 int res1 = 0 ;
32518 PyObject * obj0 = 0 ;
32519 PyObject * obj1 = 0 ;
32520 char * kwnames[] = {
32521 (char *) "self",(char *) "data", NULL
32522 };
32523
32524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32526 if (!SWIG_IsOK(res1)) {
32527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32528 }
32529 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32530 arg2 = obj1;
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 {
32538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32539 }
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *obj;
32548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32549 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32550 return SWIG_Py_Void();
32551 }
32552
32553 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32554 return SWIG_Python_InitShadowInstance(args);
32555 }
32556
32557 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32558 PyObject *resultobj = 0;
32559 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32560 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32561 wxPyDataObjectSimple *result = 0 ;
32562 void *argp1 = 0 ;
32563 int res1 = 0 ;
32564 PyObject * obj0 = 0 ;
32565 char * kwnames[] = {
32566 (char *) "format", NULL
32567 };
32568
32569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32570 if (obj0) {
32571 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32572 if (!SWIG_IsOK(res1)) {
32573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32574 }
32575 if (!argp1) {
32576 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32577 }
32578 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32579 }
32580 {
32581 PyThreadState* __tstate = wxPyBeginAllowThreads();
32582 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32594 PyObject *resultobj = 0;
32595 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32596 PyObject *arg2 = (PyObject *) 0 ;
32597 PyObject *arg3 = (PyObject *) 0 ;
32598 void *argp1 = 0 ;
32599 int res1 = 0 ;
32600 PyObject * obj0 = 0 ;
32601 PyObject * obj1 = 0 ;
32602 PyObject * obj2 = 0 ;
32603 char * kwnames[] = {
32604 (char *) "self",(char *) "self",(char *) "_class", NULL
32605 };
32606
32607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32609 if (!SWIG_IsOK(res1)) {
32610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32611 }
32612 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32613 arg2 = obj1;
32614 arg3 = obj2;
32615 {
32616 PyThreadState* __tstate = wxPyBeginAllowThreads();
32617 (arg1)->_setCallbackInfo(arg2,arg3);
32618 wxPyEndAllowThreads(__tstate);
32619 if (PyErr_Occurred()) SWIG_fail;
32620 }
32621 resultobj = SWIG_Py_Void();
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32629 PyObject *obj;
32630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32631 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32632 return SWIG_Py_Void();
32633 }
32634
32635 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32636 return SWIG_Python_InitShadowInstance(args);
32637 }
32638
32639 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32640 PyObject *resultobj = 0;
32641 wxDataObjectComposite *result = 0 ;
32642
32643 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32647 wxPyEndAllowThreads(__tstate);
32648 if (PyErr_Occurred()) SWIG_fail;
32649 }
32650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32651 return resultobj;
32652 fail:
32653 return NULL;
32654 }
32655
32656
32657 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32658 PyObject *resultobj = 0;
32659 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32660 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32661 bool arg3 = (bool) false ;
32662 void *argp1 = 0 ;
32663 int res1 = 0 ;
32664 int res2 = 0 ;
32665 bool val3 ;
32666 int ecode3 = 0 ;
32667 PyObject * obj0 = 0 ;
32668 PyObject * obj1 = 0 ;
32669 PyObject * obj2 = 0 ;
32670 char * kwnames[] = {
32671 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32672 };
32673
32674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32676 if (!SWIG_IsOK(res1)) {
32677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32678 }
32679 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32680 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32681 if (!SWIG_IsOK(res2)) {
32682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32683 }
32684 if (obj2) {
32685 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32686 if (!SWIG_IsOK(ecode3)) {
32687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32688 }
32689 arg3 = static_cast< bool >(val3);
32690 }
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 (arg1)->Add(arg2,arg3);
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 resultobj = SWIG_Py_Void();
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32705 PyObject *resultobj = 0;
32706 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32707 SwigValueWrapper<wxDataFormat > result;
32708 void *argp1 = 0 ;
32709 int res1 = 0 ;
32710 PyObject *swig_obj[1] ;
32711
32712 if (!args) SWIG_fail;
32713 swig_obj[0] = args;
32714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32715 if (!SWIG_IsOK(res1)) {
32716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32717 }
32718 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32719 {
32720 PyThreadState* __tstate = wxPyBeginAllowThreads();
32721 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32722 wxPyEndAllowThreads(__tstate);
32723 if (PyErr_Occurred()) SWIG_fail;
32724 }
32725 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32726 return resultobj;
32727 fail:
32728 return NULL;
32729 }
32730
32731
32732 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32733 PyObject *obj;
32734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32735 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32736 return SWIG_Py_Void();
32737 }
32738
32739 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32740 return SWIG_Python_InitShadowInstance(args);
32741 }
32742
32743 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32744 PyObject *resultobj = 0;
32745 wxString const &arg1_defvalue = wxPyEmptyString ;
32746 wxString *arg1 = (wxString *) &arg1_defvalue ;
32747 wxTextDataObject *result = 0 ;
32748 bool temp1 = false ;
32749 PyObject * obj0 = 0 ;
32750 char * kwnames[] = {
32751 (char *) "text", NULL
32752 };
32753
32754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32755 if (obj0) {
32756 {
32757 arg1 = wxString_in_helper(obj0);
32758 if (arg1 == NULL) SWIG_fail;
32759 temp1 = true;
32760 }
32761 }
32762 {
32763 PyThreadState* __tstate = wxPyBeginAllowThreads();
32764 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32765 wxPyEndAllowThreads(__tstate);
32766 if (PyErr_Occurred()) SWIG_fail;
32767 }
32768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32769 {
32770 if (temp1)
32771 delete arg1;
32772 }
32773 return resultobj;
32774 fail:
32775 {
32776 if (temp1)
32777 delete arg1;
32778 }
32779 return NULL;
32780 }
32781
32782
32783 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32784 PyObject *resultobj = 0;
32785 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32786 size_t result;
32787 void *argp1 = 0 ;
32788 int res1 = 0 ;
32789 PyObject *swig_obj[1] ;
32790
32791 if (!args) SWIG_fail;
32792 swig_obj[0] = args;
32793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32794 if (!SWIG_IsOK(res1)) {
32795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32796 }
32797 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32798 {
32799 PyThreadState* __tstate = wxPyBeginAllowThreads();
32800 result = (size_t)(arg1)->GetTextLength();
32801 wxPyEndAllowThreads(__tstate);
32802 if (PyErr_Occurred()) SWIG_fail;
32803 }
32804 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32805 return resultobj;
32806 fail:
32807 return NULL;
32808 }
32809
32810
32811 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32812 PyObject *resultobj = 0;
32813 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32814 wxString result;
32815 void *argp1 = 0 ;
32816 int res1 = 0 ;
32817 PyObject *swig_obj[1] ;
32818
32819 if (!args) SWIG_fail;
32820 swig_obj[0] = args;
32821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32822 if (!SWIG_IsOK(res1)) {
32823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32824 }
32825 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32826 {
32827 PyThreadState* __tstate = wxPyBeginAllowThreads();
32828 result = (arg1)->GetText();
32829 wxPyEndAllowThreads(__tstate);
32830 if (PyErr_Occurred()) SWIG_fail;
32831 }
32832 {
32833 #if wxUSE_UNICODE
32834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32835 #else
32836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32837 #endif
32838 }
32839 return resultobj;
32840 fail:
32841 return NULL;
32842 }
32843
32844
32845 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32846 PyObject *resultobj = 0;
32847 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32848 wxString *arg2 = 0 ;
32849 void *argp1 = 0 ;
32850 int res1 = 0 ;
32851 bool temp2 = false ;
32852 PyObject * obj0 = 0 ;
32853 PyObject * obj1 = 0 ;
32854 char * kwnames[] = {
32855 (char *) "self",(char *) "text", NULL
32856 };
32857
32858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32860 if (!SWIG_IsOK(res1)) {
32861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32862 }
32863 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32864 {
32865 arg2 = wxString_in_helper(obj1);
32866 if (arg2 == NULL) SWIG_fail;
32867 temp2 = true;
32868 }
32869 {
32870 PyThreadState* __tstate = wxPyBeginAllowThreads();
32871 (arg1)->SetText((wxString const &)*arg2);
32872 wxPyEndAllowThreads(__tstate);
32873 if (PyErr_Occurred()) SWIG_fail;
32874 }
32875 resultobj = SWIG_Py_Void();
32876 {
32877 if (temp2)
32878 delete arg2;
32879 }
32880 return resultobj;
32881 fail:
32882 {
32883 if (temp2)
32884 delete arg2;
32885 }
32886 return NULL;
32887 }
32888
32889
32890 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32891 PyObject *obj;
32892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32893 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32894 return SWIG_Py_Void();
32895 }
32896
32897 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32898 return SWIG_Python_InitShadowInstance(args);
32899 }
32900
32901 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32902 PyObject *resultobj = 0;
32903 wxString const &arg1_defvalue = wxPyEmptyString ;
32904 wxString *arg1 = (wxString *) &arg1_defvalue ;
32905 wxPyTextDataObject *result = 0 ;
32906 bool temp1 = false ;
32907 PyObject * obj0 = 0 ;
32908 char * kwnames[] = {
32909 (char *) "text", NULL
32910 };
32911
32912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32913 if (obj0) {
32914 {
32915 arg1 = wxString_in_helper(obj0);
32916 if (arg1 == NULL) SWIG_fail;
32917 temp1 = true;
32918 }
32919 }
32920 {
32921 PyThreadState* __tstate = wxPyBeginAllowThreads();
32922 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32923 wxPyEndAllowThreads(__tstate);
32924 if (PyErr_Occurred()) SWIG_fail;
32925 }
32926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32927 {
32928 if (temp1)
32929 delete arg1;
32930 }
32931 return resultobj;
32932 fail:
32933 {
32934 if (temp1)
32935 delete arg1;
32936 }
32937 return NULL;
32938 }
32939
32940
32941 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32942 PyObject *resultobj = 0;
32943 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32944 PyObject *arg2 = (PyObject *) 0 ;
32945 PyObject *arg3 = (PyObject *) 0 ;
32946 void *argp1 = 0 ;
32947 int res1 = 0 ;
32948 PyObject * obj0 = 0 ;
32949 PyObject * obj1 = 0 ;
32950 PyObject * obj2 = 0 ;
32951 char * kwnames[] = {
32952 (char *) "self",(char *) "self",(char *) "_class", NULL
32953 };
32954
32955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32957 if (!SWIG_IsOK(res1)) {
32958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32959 }
32960 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32961 arg2 = obj1;
32962 arg3 = obj2;
32963 {
32964 PyThreadState* __tstate = wxPyBeginAllowThreads();
32965 (arg1)->_setCallbackInfo(arg2,arg3);
32966 wxPyEndAllowThreads(__tstate);
32967 if (PyErr_Occurred()) SWIG_fail;
32968 }
32969 resultobj = SWIG_Py_Void();
32970 return resultobj;
32971 fail:
32972 return NULL;
32973 }
32974
32975
32976 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32977 PyObject *obj;
32978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32979 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32980 return SWIG_Py_Void();
32981 }
32982
32983 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32984 return SWIG_Python_InitShadowInstance(args);
32985 }
32986
32987 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32988 PyObject *resultobj = 0;
32989 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32990 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32991 wxBitmapDataObject *result = 0 ;
32992 void *argp1 = 0 ;
32993 int res1 = 0 ;
32994 PyObject * obj0 = 0 ;
32995 char * kwnames[] = {
32996 (char *) "bitmap", NULL
32997 };
32998
32999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33000 if (obj0) {
33001 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33002 if (!SWIG_IsOK(res1)) {
33003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33004 }
33005 if (!argp1) {
33006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33007 }
33008 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33009 }
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33013 wxPyEndAllowThreads(__tstate);
33014 if (PyErr_Occurred()) SWIG_fail;
33015 }
33016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33017 return resultobj;
33018 fail:
33019 return NULL;
33020 }
33021
33022
33023 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33024 PyObject *resultobj = 0;
33025 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33026 wxBitmap result;
33027 void *argp1 = 0 ;
33028 int res1 = 0 ;
33029 PyObject *swig_obj[1] ;
33030
33031 if (!args) SWIG_fail;
33032 swig_obj[0] = args;
33033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33034 if (!SWIG_IsOK(res1)) {
33035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33036 }
33037 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33038 {
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33041 wxPyEndAllowThreads(__tstate);
33042 if (PyErr_Occurred()) SWIG_fail;
33043 }
33044 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33045 return resultobj;
33046 fail:
33047 return NULL;
33048 }
33049
33050
33051 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33052 PyObject *resultobj = 0;
33053 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33054 wxBitmap *arg2 = 0 ;
33055 void *argp1 = 0 ;
33056 int res1 = 0 ;
33057 void *argp2 = 0 ;
33058 int res2 = 0 ;
33059 PyObject * obj0 = 0 ;
33060 PyObject * obj1 = 0 ;
33061 char * kwnames[] = {
33062 (char *) "self",(char *) "bitmap", NULL
33063 };
33064
33065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33067 if (!SWIG_IsOK(res1)) {
33068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33069 }
33070 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33071 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33072 if (!SWIG_IsOK(res2)) {
33073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33074 }
33075 if (!argp2) {
33076 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33077 }
33078 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33079 {
33080 PyThreadState* __tstate = wxPyBeginAllowThreads();
33081 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33082 wxPyEndAllowThreads(__tstate);
33083 if (PyErr_Occurred()) SWIG_fail;
33084 }
33085 resultobj = SWIG_Py_Void();
33086 return resultobj;
33087 fail:
33088 return NULL;
33089 }
33090
33091
33092 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33093 PyObject *obj;
33094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33095 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33096 return SWIG_Py_Void();
33097 }
33098
33099 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33100 return SWIG_Python_InitShadowInstance(args);
33101 }
33102
33103 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33104 PyObject *resultobj = 0;
33105 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33106 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33107 wxPyBitmapDataObject *result = 0 ;
33108 void *argp1 = 0 ;
33109 int res1 = 0 ;
33110 PyObject * obj0 = 0 ;
33111 char * kwnames[] = {
33112 (char *) "bitmap", NULL
33113 };
33114
33115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33116 if (obj0) {
33117 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33118 if (!SWIG_IsOK(res1)) {
33119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33120 }
33121 if (!argp1) {
33122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33123 }
33124 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33125 }
33126 {
33127 PyThreadState* __tstate = wxPyBeginAllowThreads();
33128 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33133 return resultobj;
33134 fail:
33135 return NULL;
33136 }
33137
33138
33139 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33140 PyObject *resultobj = 0;
33141 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33142 PyObject *arg2 = (PyObject *) 0 ;
33143 PyObject *arg3 = (PyObject *) 0 ;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 PyObject * obj0 = 0 ;
33147 PyObject * obj1 = 0 ;
33148 PyObject * obj2 = 0 ;
33149 char * kwnames[] = {
33150 (char *) "self",(char *) "self",(char *) "_class", NULL
33151 };
33152
33153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33155 if (!SWIG_IsOK(res1)) {
33156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33157 }
33158 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33159 arg2 = obj1;
33160 arg3 = obj2;
33161 {
33162 PyThreadState* __tstate = wxPyBeginAllowThreads();
33163 (arg1)->_setCallbackInfo(arg2,arg3);
33164 wxPyEndAllowThreads(__tstate);
33165 if (PyErr_Occurred()) SWIG_fail;
33166 }
33167 resultobj = SWIG_Py_Void();
33168 return resultobj;
33169 fail:
33170 return NULL;
33171 }
33172
33173
33174 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33175 PyObject *obj;
33176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33177 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33178 return SWIG_Py_Void();
33179 }
33180
33181 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33182 return SWIG_Python_InitShadowInstance(args);
33183 }
33184
33185 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33186 PyObject *resultobj = 0;
33187 wxFileDataObject *result = 0 ;
33188
33189 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33190 {
33191 PyThreadState* __tstate = wxPyBeginAllowThreads();
33192 result = (wxFileDataObject *)new wxFileDataObject();
33193 wxPyEndAllowThreads(__tstate);
33194 if (PyErr_Occurred()) SWIG_fail;
33195 }
33196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33197 return resultobj;
33198 fail:
33199 return NULL;
33200 }
33201
33202
33203 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33204 PyObject *resultobj = 0;
33205 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33206 wxArrayString *result = 0 ;
33207 void *argp1 = 0 ;
33208 int res1 = 0 ;
33209 PyObject *swig_obj[1] ;
33210
33211 if (!args) SWIG_fail;
33212 swig_obj[0] = args;
33213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33214 if (!SWIG_IsOK(res1)) {
33215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33216 }
33217 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33218 {
33219 PyThreadState* __tstate = wxPyBeginAllowThreads();
33220 {
33221 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33222 result = (wxArrayString *) &_result_ref;
33223 }
33224 wxPyEndAllowThreads(__tstate);
33225 if (PyErr_Occurred()) SWIG_fail;
33226 }
33227 {
33228 resultobj = wxArrayString2PyList_helper(*result);
33229 }
33230 return resultobj;
33231 fail:
33232 return NULL;
33233 }
33234
33235
33236 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33237 PyObject *resultobj = 0;
33238 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33239 wxString *arg2 = 0 ;
33240 void *argp1 = 0 ;
33241 int res1 = 0 ;
33242 bool temp2 = false ;
33243 PyObject * obj0 = 0 ;
33244 PyObject * obj1 = 0 ;
33245 char * kwnames[] = {
33246 (char *) "self",(char *) "filename", NULL
33247 };
33248
33249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33251 if (!SWIG_IsOK(res1)) {
33252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33253 }
33254 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33255 {
33256 arg2 = wxString_in_helper(obj1);
33257 if (arg2 == NULL) SWIG_fail;
33258 temp2 = true;
33259 }
33260 {
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 (arg1)->AddFile((wxString const &)*arg2);
33263 wxPyEndAllowThreads(__tstate);
33264 if (PyErr_Occurred()) SWIG_fail;
33265 }
33266 resultobj = SWIG_Py_Void();
33267 {
33268 if (temp2)
33269 delete arg2;
33270 }
33271 return resultobj;
33272 fail:
33273 {
33274 if (temp2)
33275 delete arg2;
33276 }
33277 return NULL;
33278 }
33279
33280
33281 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33282 PyObject *obj;
33283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33284 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33285 return SWIG_Py_Void();
33286 }
33287
33288 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33289 return SWIG_Python_InitShadowInstance(args);
33290 }
33291
33292 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33293 PyObject *resultobj = 0;
33294 wxDataFormat *arg1 = 0 ;
33295 wxCustomDataObject *result = 0 ;
33296 void *argp1 = 0 ;
33297 int res1 = 0 ;
33298
33299 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33301 if (!SWIG_IsOK(res1)) {
33302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33303 }
33304 if (!argp1) {
33305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33306 }
33307 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33315 return resultobj;
33316 fail:
33317 return NULL;
33318 }
33319
33320
33321 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33322 PyObject *resultobj = 0;
33323 wxString *arg1 = 0 ;
33324 wxCustomDataObject *result = 0 ;
33325 bool temp1 = false ;
33326
33327 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33328 {
33329 arg1 = wxString_in_helper(swig_obj[0]);
33330 if (arg1 == NULL) SWIG_fail;
33331 temp1 = true;
33332 }
33333 {
33334 PyThreadState* __tstate = wxPyBeginAllowThreads();
33335 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33336 wxPyEndAllowThreads(__tstate);
33337 if (PyErr_Occurred()) SWIG_fail;
33338 }
33339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33340 {
33341 if (temp1)
33342 delete arg1;
33343 }
33344 return resultobj;
33345 fail:
33346 {
33347 if (temp1)
33348 delete arg1;
33349 }
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33355 PyObject *resultobj = 0;
33356 wxCustomDataObject *result = 0 ;
33357
33358 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33359 {
33360 PyThreadState* __tstate = wxPyBeginAllowThreads();
33361 result = (wxCustomDataObject *)new wxCustomDataObject();
33362 wxPyEndAllowThreads(__tstate);
33363 if (PyErr_Occurred()) SWIG_fail;
33364 }
33365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33366 return resultobj;
33367 fail:
33368 return NULL;
33369 }
33370
33371
33372 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33373 int argc;
33374 PyObject *argv[2];
33375
33376 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33377 --argc;
33378 if (argc == 0) {
33379 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33380 }
33381 if (argc == 1) {
33382 int _v = 0;
33383 {
33384 {
33385 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33386 }
33387 }
33388 if (!_v) goto check_2;
33389 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33390 }
33391 check_2:
33392
33393 if (argc == 1) {
33394 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33395 }
33396
33397 fail:
33398 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33399 return NULL;
33400 }
33401
33402
33403 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33404 PyObject *resultobj = 0;
33405 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33406 PyObject *arg2 = (PyObject *) 0 ;
33407 bool result;
33408 void *argp1 = 0 ;
33409 int res1 = 0 ;
33410 PyObject * obj0 = 0 ;
33411 PyObject * obj1 = 0 ;
33412 char * kwnames[] = {
33413 (char *) "self",(char *) "data", NULL
33414 };
33415
33416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33418 if (!SWIG_IsOK(res1)) {
33419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33420 }
33421 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33422 arg2 = obj1;
33423 {
33424 PyThreadState* __tstate = wxPyBeginAllowThreads();
33425 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 {
33430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33431 }
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33439 PyObject *resultobj = 0;
33440 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33441 size_t result;
33442 void *argp1 = 0 ;
33443 int res1 = 0 ;
33444 PyObject *swig_obj[1] ;
33445
33446 if (!args) SWIG_fail;
33447 swig_obj[0] = args;
33448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33449 if (!SWIG_IsOK(res1)) {
33450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33451 }
33452 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 result = (size_t)(arg1)->GetSize();
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33467 PyObject *resultobj = 0;
33468 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33469 PyObject *result = 0 ;
33470 void *argp1 = 0 ;
33471 int res1 = 0 ;
33472 PyObject *swig_obj[1] ;
33473
33474 if (!args) SWIG_fail;
33475 swig_obj[0] = args;
33476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33477 if (!SWIG_IsOK(res1)) {
33478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33479 }
33480 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33481 {
33482 PyThreadState* __tstate = wxPyBeginAllowThreads();
33483 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33484 wxPyEndAllowThreads(__tstate);
33485 if (PyErr_Occurred()) SWIG_fail;
33486 }
33487 resultobj = result;
33488 return resultobj;
33489 fail:
33490 return NULL;
33491 }
33492
33493
33494 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33495 PyObject *obj;
33496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33497 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33498 return SWIG_Py_Void();
33499 }
33500
33501 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33502 return SWIG_Python_InitShadowInstance(args);
33503 }
33504
33505 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33506 PyObject *resultobj = 0;
33507 wxString const &arg1_defvalue = wxPyEmptyString ;
33508 wxString *arg1 = (wxString *) &arg1_defvalue ;
33509 wxURLDataObject *result = 0 ;
33510 bool temp1 = false ;
33511 PyObject * obj0 = 0 ;
33512 char * kwnames[] = {
33513 (char *) "url", NULL
33514 };
33515
33516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33517 if (obj0) {
33518 {
33519 arg1 = wxString_in_helper(obj0);
33520 if (arg1 == NULL) SWIG_fail;
33521 temp1 = true;
33522 }
33523 }
33524 {
33525 PyThreadState* __tstate = wxPyBeginAllowThreads();
33526 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33527 wxPyEndAllowThreads(__tstate);
33528 if (PyErr_Occurred()) SWIG_fail;
33529 }
33530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33531 {
33532 if (temp1)
33533 delete arg1;
33534 }
33535 return resultobj;
33536 fail:
33537 {
33538 if (temp1)
33539 delete arg1;
33540 }
33541 return NULL;
33542 }
33543
33544
33545 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33546 PyObject *resultobj = 0;
33547 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33548 wxString result;
33549 void *argp1 = 0 ;
33550 int res1 = 0 ;
33551 PyObject *swig_obj[1] ;
33552
33553 if (!args) SWIG_fail;
33554 swig_obj[0] = args;
33555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33556 if (!SWIG_IsOK(res1)) {
33557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33558 }
33559 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33560 {
33561 PyThreadState* __tstate = wxPyBeginAllowThreads();
33562 result = (arg1)->GetURL();
33563 wxPyEndAllowThreads(__tstate);
33564 if (PyErr_Occurred()) SWIG_fail;
33565 }
33566 {
33567 #if wxUSE_UNICODE
33568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33569 #else
33570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33571 #endif
33572 }
33573 return resultobj;
33574 fail:
33575 return NULL;
33576 }
33577
33578
33579 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33580 PyObject *resultobj = 0;
33581 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33582 wxString *arg2 = 0 ;
33583 void *argp1 = 0 ;
33584 int res1 = 0 ;
33585 bool temp2 = false ;
33586 PyObject * obj0 = 0 ;
33587 PyObject * obj1 = 0 ;
33588 char * kwnames[] = {
33589 (char *) "self",(char *) "url", NULL
33590 };
33591
33592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33594 if (!SWIG_IsOK(res1)) {
33595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33596 }
33597 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33598 {
33599 arg2 = wxString_in_helper(obj1);
33600 if (arg2 == NULL) SWIG_fail;
33601 temp2 = true;
33602 }
33603 {
33604 PyThreadState* __tstate = wxPyBeginAllowThreads();
33605 (arg1)->SetURL((wxString const &)*arg2);
33606 wxPyEndAllowThreads(__tstate);
33607 if (PyErr_Occurred()) SWIG_fail;
33608 }
33609 resultobj = SWIG_Py_Void();
33610 {
33611 if (temp2)
33612 delete arg2;
33613 }
33614 return resultobj;
33615 fail:
33616 {
33617 if (temp2)
33618 delete arg2;
33619 }
33620 return NULL;
33621 }
33622
33623
33624 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33625 PyObject *obj;
33626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33627 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33628 return SWIG_Py_Void();
33629 }
33630
33631 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33632 return SWIG_Python_InitShadowInstance(args);
33633 }
33634
33635 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33636 PyObject *resultobj = 0;
33637 wxMetafileDataObject *result = 0 ;
33638
33639 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33640 {
33641 PyThreadState* __tstate = wxPyBeginAllowThreads();
33642 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33643 wxPyEndAllowThreads(__tstate);
33644 if (PyErr_Occurred()) SWIG_fail;
33645 }
33646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33647 return resultobj;
33648 fail:
33649 return NULL;
33650 }
33651
33652
33653 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33654 PyObject *resultobj = 0;
33655 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33656 wxMetafile *arg2 = 0 ;
33657 void *argp1 = 0 ;
33658 int res1 = 0 ;
33659 void *argp2 = 0 ;
33660 int res2 = 0 ;
33661 PyObject * obj0 = 0 ;
33662 PyObject * obj1 = 0 ;
33663 char * kwnames[] = {
33664 (char *) "self",(char *) "metafile", NULL
33665 };
33666
33667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33669 if (!SWIG_IsOK(res1)) {
33670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33671 }
33672 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33673 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33674 if (!SWIG_IsOK(res2)) {
33675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33676 }
33677 if (!argp2) {
33678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33679 }
33680 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33681 {
33682 PyThreadState* __tstate = wxPyBeginAllowThreads();
33683 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33684 wxPyEndAllowThreads(__tstate);
33685 if (PyErr_Occurred()) SWIG_fail;
33686 }
33687 resultobj = SWIG_Py_Void();
33688 return resultobj;
33689 fail:
33690 return NULL;
33691 }
33692
33693
33694 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33695 PyObject *resultobj = 0;
33696 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33697 wxMetafile result;
33698 void *argp1 = 0 ;
33699 int res1 = 0 ;
33700 PyObject *swig_obj[1] ;
33701
33702 if (!args) SWIG_fail;
33703 swig_obj[0] = args;
33704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33705 if (!SWIG_IsOK(res1)) {
33706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33707 }
33708 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33709 {
33710 PyThreadState* __tstate = wxPyBeginAllowThreads();
33711 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33712 wxPyEndAllowThreads(__tstate);
33713 if (PyErr_Occurred()) SWIG_fail;
33714 }
33715 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33716 return resultobj;
33717 fail:
33718 return NULL;
33719 }
33720
33721
33722 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33723 PyObject *obj;
33724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33725 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33726 return SWIG_Py_Void();
33727 }
33728
33729 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33730 return SWIG_Python_InitShadowInstance(args);
33731 }
33732
33733 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33734 PyObject *resultobj = 0;
33735 wxDragResult arg1 ;
33736 bool result;
33737 int val1 ;
33738 int ecode1 = 0 ;
33739 PyObject * obj0 = 0 ;
33740 char * kwnames[] = {
33741 (char *) "res", NULL
33742 };
33743
33744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33745 ecode1 = SWIG_AsVal_int(obj0, &val1);
33746 if (!SWIG_IsOK(ecode1)) {
33747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33748 }
33749 arg1 = static_cast< wxDragResult >(val1);
33750 {
33751 PyThreadState* __tstate = wxPyBeginAllowThreads();
33752 result = (bool)wxIsDragResultOk(arg1);
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 {
33757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33758 }
33759 return resultobj;
33760 fail:
33761 return NULL;
33762 }
33763
33764
33765 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33766 PyObject *resultobj = 0;
33767 wxWindow *arg1 = (wxWindow *) 0 ;
33768 wxCursor const &arg2_defvalue = wxNullCursor ;
33769 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33770 wxCursor const &arg3_defvalue = wxNullCursor ;
33771 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33772 wxCursor const &arg4_defvalue = wxNullCursor ;
33773 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33774 wxPyDropSource *result = 0 ;
33775 void *argp1 = 0 ;
33776 int res1 = 0 ;
33777 void *argp2 = 0 ;
33778 int res2 = 0 ;
33779 void *argp3 = 0 ;
33780 int res3 = 0 ;
33781 void *argp4 = 0 ;
33782 int res4 = 0 ;
33783 PyObject * obj0 = 0 ;
33784 PyObject * obj1 = 0 ;
33785 PyObject * obj2 = 0 ;
33786 PyObject * obj3 = 0 ;
33787 char * kwnames[] = {
33788 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33789 };
33790
33791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33793 if (!SWIG_IsOK(res1)) {
33794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33795 }
33796 arg1 = reinterpret_cast< wxWindow * >(argp1);
33797 if (obj1) {
33798 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33799 if (!SWIG_IsOK(res2)) {
33800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33801 }
33802 if (!argp2) {
33803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33804 }
33805 arg2 = reinterpret_cast< wxCursor * >(argp2);
33806 }
33807 if (obj2) {
33808 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33809 if (!SWIG_IsOK(res3)) {
33810 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33811 }
33812 if (!argp3) {
33813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33814 }
33815 arg3 = reinterpret_cast< wxCursor * >(argp3);
33816 }
33817 if (obj3) {
33818 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33819 if (!SWIG_IsOK(res4)) {
33820 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33821 }
33822 if (!argp4) {
33823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33824 }
33825 arg4 = reinterpret_cast< wxCursor * >(argp4);
33826 }
33827 {
33828 PyThreadState* __tstate = wxPyBeginAllowThreads();
33829 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33830 wxPyEndAllowThreads(__tstate);
33831 if (PyErr_Occurred()) SWIG_fail;
33832 }
33833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33834 return resultobj;
33835 fail:
33836 return NULL;
33837 }
33838
33839
33840 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33841 PyObject *resultobj = 0;
33842 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33843 PyObject *arg2 = (PyObject *) 0 ;
33844 PyObject *arg3 = (PyObject *) 0 ;
33845 int arg4 ;
33846 void *argp1 = 0 ;
33847 int res1 = 0 ;
33848 int val4 ;
33849 int ecode4 = 0 ;
33850 PyObject * obj0 = 0 ;
33851 PyObject * obj1 = 0 ;
33852 PyObject * obj2 = 0 ;
33853 PyObject * obj3 = 0 ;
33854 char * kwnames[] = {
33855 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33856 };
33857
33858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33860 if (!SWIG_IsOK(res1)) {
33861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33862 }
33863 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33864 arg2 = obj1;
33865 arg3 = obj2;
33866 ecode4 = SWIG_AsVal_int(obj3, &val4);
33867 if (!SWIG_IsOK(ecode4)) {
33868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33869 }
33870 arg4 = static_cast< int >(val4);
33871 {
33872 PyThreadState* __tstate = wxPyBeginAllowThreads();
33873 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33874 wxPyEndAllowThreads(__tstate);
33875 if (PyErr_Occurred()) SWIG_fail;
33876 }
33877 resultobj = SWIG_Py_Void();
33878 return resultobj;
33879 fail:
33880 return NULL;
33881 }
33882
33883
33884 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33885 PyObject *resultobj = 0;
33886 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 PyObject *swig_obj[1] ;
33890
33891 if (!args) SWIG_fail;
33892 swig_obj[0] = args;
33893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33894 if (!SWIG_IsOK(res1)) {
33895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33896 }
33897 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 delete arg1;
33901
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 resultobj = SWIG_Py_Void();
33906 return resultobj;
33907 fail:
33908 return NULL;
33909 }
33910
33911
33912 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33913 PyObject *resultobj = 0;
33914 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33915 wxDataObject *arg2 = 0 ;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 void *argp2 = 0 ;
33919 int res2 = 0 ;
33920 PyObject * obj0 = 0 ;
33921 PyObject * obj1 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "data", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33928 if (!SWIG_IsOK(res1)) {
33929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33930 }
33931 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33932 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33933 if (!SWIG_IsOK(res2)) {
33934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33935 }
33936 if (!argp2) {
33937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33938 }
33939 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33940 {
33941 PyThreadState* __tstate = wxPyBeginAllowThreads();
33942 (arg1)->SetData(*arg2);
33943 wxPyEndAllowThreads(__tstate);
33944 if (PyErr_Occurred()) SWIG_fail;
33945 }
33946 resultobj = SWIG_Py_Void();
33947 return resultobj;
33948 fail:
33949 return NULL;
33950 }
33951
33952
33953 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33954 PyObject *resultobj = 0;
33955 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33956 wxDataObject *result = 0 ;
33957 void *argp1 = 0 ;
33958 int res1 = 0 ;
33959 PyObject *swig_obj[1] ;
33960
33961 if (!args) SWIG_fail;
33962 swig_obj[0] = args;
33963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33966 }
33967 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33968 {
33969 PyThreadState* __tstate = wxPyBeginAllowThreads();
33970 result = (wxDataObject *)(arg1)->GetDataObject();
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj = 0;
33983 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33984 wxDragResult arg2 ;
33985 wxCursor *arg3 = 0 ;
33986 void *argp1 = 0 ;
33987 int res1 = 0 ;
33988 int val2 ;
33989 int ecode2 = 0 ;
33990 void *argp3 = 0 ;
33991 int res3 = 0 ;
33992 PyObject * obj0 = 0 ;
33993 PyObject * obj1 = 0 ;
33994 PyObject * obj2 = 0 ;
33995 char * kwnames[] = {
33996 (char *) "self",(char *) "res",(char *) "cursor", NULL
33997 };
33998
33999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34001 if (!SWIG_IsOK(res1)) {
34002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34003 }
34004 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34005 ecode2 = SWIG_AsVal_int(obj1, &val2);
34006 if (!SWIG_IsOK(ecode2)) {
34007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34008 }
34009 arg2 = static_cast< wxDragResult >(val2);
34010 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34011 if (!SWIG_IsOK(res3)) {
34012 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34013 }
34014 if (!argp3) {
34015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34016 }
34017 arg3 = reinterpret_cast< wxCursor * >(argp3);
34018 {
34019 PyThreadState* __tstate = wxPyBeginAllowThreads();
34020 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34021 wxPyEndAllowThreads(__tstate);
34022 if (PyErr_Occurred()) SWIG_fail;
34023 }
34024 resultobj = SWIG_Py_Void();
34025 return resultobj;
34026 fail:
34027 return NULL;
34028 }
34029
34030
34031 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34032 PyObject *resultobj = 0;
34033 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34034 int arg2 = (int) wxDrag_CopyOnly ;
34035 wxDragResult result;
34036 void *argp1 = 0 ;
34037 int res1 = 0 ;
34038 int val2 ;
34039 int ecode2 = 0 ;
34040 PyObject * obj0 = 0 ;
34041 PyObject * obj1 = 0 ;
34042 char * kwnames[] = {
34043 (char *) "self",(char *) "flags", NULL
34044 };
34045
34046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34048 if (!SWIG_IsOK(res1)) {
34049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34050 }
34051 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34052 if (obj1) {
34053 ecode2 = SWIG_AsVal_int(obj1, &val2);
34054 if (!SWIG_IsOK(ecode2)) {
34055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34056 }
34057 arg2 = static_cast< int >(val2);
34058 }
34059 {
34060 PyThreadState* __tstate = wxPyBeginAllowThreads();
34061 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34062 wxPyEndAllowThreads(__tstate);
34063 if (PyErr_Occurred()) SWIG_fail;
34064 }
34065 resultobj = SWIG_From_int(static_cast< int >(result));
34066 return resultobj;
34067 fail:
34068 return NULL;
34069 }
34070
34071
34072 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34073 PyObject *resultobj = 0;
34074 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34075 wxDragResult arg2 ;
34076 bool result;
34077 void *argp1 = 0 ;
34078 int res1 = 0 ;
34079 int val2 ;
34080 int ecode2 = 0 ;
34081 PyObject * obj0 = 0 ;
34082 PyObject * obj1 = 0 ;
34083 char * kwnames[] = {
34084 (char *) "self",(char *) "effect", NULL
34085 };
34086
34087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34089 if (!SWIG_IsOK(res1)) {
34090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34091 }
34092 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34093 ecode2 = SWIG_AsVal_int(obj1, &val2);
34094 if (!SWIG_IsOK(ecode2)) {
34095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34096 }
34097 arg2 = static_cast< wxDragResult >(val2);
34098 {
34099 PyThreadState* __tstate = wxPyBeginAllowThreads();
34100 result = (bool)(arg1)->GiveFeedback(arg2);
34101 wxPyEndAllowThreads(__tstate);
34102 if (PyErr_Occurred()) SWIG_fail;
34103 }
34104 {
34105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34106 }
34107 return resultobj;
34108 fail:
34109 return NULL;
34110 }
34111
34112
34113 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34114 PyObject *obj;
34115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34116 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34117 return SWIG_Py_Void();
34118 }
34119
34120 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34121 return SWIG_Python_InitShadowInstance(args);
34122 }
34123
34124 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34125 PyObject *resultobj = 0;
34126 wxDataObject *arg1 = (wxDataObject *) NULL ;
34127 wxPyDropTarget *result = 0 ;
34128 int res1 = 0 ;
34129 PyObject * obj0 = 0 ;
34130 char * kwnames[] = {
34131 (char *) "dataObject", NULL
34132 };
34133
34134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34135 if (obj0) {
34136 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34137 if (!SWIG_IsOK(res1)) {
34138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34139 }
34140 }
34141 {
34142 PyThreadState* __tstate = wxPyBeginAllowThreads();
34143 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34144 wxPyEndAllowThreads(__tstate);
34145 if (PyErr_Occurred()) SWIG_fail;
34146 }
34147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34148 return resultobj;
34149 fail:
34150 return NULL;
34151 }
34152
34153
34154 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34155 PyObject *resultobj = 0;
34156 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34157 PyObject *arg2 = (PyObject *) 0 ;
34158 PyObject *arg3 = (PyObject *) 0 ;
34159 void *argp1 = 0 ;
34160 int res1 = 0 ;
34161 PyObject * obj0 = 0 ;
34162 PyObject * obj1 = 0 ;
34163 PyObject * obj2 = 0 ;
34164 char * kwnames[] = {
34165 (char *) "self",(char *) "self",(char *) "_class", NULL
34166 };
34167
34168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34170 if (!SWIG_IsOK(res1)) {
34171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34172 }
34173 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34174 arg2 = obj1;
34175 arg3 = obj2;
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 (arg1)->_setCallbackInfo(arg2,arg3);
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_Py_Void();
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34190 PyObject *resultobj = 0;
34191 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34192 void *argp1 = 0 ;
34193 int res1 = 0 ;
34194 PyObject *swig_obj[1] ;
34195
34196 if (!args) SWIG_fail;
34197 swig_obj[0] = args;
34198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34199 if (!SWIG_IsOK(res1)) {
34200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34201 }
34202 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34203 {
34204 PyThreadState* __tstate = wxPyBeginAllowThreads();
34205 delete arg1;
34206
34207 wxPyEndAllowThreads(__tstate);
34208 if (PyErr_Occurred()) SWIG_fail;
34209 }
34210 resultobj = SWIG_Py_Void();
34211 return resultobj;
34212 fail:
34213 return NULL;
34214 }
34215
34216
34217 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34218 PyObject *resultobj = 0;
34219 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34220 wxDataObject *result = 0 ;
34221 void *argp1 = 0 ;
34222 int res1 = 0 ;
34223 PyObject *swig_obj[1] ;
34224
34225 if (!args) SWIG_fail;
34226 swig_obj[0] = args;
34227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34228 if (!SWIG_IsOK(res1)) {
34229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34230 }
34231 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34232 {
34233 PyThreadState* __tstate = wxPyBeginAllowThreads();
34234 result = (wxDataObject *)(arg1)->GetDataObject();
34235 wxPyEndAllowThreads(__tstate);
34236 if (PyErr_Occurred()) SWIG_fail;
34237 }
34238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34239 return resultobj;
34240 fail:
34241 return NULL;
34242 }
34243
34244
34245 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34246 PyObject *resultobj = 0;
34247 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34248 wxDataObject *arg2 = (wxDataObject *) 0 ;
34249 void *argp1 = 0 ;
34250 int res1 = 0 ;
34251 int res2 = 0 ;
34252 PyObject * obj0 = 0 ;
34253 PyObject * obj1 = 0 ;
34254 char * kwnames[] = {
34255 (char *) "self",(char *) "dataObject", NULL
34256 };
34257
34258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34260 if (!SWIG_IsOK(res1)) {
34261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34262 }
34263 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34264 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34265 if (!SWIG_IsOK(res2)) {
34266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34267 }
34268 {
34269 PyThreadState* __tstate = wxPyBeginAllowThreads();
34270 (arg1)->SetDataObject(arg2);
34271 wxPyEndAllowThreads(__tstate);
34272 if (PyErr_Occurred()) SWIG_fail;
34273 }
34274 resultobj = SWIG_Py_Void();
34275 return resultobj;
34276 fail:
34277 return NULL;
34278 }
34279
34280
34281 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34282 PyObject *resultobj = 0;
34283 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34284 int arg2 ;
34285 int arg3 ;
34286 wxDragResult arg4 ;
34287 wxDragResult result;
34288 void *argp1 = 0 ;
34289 int res1 = 0 ;
34290 int val2 ;
34291 int ecode2 = 0 ;
34292 int val3 ;
34293 int ecode3 = 0 ;
34294 int val4 ;
34295 int ecode4 = 0 ;
34296 PyObject * obj0 = 0 ;
34297 PyObject * obj1 = 0 ;
34298 PyObject * obj2 = 0 ;
34299 PyObject * obj3 = 0 ;
34300 char * kwnames[] = {
34301 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34302 };
34303
34304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34306 if (!SWIG_IsOK(res1)) {
34307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34308 }
34309 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34310 ecode2 = SWIG_AsVal_int(obj1, &val2);
34311 if (!SWIG_IsOK(ecode2)) {
34312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34313 }
34314 arg2 = static_cast< int >(val2);
34315 ecode3 = SWIG_AsVal_int(obj2, &val3);
34316 if (!SWIG_IsOK(ecode3)) {
34317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34318 }
34319 arg3 = static_cast< int >(val3);
34320 ecode4 = SWIG_AsVal_int(obj3, &val4);
34321 if (!SWIG_IsOK(ecode4)) {
34322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34323 }
34324 arg4 = static_cast< wxDragResult >(val4);
34325 {
34326 PyThreadState* __tstate = wxPyBeginAllowThreads();
34327 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34328 wxPyEndAllowThreads(__tstate);
34329 if (PyErr_Occurred()) SWIG_fail;
34330 }
34331 resultobj = SWIG_From_int(static_cast< int >(result));
34332 return resultobj;
34333 fail:
34334 return NULL;
34335 }
34336
34337
34338 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34339 PyObject *resultobj = 0;
34340 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34341 int arg2 ;
34342 int arg3 ;
34343 wxDragResult arg4 ;
34344 wxDragResult result;
34345 void *argp1 = 0 ;
34346 int res1 = 0 ;
34347 int val2 ;
34348 int ecode2 = 0 ;
34349 int val3 ;
34350 int ecode3 = 0 ;
34351 int val4 ;
34352 int ecode4 = 0 ;
34353 PyObject * obj0 = 0 ;
34354 PyObject * obj1 = 0 ;
34355 PyObject * obj2 = 0 ;
34356 PyObject * obj3 = 0 ;
34357 char * kwnames[] = {
34358 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34359 };
34360
34361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34363 if (!SWIG_IsOK(res1)) {
34364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34365 }
34366 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34367 ecode2 = SWIG_AsVal_int(obj1, &val2);
34368 if (!SWIG_IsOK(ecode2)) {
34369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34370 }
34371 arg2 = static_cast< int >(val2);
34372 ecode3 = SWIG_AsVal_int(obj2, &val3);
34373 if (!SWIG_IsOK(ecode3)) {
34374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34375 }
34376 arg3 = static_cast< int >(val3);
34377 ecode4 = SWIG_AsVal_int(obj3, &val4);
34378 if (!SWIG_IsOK(ecode4)) {
34379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34380 }
34381 arg4 = static_cast< wxDragResult >(val4);
34382 {
34383 PyThreadState* __tstate = wxPyBeginAllowThreads();
34384 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 resultobj = SWIG_From_int(static_cast< int >(result));
34389 return resultobj;
34390 fail:
34391 return NULL;
34392 }
34393
34394
34395 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34396 PyObject *resultobj = 0;
34397 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34398 void *argp1 = 0 ;
34399 int res1 = 0 ;
34400 PyObject *swig_obj[1] ;
34401
34402 if (!args) SWIG_fail;
34403 swig_obj[0] = args;
34404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34405 if (!SWIG_IsOK(res1)) {
34406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34407 }
34408 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34409 {
34410 PyThreadState* __tstate = wxPyBeginAllowThreads();
34411 (arg1)->OnLeave();
34412 wxPyEndAllowThreads(__tstate);
34413 if (PyErr_Occurred()) SWIG_fail;
34414 }
34415 resultobj = SWIG_Py_Void();
34416 return resultobj;
34417 fail:
34418 return NULL;
34419 }
34420
34421
34422 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34423 PyObject *resultobj = 0;
34424 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34425 int arg2 ;
34426 int arg3 ;
34427 bool result;
34428 void *argp1 = 0 ;
34429 int res1 = 0 ;
34430 int val2 ;
34431 int ecode2 = 0 ;
34432 int val3 ;
34433 int ecode3 = 0 ;
34434 PyObject * obj0 = 0 ;
34435 PyObject * obj1 = 0 ;
34436 PyObject * obj2 = 0 ;
34437 char * kwnames[] = {
34438 (char *) "self",(char *) "x",(char *) "y", NULL
34439 };
34440
34441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34443 if (!SWIG_IsOK(res1)) {
34444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34445 }
34446 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34447 ecode2 = SWIG_AsVal_int(obj1, &val2);
34448 if (!SWIG_IsOK(ecode2)) {
34449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34450 }
34451 arg2 = static_cast< int >(val2);
34452 ecode3 = SWIG_AsVal_int(obj2, &val3);
34453 if (!SWIG_IsOK(ecode3)) {
34454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34455 }
34456 arg3 = static_cast< int >(val3);
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 result = (bool)(arg1)->OnDrop(arg2,arg3);
34460 wxPyEndAllowThreads(__tstate);
34461 if (PyErr_Occurred()) SWIG_fail;
34462 }
34463 {
34464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34465 }
34466 return resultobj;
34467 fail:
34468 return NULL;
34469 }
34470
34471
34472 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34473 PyObject *resultobj = 0;
34474 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34475 bool result;
34476 void *argp1 = 0 ;
34477 int res1 = 0 ;
34478 PyObject *swig_obj[1] ;
34479
34480 if (!args) SWIG_fail;
34481 swig_obj[0] = args;
34482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34483 if (!SWIG_IsOK(res1)) {
34484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34485 }
34486 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34487 {
34488 PyThreadState* __tstate = wxPyBeginAllowThreads();
34489 result = (bool)(arg1)->GetData();
34490 wxPyEndAllowThreads(__tstate);
34491 if (PyErr_Occurred()) SWIG_fail;
34492 }
34493 {
34494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34495 }
34496 return resultobj;
34497 fail:
34498 return NULL;
34499 }
34500
34501
34502 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34503 PyObject *resultobj = 0;
34504 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34505 wxDragResult arg2 ;
34506 void *argp1 = 0 ;
34507 int res1 = 0 ;
34508 int val2 ;
34509 int ecode2 = 0 ;
34510 PyObject * obj0 = 0 ;
34511 PyObject * obj1 = 0 ;
34512 char * kwnames[] = {
34513 (char *) "self",(char *) "action", NULL
34514 };
34515
34516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34518 if (!SWIG_IsOK(res1)) {
34519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34520 }
34521 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34522 ecode2 = SWIG_AsVal_int(obj1, &val2);
34523 if (!SWIG_IsOK(ecode2)) {
34524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34525 }
34526 arg2 = static_cast< wxDragResult >(val2);
34527 {
34528 PyThreadState* __tstate = wxPyBeginAllowThreads();
34529 (arg1)->SetDefaultAction(arg2);
34530 wxPyEndAllowThreads(__tstate);
34531 if (PyErr_Occurred()) SWIG_fail;
34532 }
34533 resultobj = SWIG_Py_Void();
34534 return resultobj;
34535 fail:
34536 return NULL;
34537 }
34538
34539
34540 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34541 PyObject *resultobj = 0;
34542 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34543 wxDragResult result;
34544 void *argp1 = 0 ;
34545 int res1 = 0 ;
34546 PyObject *swig_obj[1] ;
34547
34548 if (!args) SWIG_fail;
34549 swig_obj[0] = args;
34550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34551 if (!SWIG_IsOK(res1)) {
34552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34553 }
34554 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34555 {
34556 PyThreadState* __tstate = wxPyBeginAllowThreads();
34557 result = (wxDragResult)(arg1)->GetDefaultAction();
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 resultobj = SWIG_From_int(static_cast< int >(result));
34562 return resultobj;
34563 fail:
34564 return NULL;
34565 }
34566
34567
34568 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34569 PyObject *obj;
34570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34571 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34572 return SWIG_Py_Void();
34573 }
34574
34575 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34576 return SWIG_Python_InitShadowInstance(args);
34577 }
34578
34579 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34580 PyObject *resultobj = 0;
34581 wxPyTextDropTarget *result = 0 ;
34582
34583 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34584 {
34585 PyThreadState* __tstate = wxPyBeginAllowThreads();
34586 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34591 return resultobj;
34592 fail:
34593 return NULL;
34594 }
34595
34596
34597 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34598 PyObject *resultobj = 0;
34599 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34600 PyObject *arg2 = (PyObject *) 0 ;
34601 PyObject *arg3 = (PyObject *) 0 ;
34602 void *argp1 = 0 ;
34603 int res1 = 0 ;
34604 PyObject * obj0 = 0 ;
34605 PyObject * obj1 = 0 ;
34606 PyObject * obj2 = 0 ;
34607 char * kwnames[] = {
34608 (char *) "self",(char *) "self",(char *) "_class", NULL
34609 };
34610
34611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34615 }
34616 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34617 arg2 = obj1;
34618 arg3 = obj2;
34619 {
34620 PyThreadState* __tstate = wxPyBeginAllowThreads();
34621 (arg1)->_setCallbackInfo(arg2,arg3);
34622 wxPyEndAllowThreads(__tstate);
34623 if (PyErr_Occurred()) SWIG_fail;
34624 }
34625 resultobj = SWIG_Py_Void();
34626 return resultobj;
34627 fail:
34628 return NULL;
34629 }
34630
34631
34632 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34633 PyObject *resultobj = 0;
34634 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34635 int arg2 ;
34636 int arg3 ;
34637 wxString *arg4 = 0 ;
34638 bool result;
34639 void *argp1 = 0 ;
34640 int res1 = 0 ;
34641 int val2 ;
34642 int ecode2 = 0 ;
34643 int val3 ;
34644 int ecode3 = 0 ;
34645 bool temp4 = false ;
34646 PyObject * obj0 = 0 ;
34647 PyObject * obj1 = 0 ;
34648 PyObject * obj2 = 0 ;
34649 PyObject * obj3 = 0 ;
34650 char * kwnames[] = {
34651 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34652 };
34653
34654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34656 if (!SWIG_IsOK(res1)) {
34657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34658 }
34659 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34660 ecode2 = SWIG_AsVal_int(obj1, &val2);
34661 if (!SWIG_IsOK(ecode2)) {
34662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34663 }
34664 arg2 = static_cast< int >(val2);
34665 ecode3 = SWIG_AsVal_int(obj2, &val3);
34666 if (!SWIG_IsOK(ecode3)) {
34667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34668 }
34669 arg3 = static_cast< int >(val3);
34670 {
34671 arg4 = wxString_in_helper(obj3);
34672 if (arg4 == NULL) SWIG_fail;
34673 temp4 = true;
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 {
34682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34683 }
34684 {
34685 if (temp4)
34686 delete arg4;
34687 }
34688 return resultobj;
34689 fail:
34690 {
34691 if (temp4)
34692 delete arg4;
34693 }
34694 return NULL;
34695 }
34696
34697
34698 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34699 PyObject *resultobj = 0;
34700 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34701 int arg2 ;
34702 int arg3 ;
34703 wxDragResult arg4 ;
34704 wxDragResult result;
34705 void *argp1 = 0 ;
34706 int res1 = 0 ;
34707 int val2 ;
34708 int ecode2 = 0 ;
34709 int val3 ;
34710 int ecode3 = 0 ;
34711 int val4 ;
34712 int ecode4 = 0 ;
34713 PyObject * obj0 = 0 ;
34714 PyObject * obj1 = 0 ;
34715 PyObject * obj2 = 0 ;
34716 PyObject * obj3 = 0 ;
34717 char * kwnames[] = {
34718 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34719 };
34720
34721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34723 if (!SWIG_IsOK(res1)) {
34724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34725 }
34726 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34727 ecode2 = SWIG_AsVal_int(obj1, &val2);
34728 if (!SWIG_IsOK(ecode2)) {
34729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34730 }
34731 arg2 = static_cast< int >(val2);
34732 ecode3 = SWIG_AsVal_int(obj2, &val3);
34733 if (!SWIG_IsOK(ecode3)) {
34734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34735 }
34736 arg3 = static_cast< int >(val3);
34737 ecode4 = SWIG_AsVal_int(obj3, &val4);
34738 if (!SWIG_IsOK(ecode4)) {
34739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34740 }
34741 arg4 = static_cast< wxDragResult >(val4);
34742 {
34743 PyThreadState* __tstate = wxPyBeginAllowThreads();
34744 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34745 wxPyEndAllowThreads(__tstate);
34746 if (PyErr_Occurred()) SWIG_fail;
34747 }
34748 resultobj = SWIG_From_int(static_cast< int >(result));
34749 return resultobj;
34750 fail:
34751 return NULL;
34752 }
34753
34754
34755 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34756 PyObject *resultobj = 0;
34757 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34758 int arg2 ;
34759 int arg3 ;
34760 wxDragResult arg4 ;
34761 wxDragResult result;
34762 void *argp1 = 0 ;
34763 int res1 = 0 ;
34764 int val2 ;
34765 int ecode2 = 0 ;
34766 int val3 ;
34767 int ecode3 = 0 ;
34768 int val4 ;
34769 int ecode4 = 0 ;
34770 PyObject * obj0 = 0 ;
34771 PyObject * obj1 = 0 ;
34772 PyObject * obj2 = 0 ;
34773 PyObject * obj3 = 0 ;
34774 char * kwnames[] = {
34775 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34776 };
34777
34778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34780 if (!SWIG_IsOK(res1)) {
34781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34782 }
34783 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34784 ecode2 = SWIG_AsVal_int(obj1, &val2);
34785 if (!SWIG_IsOK(ecode2)) {
34786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34787 }
34788 arg2 = static_cast< int >(val2);
34789 ecode3 = SWIG_AsVal_int(obj2, &val3);
34790 if (!SWIG_IsOK(ecode3)) {
34791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34792 }
34793 arg3 = static_cast< int >(val3);
34794 ecode4 = SWIG_AsVal_int(obj3, &val4);
34795 if (!SWIG_IsOK(ecode4)) {
34796 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34797 }
34798 arg4 = static_cast< wxDragResult >(val4);
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34802 wxPyEndAllowThreads(__tstate);
34803 if (PyErr_Occurred()) SWIG_fail;
34804 }
34805 resultobj = SWIG_From_int(static_cast< int >(result));
34806 return resultobj;
34807 fail:
34808 return NULL;
34809 }
34810
34811
34812 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34813 PyObject *resultobj = 0;
34814 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34815 void *argp1 = 0 ;
34816 int res1 = 0 ;
34817 PyObject *swig_obj[1] ;
34818
34819 if (!args) SWIG_fail;
34820 swig_obj[0] = args;
34821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34822 if (!SWIG_IsOK(res1)) {
34823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34824 }
34825 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34826 {
34827 PyThreadState* __tstate = wxPyBeginAllowThreads();
34828 (arg1)->OnLeave();
34829 wxPyEndAllowThreads(__tstate);
34830 if (PyErr_Occurred()) SWIG_fail;
34831 }
34832 resultobj = SWIG_Py_Void();
34833 return resultobj;
34834 fail:
34835 return NULL;
34836 }
34837
34838
34839 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34840 PyObject *resultobj = 0;
34841 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34842 int arg2 ;
34843 int arg3 ;
34844 bool result;
34845 void *argp1 = 0 ;
34846 int res1 = 0 ;
34847 int val2 ;
34848 int ecode2 = 0 ;
34849 int val3 ;
34850 int ecode3 = 0 ;
34851 PyObject * obj0 = 0 ;
34852 PyObject * obj1 = 0 ;
34853 PyObject * obj2 = 0 ;
34854 char * kwnames[] = {
34855 (char *) "self",(char *) "x",(char *) "y", NULL
34856 };
34857
34858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34860 if (!SWIG_IsOK(res1)) {
34861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34862 }
34863 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34864 ecode2 = SWIG_AsVal_int(obj1, &val2);
34865 if (!SWIG_IsOK(ecode2)) {
34866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34867 }
34868 arg2 = static_cast< int >(val2);
34869 ecode3 = SWIG_AsVal_int(obj2, &val3);
34870 if (!SWIG_IsOK(ecode3)) {
34871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34872 }
34873 arg3 = static_cast< int >(val3);
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 result = (bool)(arg1)->OnDrop(arg2,arg3);
34877 wxPyEndAllowThreads(__tstate);
34878 if (PyErr_Occurred()) SWIG_fail;
34879 }
34880 {
34881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34882 }
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34890 PyObject *resultobj = 0;
34891 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34892 int arg2 ;
34893 int arg3 ;
34894 wxDragResult arg4 ;
34895 wxDragResult result;
34896 void *argp1 = 0 ;
34897 int res1 = 0 ;
34898 int val2 ;
34899 int ecode2 = 0 ;
34900 int val3 ;
34901 int ecode3 = 0 ;
34902 int val4 ;
34903 int ecode4 = 0 ;
34904 PyObject * obj0 = 0 ;
34905 PyObject * obj1 = 0 ;
34906 PyObject * obj2 = 0 ;
34907 PyObject * obj3 = 0 ;
34908 char * kwnames[] = {
34909 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34910 };
34911
34912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34914 if (!SWIG_IsOK(res1)) {
34915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34916 }
34917 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34918 ecode2 = SWIG_AsVal_int(obj1, &val2);
34919 if (!SWIG_IsOK(ecode2)) {
34920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34921 }
34922 arg2 = static_cast< int >(val2);
34923 ecode3 = SWIG_AsVal_int(obj2, &val3);
34924 if (!SWIG_IsOK(ecode3)) {
34925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34926 }
34927 arg3 = static_cast< int >(val3);
34928 ecode4 = SWIG_AsVal_int(obj3, &val4);
34929 if (!SWIG_IsOK(ecode4)) {
34930 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34931 }
34932 arg4 = static_cast< wxDragResult >(val4);
34933 {
34934 PyThreadState* __tstate = wxPyBeginAllowThreads();
34935 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34936 wxPyEndAllowThreads(__tstate);
34937 if (PyErr_Occurred()) SWIG_fail;
34938 }
34939 resultobj = SWIG_From_int(static_cast< int >(result));
34940 return resultobj;
34941 fail:
34942 return NULL;
34943 }
34944
34945
34946 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34947 PyObject *obj;
34948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34949 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34950 return SWIG_Py_Void();
34951 }
34952
34953 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34954 return SWIG_Python_InitShadowInstance(args);
34955 }
34956
34957 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34958 PyObject *resultobj = 0;
34959 wxPyFileDropTarget *result = 0 ;
34960
34961 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34969 return resultobj;
34970 fail:
34971 return NULL;
34972 }
34973
34974
34975 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34976 PyObject *resultobj = 0;
34977 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34978 PyObject *arg2 = (PyObject *) 0 ;
34979 PyObject *arg3 = (PyObject *) 0 ;
34980 void *argp1 = 0 ;
34981 int res1 = 0 ;
34982 PyObject * obj0 = 0 ;
34983 PyObject * obj1 = 0 ;
34984 PyObject * obj2 = 0 ;
34985 char * kwnames[] = {
34986 (char *) "self",(char *) "self",(char *) "_class", NULL
34987 };
34988
34989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34991 if (!SWIG_IsOK(res1)) {
34992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34993 }
34994 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34995 arg2 = obj1;
34996 arg3 = obj2;
34997 {
34998 PyThreadState* __tstate = wxPyBeginAllowThreads();
34999 (arg1)->_setCallbackInfo(arg2,arg3);
35000 wxPyEndAllowThreads(__tstate);
35001 if (PyErr_Occurred()) SWIG_fail;
35002 }
35003 resultobj = SWIG_Py_Void();
35004 return resultobj;
35005 fail:
35006 return NULL;
35007 }
35008
35009
35010 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35011 PyObject *resultobj = 0;
35012 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35013 int arg2 ;
35014 int arg3 ;
35015 wxArrayString *arg4 = 0 ;
35016 bool result;
35017 void *argp1 = 0 ;
35018 int res1 = 0 ;
35019 int val2 ;
35020 int ecode2 = 0 ;
35021 int val3 ;
35022 int ecode3 = 0 ;
35023 bool temp4 = false ;
35024 PyObject * obj0 = 0 ;
35025 PyObject * obj1 = 0 ;
35026 PyObject * obj2 = 0 ;
35027 PyObject * obj3 = 0 ;
35028 char * kwnames[] = {
35029 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35030 };
35031
35032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35034 if (!SWIG_IsOK(res1)) {
35035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35036 }
35037 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35038 ecode2 = SWIG_AsVal_int(obj1, &val2);
35039 if (!SWIG_IsOK(ecode2)) {
35040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35041 }
35042 arg2 = static_cast< int >(val2);
35043 ecode3 = SWIG_AsVal_int(obj2, &val3);
35044 if (!SWIG_IsOK(ecode3)) {
35045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35046 }
35047 arg3 = static_cast< int >(val3);
35048 {
35049 if (! PySequence_Check(obj3)) {
35050 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35051 SWIG_fail;
35052 }
35053 arg4 = new wxArrayString;
35054 temp4 = true;
35055 int i, len=PySequence_Length(obj3);
35056 for (i=0; i<len; i++) {
35057 PyObject* item = PySequence_GetItem(obj3, i);
35058 wxString* s = wxString_in_helper(item);
35059 if (PyErr_Occurred()) SWIG_fail;
35060 arg4->Add(*s);
35061 delete s;
35062 Py_DECREF(item);
35063 }
35064 }
35065 {
35066 PyThreadState* __tstate = wxPyBeginAllowThreads();
35067 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35068 wxPyEndAllowThreads(__tstate);
35069 if (PyErr_Occurred()) SWIG_fail;
35070 }
35071 {
35072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35073 }
35074 {
35075 if (temp4) delete arg4;
35076 }
35077 return resultobj;
35078 fail:
35079 {
35080 if (temp4) delete arg4;
35081 }
35082 return NULL;
35083 }
35084
35085
35086 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35087 PyObject *resultobj = 0;
35088 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35089 int arg2 ;
35090 int arg3 ;
35091 wxDragResult arg4 ;
35092 wxDragResult result;
35093 void *argp1 = 0 ;
35094 int res1 = 0 ;
35095 int val2 ;
35096 int ecode2 = 0 ;
35097 int val3 ;
35098 int ecode3 = 0 ;
35099 int val4 ;
35100 int ecode4 = 0 ;
35101 PyObject * obj0 = 0 ;
35102 PyObject * obj1 = 0 ;
35103 PyObject * obj2 = 0 ;
35104 PyObject * obj3 = 0 ;
35105 char * kwnames[] = {
35106 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35107 };
35108
35109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35111 if (!SWIG_IsOK(res1)) {
35112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35113 }
35114 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35115 ecode2 = SWIG_AsVal_int(obj1, &val2);
35116 if (!SWIG_IsOK(ecode2)) {
35117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35118 }
35119 arg2 = static_cast< int >(val2);
35120 ecode3 = SWIG_AsVal_int(obj2, &val3);
35121 if (!SWIG_IsOK(ecode3)) {
35122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35123 }
35124 arg3 = static_cast< int >(val3);
35125 ecode4 = SWIG_AsVal_int(obj3, &val4);
35126 if (!SWIG_IsOK(ecode4)) {
35127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35128 }
35129 arg4 = static_cast< wxDragResult >(val4);
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35133 wxPyEndAllowThreads(__tstate);
35134 if (PyErr_Occurred()) SWIG_fail;
35135 }
35136 resultobj = SWIG_From_int(static_cast< int >(result));
35137 return resultobj;
35138 fail:
35139 return NULL;
35140 }
35141
35142
35143 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35144 PyObject *resultobj = 0;
35145 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35146 int arg2 ;
35147 int arg3 ;
35148 wxDragResult arg4 ;
35149 wxDragResult result;
35150 void *argp1 = 0 ;
35151 int res1 = 0 ;
35152 int val2 ;
35153 int ecode2 = 0 ;
35154 int val3 ;
35155 int ecode3 = 0 ;
35156 int val4 ;
35157 int ecode4 = 0 ;
35158 PyObject * obj0 = 0 ;
35159 PyObject * obj1 = 0 ;
35160 PyObject * obj2 = 0 ;
35161 PyObject * obj3 = 0 ;
35162 char * kwnames[] = {
35163 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35164 };
35165
35166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35168 if (!SWIG_IsOK(res1)) {
35169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35170 }
35171 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35172 ecode2 = SWIG_AsVal_int(obj1, &val2);
35173 if (!SWIG_IsOK(ecode2)) {
35174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35175 }
35176 arg2 = static_cast< int >(val2);
35177 ecode3 = SWIG_AsVal_int(obj2, &val3);
35178 if (!SWIG_IsOK(ecode3)) {
35179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35180 }
35181 arg3 = static_cast< int >(val3);
35182 ecode4 = SWIG_AsVal_int(obj3, &val4);
35183 if (!SWIG_IsOK(ecode4)) {
35184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35185 }
35186 arg4 = static_cast< wxDragResult >(val4);
35187 {
35188 PyThreadState* __tstate = wxPyBeginAllowThreads();
35189 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35190 wxPyEndAllowThreads(__tstate);
35191 if (PyErr_Occurred()) SWIG_fail;
35192 }
35193 resultobj = SWIG_From_int(static_cast< int >(result));
35194 return resultobj;
35195 fail:
35196 return NULL;
35197 }
35198
35199
35200 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35201 PyObject *resultobj = 0;
35202 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 PyObject *swig_obj[1] ;
35206
35207 if (!args) SWIG_fail;
35208 swig_obj[0] = args;
35209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35210 if (!SWIG_IsOK(res1)) {
35211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35212 }
35213 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 (arg1)->OnLeave();
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 resultobj = SWIG_Py_Void();
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35228 PyObject *resultobj = 0;
35229 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35230 int arg2 ;
35231 int arg3 ;
35232 bool result;
35233 void *argp1 = 0 ;
35234 int res1 = 0 ;
35235 int val2 ;
35236 int ecode2 = 0 ;
35237 int val3 ;
35238 int ecode3 = 0 ;
35239 PyObject * obj0 = 0 ;
35240 PyObject * obj1 = 0 ;
35241 PyObject * obj2 = 0 ;
35242 char * kwnames[] = {
35243 (char *) "self",(char *) "x",(char *) "y", NULL
35244 };
35245
35246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35248 if (!SWIG_IsOK(res1)) {
35249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35250 }
35251 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35252 ecode2 = SWIG_AsVal_int(obj1, &val2);
35253 if (!SWIG_IsOK(ecode2)) {
35254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35255 }
35256 arg2 = static_cast< int >(val2);
35257 ecode3 = SWIG_AsVal_int(obj2, &val3);
35258 if (!SWIG_IsOK(ecode3)) {
35259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35260 }
35261 arg3 = static_cast< int >(val3);
35262 {
35263 PyThreadState* __tstate = wxPyBeginAllowThreads();
35264 result = (bool)(arg1)->OnDrop(arg2,arg3);
35265 wxPyEndAllowThreads(__tstate);
35266 if (PyErr_Occurred()) SWIG_fail;
35267 }
35268 {
35269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35270 }
35271 return resultobj;
35272 fail:
35273 return NULL;
35274 }
35275
35276
35277 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35278 PyObject *resultobj = 0;
35279 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35280 int arg2 ;
35281 int arg3 ;
35282 wxDragResult arg4 ;
35283 wxDragResult result;
35284 void *argp1 = 0 ;
35285 int res1 = 0 ;
35286 int val2 ;
35287 int ecode2 = 0 ;
35288 int val3 ;
35289 int ecode3 = 0 ;
35290 int val4 ;
35291 int ecode4 = 0 ;
35292 PyObject * obj0 = 0 ;
35293 PyObject * obj1 = 0 ;
35294 PyObject * obj2 = 0 ;
35295 PyObject * obj3 = 0 ;
35296 char * kwnames[] = {
35297 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35298 };
35299
35300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35302 if (!SWIG_IsOK(res1)) {
35303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35304 }
35305 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35306 ecode2 = SWIG_AsVal_int(obj1, &val2);
35307 if (!SWIG_IsOK(ecode2)) {
35308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35309 }
35310 arg2 = static_cast< int >(val2);
35311 ecode3 = SWIG_AsVal_int(obj2, &val3);
35312 if (!SWIG_IsOK(ecode3)) {
35313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35314 }
35315 arg3 = static_cast< int >(val3);
35316 ecode4 = SWIG_AsVal_int(obj3, &val4);
35317 if (!SWIG_IsOK(ecode4)) {
35318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35319 }
35320 arg4 = static_cast< wxDragResult >(val4);
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35324 wxPyEndAllowThreads(__tstate);
35325 if (PyErr_Occurred()) SWIG_fail;
35326 }
35327 resultobj = SWIG_From_int(static_cast< int >(result));
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35335 PyObject *obj;
35336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35337 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35338 return SWIG_Py_Void();
35339 }
35340
35341 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35342 return SWIG_Python_InitShadowInstance(args);
35343 }
35344
35345 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35346 PyObject *resultobj = 0;
35347 wxClipboard *result = 0 ;
35348
35349 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 result = (wxClipboard *)new wxClipboard();
35353 wxPyEndAllowThreads(__tstate);
35354 if (PyErr_Occurred()) SWIG_fail;
35355 }
35356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35357 return resultobj;
35358 fail:
35359 return NULL;
35360 }
35361
35362
35363 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35364 PyObject *resultobj = 0;
35365 wxClipboard *arg1 = (wxClipboard *) 0 ;
35366 void *argp1 = 0 ;
35367 int res1 = 0 ;
35368 PyObject *swig_obj[1] ;
35369
35370 if (!args) SWIG_fail;
35371 swig_obj[0] = args;
35372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35373 if (!SWIG_IsOK(res1)) {
35374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35375 }
35376 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 delete arg1;
35380
35381 wxPyEndAllowThreads(__tstate);
35382 if (PyErr_Occurred()) SWIG_fail;
35383 }
35384 resultobj = SWIG_Py_Void();
35385 return resultobj;
35386 fail:
35387 return NULL;
35388 }
35389
35390
35391 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35392 PyObject *resultobj = 0;
35393 wxClipboard *arg1 = (wxClipboard *) 0 ;
35394 bool result;
35395 void *argp1 = 0 ;
35396 int res1 = 0 ;
35397 PyObject *swig_obj[1] ;
35398
35399 if (!args) SWIG_fail;
35400 swig_obj[0] = args;
35401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35402 if (!SWIG_IsOK(res1)) {
35403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35404 }
35405 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 result = (bool)(arg1)->Open();
35409 wxPyEndAllowThreads(__tstate);
35410 if (PyErr_Occurred()) SWIG_fail;
35411 }
35412 {
35413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35414 }
35415 return resultobj;
35416 fail:
35417 return NULL;
35418 }
35419
35420
35421 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35422 PyObject *resultobj = 0;
35423 wxClipboard *arg1 = (wxClipboard *) 0 ;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 PyObject *swig_obj[1] ;
35427
35428 if (!args) SWIG_fail;
35429 swig_obj[0] = args;
35430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35433 }
35434 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35435 {
35436 PyThreadState* __tstate = wxPyBeginAllowThreads();
35437 (arg1)->Close();
35438 wxPyEndAllowThreads(__tstate);
35439 if (PyErr_Occurred()) SWIG_fail;
35440 }
35441 resultobj = SWIG_Py_Void();
35442 return resultobj;
35443 fail:
35444 return NULL;
35445 }
35446
35447
35448 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35449 PyObject *resultobj = 0;
35450 wxClipboard *arg1 = (wxClipboard *) 0 ;
35451 bool result;
35452 void *argp1 = 0 ;
35453 int res1 = 0 ;
35454 PyObject *swig_obj[1] ;
35455
35456 if (!args) SWIG_fail;
35457 swig_obj[0] = args;
35458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35459 if (!SWIG_IsOK(res1)) {
35460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35461 }
35462 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 {
35470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35471 }
35472 return resultobj;
35473 fail:
35474 return NULL;
35475 }
35476
35477
35478 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35479 PyObject *resultobj = 0;
35480 wxClipboard *arg1 = (wxClipboard *) 0 ;
35481 wxDataObject *arg2 = (wxDataObject *) 0 ;
35482 bool result;
35483 void *argp1 = 0 ;
35484 int res1 = 0 ;
35485 int res2 = 0 ;
35486 PyObject * obj0 = 0 ;
35487 PyObject * obj1 = 0 ;
35488 char * kwnames[] = {
35489 (char *) "self",(char *) "data", NULL
35490 };
35491
35492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35494 if (!SWIG_IsOK(res1)) {
35495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35496 }
35497 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35498 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35499 if (!SWIG_IsOK(res2)) {
35500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35501 }
35502 {
35503 PyThreadState* __tstate = wxPyBeginAllowThreads();
35504 result = (bool)(arg1)->AddData(arg2);
35505 wxPyEndAllowThreads(__tstate);
35506 if (PyErr_Occurred()) SWIG_fail;
35507 }
35508 {
35509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35510 }
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj = 0;
35519 wxClipboard *arg1 = (wxClipboard *) 0 ;
35520 wxDataObject *arg2 = (wxDataObject *) 0 ;
35521 bool result;
35522 void *argp1 = 0 ;
35523 int res1 = 0 ;
35524 int res2 = 0 ;
35525 PyObject * obj0 = 0 ;
35526 PyObject * obj1 = 0 ;
35527 char * kwnames[] = {
35528 (char *) "self",(char *) "data", NULL
35529 };
35530
35531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35533 if (!SWIG_IsOK(res1)) {
35534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35535 }
35536 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35537 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35538 if (!SWIG_IsOK(res2)) {
35539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35540 }
35541 {
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 result = (bool)(arg1)->SetData(arg2);
35544 wxPyEndAllowThreads(__tstate);
35545 if (PyErr_Occurred()) SWIG_fail;
35546 }
35547 {
35548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35549 }
35550 return resultobj;
35551 fail:
35552 return NULL;
35553 }
35554
35555
35556 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35557 PyObject *resultobj = 0;
35558 wxClipboard *arg1 = (wxClipboard *) 0 ;
35559 wxDataFormat *arg2 = 0 ;
35560 bool result;
35561 void *argp1 = 0 ;
35562 int res1 = 0 ;
35563 void *argp2 = 0 ;
35564 int res2 = 0 ;
35565 PyObject * obj0 = 0 ;
35566 PyObject * obj1 = 0 ;
35567 char * kwnames[] = {
35568 (char *) "self",(char *) "format", NULL
35569 };
35570
35571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35573 if (!SWIG_IsOK(res1)) {
35574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35575 }
35576 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35578 if (!SWIG_IsOK(res2)) {
35579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35580 }
35581 if (!argp2) {
35582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35583 }
35584 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35585 {
35586 PyThreadState* __tstate = wxPyBeginAllowThreads();
35587 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35588 wxPyEndAllowThreads(__tstate);
35589 if (PyErr_Occurred()) SWIG_fail;
35590 }
35591 {
35592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35593 }
35594 return resultobj;
35595 fail:
35596 return NULL;
35597 }
35598
35599
35600 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35601 PyObject *resultobj = 0;
35602 wxClipboard *arg1 = (wxClipboard *) 0 ;
35603 wxDataObject *arg2 = 0 ;
35604 bool result;
35605 void *argp1 = 0 ;
35606 int res1 = 0 ;
35607 void *argp2 = 0 ;
35608 int res2 = 0 ;
35609 PyObject * obj0 = 0 ;
35610 PyObject * obj1 = 0 ;
35611 char * kwnames[] = {
35612 (char *) "self",(char *) "data", NULL
35613 };
35614
35615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35617 if (!SWIG_IsOK(res1)) {
35618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35619 }
35620 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35621 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35622 if (!SWIG_IsOK(res2)) {
35623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35624 }
35625 if (!argp2) {
35626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35627 }
35628 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35629 {
35630 PyThreadState* __tstate = wxPyBeginAllowThreads();
35631 result = (bool)(arg1)->GetData(*arg2);
35632 wxPyEndAllowThreads(__tstate);
35633 if (PyErr_Occurred()) SWIG_fail;
35634 }
35635 {
35636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35637 }
35638 return resultobj;
35639 fail:
35640 return NULL;
35641 }
35642
35643
35644 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35645 PyObject *resultobj = 0;
35646 wxClipboard *arg1 = (wxClipboard *) 0 ;
35647 void *argp1 = 0 ;
35648 int res1 = 0 ;
35649 PyObject *swig_obj[1] ;
35650
35651 if (!args) SWIG_fail;
35652 swig_obj[0] = args;
35653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35654 if (!SWIG_IsOK(res1)) {
35655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35656 }
35657 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 (arg1)->Clear();
35661 wxPyEndAllowThreads(__tstate);
35662 if (PyErr_Occurred()) SWIG_fail;
35663 }
35664 resultobj = SWIG_Py_Void();
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35672 PyObject *resultobj = 0;
35673 wxClipboard *arg1 = (wxClipboard *) 0 ;
35674 bool result;
35675 void *argp1 = 0 ;
35676 int res1 = 0 ;
35677 PyObject *swig_obj[1] ;
35678
35679 if (!args) SWIG_fail;
35680 swig_obj[0] = args;
35681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35682 if (!SWIG_IsOK(res1)) {
35683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35684 }
35685 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35686 {
35687 PyThreadState* __tstate = wxPyBeginAllowThreads();
35688 result = (bool)(arg1)->Flush();
35689 wxPyEndAllowThreads(__tstate);
35690 if (PyErr_Occurred()) SWIG_fail;
35691 }
35692 {
35693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35694 }
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35702 PyObject *resultobj = 0;
35703 wxClipboard *arg1 = (wxClipboard *) 0 ;
35704 bool arg2 = (bool) true ;
35705 void *argp1 = 0 ;
35706 int res1 = 0 ;
35707 bool val2 ;
35708 int ecode2 = 0 ;
35709 PyObject * obj0 = 0 ;
35710 PyObject * obj1 = 0 ;
35711 char * kwnames[] = {
35712 (char *) "self",(char *) "primary", NULL
35713 };
35714
35715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35717 if (!SWIG_IsOK(res1)) {
35718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35719 }
35720 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35721 if (obj1) {
35722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35723 if (!SWIG_IsOK(ecode2)) {
35724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35725 }
35726 arg2 = static_cast< bool >(val2);
35727 }
35728 {
35729 PyThreadState* __tstate = wxPyBeginAllowThreads();
35730 (arg1)->UsePrimarySelection(arg2);
35731 wxPyEndAllowThreads(__tstate);
35732 if (PyErr_Occurred()) SWIG_fail;
35733 }
35734 resultobj = SWIG_Py_Void();
35735 return resultobj;
35736 fail:
35737 return NULL;
35738 }
35739
35740
35741 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35742 PyObject *resultobj = 0;
35743 wxClipboard *result = 0 ;
35744
35745 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35746 {
35747 PyThreadState* __tstate = wxPyBeginAllowThreads();
35748 result = (wxClipboard *)wxClipboard::Get();
35749 wxPyEndAllowThreads(__tstate);
35750 if (PyErr_Occurred()) SWIG_fail;
35751 }
35752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35753 return resultobj;
35754 fail:
35755 return NULL;
35756 }
35757
35758
35759 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35760 PyObject *obj;
35761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35762 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35763 return SWIG_Py_Void();
35764 }
35765
35766 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35767 return SWIG_Python_InitShadowInstance(args);
35768 }
35769
35770 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35771 PyObject *resultobj = 0;
35772 wxClipboard *arg1 = (wxClipboard *) NULL ;
35773 wxClipboardLocker *result = 0 ;
35774 void *argp1 = 0 ;
35775 int res1 = 0 ;
35776 PyObject * obj0 = 0 ;
35777 char * kwnames[] = {
35778 (char *) "clipboard", NULL
35779 };
35780
35781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35782 if (obj0) {
35783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35784 if (!SWIG_IsOK(res1)) {
35785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35786 }
35787 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35788 }
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35796 return resultobj;
35797 fail:
35798 return NULL;
35799 }
35800
35801
35802 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35803 PyObject *resultobj = 0;
35804 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35805 void *argp1 = 0 ;
35806 int res1 = 0 ;
35807 PyObject *swig_obj[1] ;
35808
35809 if (!args) SWIG_fail;
35810 swig_obj[0] = args;
35811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35812 if (!SWIG_IsOK(res1)) {
35813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35814 }
35815 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35816 {
35817 PyThreadState* __tstate = wxPyBeginAllowThreads();
35818 delete arg1;
35819
35820 wxPyEndAllowThreads(__tstate);
35821 if (PyErr_Occurred()) SWIG_fail;
35822 }
35823 resultobj = SWIG_Py_Void();
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35831 PyObject *resultobj = 0;
35832 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35833 bool result;
35834 void *argp1 = 0 ;
35835 int res1 = 0 ;
35836 PyObject *swig_obj[1] ;
35837
35838 if (!args) SWIG_fail;
35839 swig_obj[0] = args;
35840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35843 }
35844 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (bool)wxClipboardLocker___nonzero__(arg1);
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 {
35852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35853 }
35854 return resultobj;
35855 fail:
35856 return NULL;
35857 }
35858
35859
35860 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35861 PyObject *obj;
35862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35863 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35864 return SWIG_Py_Void();
35865 }
35866
35867 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35868 return SWIG_Python_InitShadowInstance(args);
35869 }
35870
35871 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35872 PyObject *resultobj = 0;
35873 int arg1 = (int) 0 ;
35874 int arg2 = (int) 0 ;
35875 int arg3 = (int) 0 ;
35876 int arg4 = (int) 0 ;
35877 wxVideoMode *result = 0 ;
35878 int val1 ;
35879 int ecode1 = 0 ;
35880 int val2 ;
35881 int ecode2 = 0 ;
35882 int val3 ;
35883 int ecode3 = 0 ;
35884 int val4 ;
35885 int ecode4 = 0 ;
35886 PyObject * obj0 = 0 ;
35887 PyObject * obj1 = 0 ;
35888 PyObject * obj2 = 0 ;
35889 PyObject * obj3 = 0 ;
35890 char * kwnames[] = {
35891 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35892 };
35893
35894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35895 if (obj0) {
35896 ecode1 = SWIG_AsVal_int(obj0, &val1);
35897 if (!SWIG_IsOK(ecode1)) {
35898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35899 }
35900 arg1 = static_cast< int >(val1);
35901 }
35902 if (obj1) {
35903 ecode2 = SWIG_AsVal_int(obj1, &val2);
35904 if (!SWIG_IsOK(ecode2)) {
35905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35906 }
35907 arg2 = static_cast< int >(val2);
35908 }
35909 if (obj2) {
35910 ecode3 = SWIG_AsVal_int(obj2, &val3);
35911 if (!SWIG_IsOK(ecode3)) {
35912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35913 }
35914 arg3 = static_cast< int >(val3);
35915 }
35916 if (obj3) {
35917 ecode4 = SWIG_AsVal_int(obj3, &val4);
35918 if (!SWIG_IsOK(ecode4)) {
35919 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35920 }
35921 arg4 = static_cast< int >(val4);
35922 }
35923 {
35924 PyThreadState* __tstate = wxPyBeginAllowThreads();
35925 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35930 return resultobj;
35931 fail:
35932 return NULL;
35933 }
35934
35935
35936 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35937 PyObject *resultobj = 0;
35938 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35939 void *argp1 = 0 ;
35940 int res1 = 0 ;
35941 PyObject *swig_obj[1] ;
35942
35943 if (!args) SWIG_fail;
35944 swig_obj[0] = args;
35945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35946 if (!SWIG_IsOK(res1)) {
35947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35948 }
35949 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35950 {
35951 PyThreadState* __tstate = wxPyBeginAllowThreads();
35952 delete arg1;
35953
35954 wxPyEndAllowThreads(__tstate);
35955 if (PyErr_Occurred()) SWIG_fail;
35956 }
35957 resultobj = SWIG_Py_Void();
35958 return resultobj;
35959 fail:
35960 return NULL;
35961 }
35962
35963
35964 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35965 PyObject *resultobj = 0;
35966 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35967 wxVideoMode *arg2 = 0 ;
35968 bool result;
35969 void *argp1 = 0 ;
35970 int res1 = 0 ;
35971 void *argp2 = 0 ;
35972 int res2 = 0 ;
35973 PyObject * obj0 = 0 ;
35974 PyObject * obj1 = 0 ;
35975 char * kwnames[] = {
35976 (char *) "self",(char *) "other", NULL
35977 };
35978
35979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35981 if (!SWIG_IsOK(res1)) {
35982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35983 }
35984 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35985 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35986 if (!SWIG_IsOK(res2)) {
35987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35988 }
35989 if (!argp2) {
35990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35991 }
35992 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35993 {
35994 PyThreadState* __tstate = wxPyBeginAllowThreads();
35995 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35996 wxPyEndAllowThreads(__tstate);
35997 if (PyErr_Occurred()) SWIG_fail;
35998 }
35999 {
36000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36001 }
36002 return resultobj;
36003 fail:
36004 return NULL;
36005 }
36006
36007
36008 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36009 PyObject *resultobj = 0;
36010 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36011 int result;
36012 void *argp1 = 0 ;
36013 int res1 = 0 ;
36014 PyObject *swig_obj[1] ;
36015
36016 if (!args) SWIG_fail;
36017 swig_obj[0] = args;
36018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36019 if (!SWIG_IsOK(res1)) {
36020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36021 }
36022 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36023 {
36024 PyThreadState* __tstate = wxPyBeginAllowThreads();
36025 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 resultobj = SWIG_From_int(static_cast< int >(result));
36030 return resultobj;
36031 fail:
36032 return NULL;
36033 }
36034
36035
36036 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36037 PyObject *resultobj = 0;
36038 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36039 int result;
36040 void *argp1 = 0 ;
36041 int res1 = 0 ;
36042 PyObject *swig_obj[1] ;
36043
36044 if (!args) SWIG_fail;
36045 swig_obj[0] = args;
36046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36047 if (!SWIG_IsOK(res1)) {
36048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36049 }
36050 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36051 {
36052 PyThreadState* __tstate = wxPyBeginAllowThreads();
36053 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36054 wxPyEndAllowThreads(__tstate);
36055 if (PyErr_Occurred()) SWIG_fail;
36056 }
36057 resultobj = SWIG_From_int(static_cast< int >(result));
36058 return resultobj;
36059 fail:
36060 return NULL;
36061 }
36062
36063
36064 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36065 PyObject *resultobj = 0;
36066 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36067 int result;
36068 void *argp1 = 0 ;
36069 int res1 = 0 ;
36070 PyObject *swig_obj[1] ;
36071
36072 if (!args) SWIG_fail;
36073 swig_obj[0] = args;
36074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36075 if (!SWIG_IsOK(res1)) {
36076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36077 }
36078 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36079 {
36080 PyThreadState* __tstate = wxPyBeginAllowThreads();
36081 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36082 wxPyEndAllowThreads(__tstate);
36083 if (PyErr_Occurred()) SWIG_fail;
36084 }
36085 resultobj = SWIG_From_int(static_cast< int >(result));
36086 return resultobj;
36087 fail:
36088 return NULL;
36089 }
36090
36091
36092 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36093 PyObject *resultobj = 0;
36094 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36095 bool result;
36096 void *argp1 = 0 ;
36097 int res1 = 0 ;
36098 PyObject *swig_obj[1] ;
36099
36100 if (!args) SWIG_fail;
36101 swig_obj[0] = args;
36102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36103 if (!SWIG_IsOK(res1)) {
36104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36105 }
36106 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36107 {
36108 PyThreadState* __tstate = wxPyBeginAllowThreads();
36109 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36110 wxPyEndAllowThreads(__tstate);
36111 if (PyErr_Occurred()) SWIG_fail;
36112 }
36113 {
36114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36115 }
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36123 PyObject *resultobj = 0;
36124 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36125 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36126 bool result;
36127 void *argp1 = 0 ;
36128 int res1 = 0 ;
36129 void *argp2 = 0 ;
36130 int res2 = 0 ;
36131 PyObject * obj0 = 0 ;
36132 PyObject * obj1 = 0 ;
36133 char * kwnames[] = {
36134 (char *) "self",(char *) "other", NULL
36135 };
36136
36137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36139 if (!SWIG_IsOK(res1)) {
36140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36141 }
36142 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36144 if (!SWIG_IsOK(res2)) {
36145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36146 }
36147 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36148 {
36149 PyThreadState* __tstate = wxPyBeginAllowThreads();
36150 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36151 wxPyEndAllowThreads(__tstate);
36152 if (PyErr_Occurred()) SWIG_fail;
36153 }
36154 {
36155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36156 }
36157 return resultobj;
36158 fail:
36159 return NULL;
36160 }
36161
36162
36163 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36164 PyObject *resultobj = 0;
36165 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36166 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36167 bool result;
36168 void *argp1 = 0 ;
36169 int res1 = 0 ;
36170 void *argp2 = 0 ;
36171 int res2 = 0 ;
36172 PyObject * obj0 = 0 ;
36173 PyObject * obj1 = 0 ;
36174 char * kwnames[] = {
36175 (char *) "self",(char *) "other", NULL
36176 };
36177
36178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36182 }
36183 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36185 if (!SWIG_IsOK(res2)) {
36186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36187 }
36188 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36189 {
36190 PyThreadState* __tstate = wxPyBeginAllowThreads();
36191 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36192 wxPyEndAllowThreads(__tstate);
36193 if (PyErr_Occurred()) SWIG_fail;
36194 }
36195 {
36196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36197 }
36198 return resultobj;
36199 fail:
36200 return NULL;
36201 }
36202
36203
36204 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36205 PyObject *resultobj = 0;
36206 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36207 int arg2 ;
36208 void *argp1 = 0 ;
36209 int res1 = 0 ;
36210 int val2 ;
36211 int ecode2 = 0 ;
36212 PyObject *swig_obj[2] ;
36213
36214 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36216 if (!SWIG_IsOK(res1)) {
36217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36218 }
36219 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36220 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36221 if (!SWIG_IsOK(ecode2)) {
36222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36223 }
36224 arg2 = static_cast< int >(val2);
36225 if (arg1) (arg1)->w = arg2;
36226
36227 resultobj = SWIG_Py_Void();
36228 return resultobj;
36229 fail:
36230 return NULL;
36231 }
36232
36233
36234 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36235 PyObject *resultobj = 0;
36236 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36237 int result;
36238 void *argp1 = 0 ;
36239 int res1 = 0 ;
36240 PyObject *swig_obj[1] ;
36241
36242 if (!args) SWIG_fail;
36243 swig_obj[0] = args;
36244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36245 if (!SWIG_IsOK(res1)) {
36246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36247 }
36248 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36249 result = (int) ((arg1)->w);
36250 resultobj = SWIG_From_int(static_cast< int >(result));
36251 return resultobj;
36252 fail:
36253 return NULL;
36254 }
36255
36256
36257 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36258 PyObject *resultobj = 0;
36259 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36260 int arg2 ;
36261 void *argp1 = 0 ;
36262 int res1 = 0 ;
36263 int val2 ;
36264 int ecode2 = 0 ;
36265 PyObject *swig_obj[2] ;
36266
36267 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36269 if (!SWIG_IsOK(res1)) {
36270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36271 }
36272 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36273 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36274 if (!SWIG_IsOK(ecode2)) {
36275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36276 }
36277 arg2 = static_cast< int >(val2);
36278 if (arg1) (arg1)->h = arg2;
36279
36280 resultobj = SWIG_Py_Void();
36281 return resultobj;
36282 fail:
36283 return NULL;
36284 }
36285
36286
36287 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36288 PyObject *resultobj = 0;
36289 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36290 int result;
36291 void *argp1 = 0 ;
36292 int res1 = 0 ;
36293 PyObject *swig_obj[1] ;
36294
36295 if (!args) SWIG_fail;
36296 swig_obj[0] = args;
36297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36298 if (!SWIG_IsOK(res1)) {
36299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36300 }
36301 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36302 result = (int) ((arg1)->h);
36303 resultobj = SWIG_From_int(static_cast< int >(result));
36304 return resultobj;
36305 fail:
36306 return NULL;
36307 }
36308
36309
36310 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36311 PyObject *resultobj = 0;
36312 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36313 int arg2 ;
36314 void *argp1 = 0 ;
36315 int res1 = 0 ;
36316 int val2 ;
36317 int ecode2 = 0 ;
36318 PyObject *swig_obj[2] ;
36319
36320 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36322 if (!SWIG_IsOK(res1)) {
36323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36324 }
36325 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36326 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36327 if (!SWIG_IsOK(ecode2)) {
36328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36329 }
36330 arg2 = static_cast< int >(val2);
36331 if (arg1) (arg1)->bpp = arg2;
36332
36333 resultobj = SWIG_Py_Void();
36334 return resultobj;
36335 fail:
36336 return NULL;
36337 }
36338
36339
36340 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36341 PyObject *resultobj = 0;
36342 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36343 int result;
36344 void *argp1 = 0 ;
36345 int res1 = 0 ;
36346 PyObject *swig_obj[1] ;
36347
36348 if (!args) SWIG_fail;
36349 swig_obj[0] = args;
36350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36351 if (!SWIG_IsOK(res1)) {
36352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36353 }
36354 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36355 result = (int) ((arg1)->bpp);
36356 resultobj = SWIG_From_int(static_cast< int >(result));
36357 return resultobj;
36358 fail:
36359 return NULL;
36360 }
36361
36362
36363 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36364 PyObject *resultobj = 0;
36365 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36366 int arg2 ;
36367 void *argp1 = 0 ;
36368 int res1 = 0 ;
36369 int val2 ;
36370 int ecode2 = 0 ;
36371 PyObject *swig_obj[2] ;
36372
36373 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36375 if (!SWIG_IsOK(res1)) {
36376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36377 }
36378 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36379 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36380 if (!SWIG_IsOK(ecode2)) {
36381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36382 }
36383 arg2 = static_cast< int >(val2);
36384 if (arg1) (arg1)->refresh = arg2;
36385
36386 resultobj = SWIG_Py_Void();
36387 return resultobj;
36388 fail:
36389 return NULL;
36390 }
36391
36392
36393 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36394 PyObject *resultobj = 0;
36395 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36396 int result;
36397 void *argp1 = 0 ;
36398 int res1 = 0 ;
36399 PyObject *swig_obj[1] ;
36400
36401 if (!args) SWIG_fail;
36402 swig_obj[0] = args;
36403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36404 if (!SWIG_IsOK(res1)) {
36405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36406 }
36407 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36408 result = (int) ((arg1)->refresh);
36409 resultobj = SWIG_From_int(static_cast< int >(result));
36410 return resultobj;
36411 fail:
36412 return NULL;
36413 }
36414
36415
36416 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36417 PyObject *obj;
36418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36419 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36420 return SWIG_Py_Void();
36421 }
36422
36423 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36424 return SWIG_Python_InitShadowInstance(args);
36425 }
36426
36427 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36428 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36429 return 1;
36430 }
36431
36432
36433 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36434 PyObject *pyobj = 0;
36435
36436 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36437 return pyobj;
36438 }
36439
36440
36441 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36442 PyObject *resultobj = 0;
36443 unsigned int arg1 = (unsigned int) 0 ;
36444 wxDisplay *result = 0 ;
36445 unsigned int val1 ;
36446 int ecode1 = 0 ;
36447 PyObject * obj0 = 0 ;
36448 char * kwnames[] = {
36449 (char *) "index", NULL
36450 };
36451
36452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36453 if (obj0) {
36454 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36455 if (!SWIG_IsOK(ecode1)) {
36456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36457 }
36458 arg1 = static_cast< unsigned int >(val1);
36459 }
36460 {
36461 PyThreadState* __tstate = wxPyBeginAllowThreads();
36462 result = (wxDisplay *)new wxDisplay(arg1);
36463 wxPyEndAllowThreads(__tstate);
36464 if (PyErr_Occurred()) SWIG_fail;
36465 }
36466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36467 return resultobj;
36468 fail:
36469 return NULL;
36470 }
36471
36472
36473 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36474 PyObject *resultobj = 0;
36475 wxDisplay *arg1 = (wxDisplay *) 0 ;
36476 void *argp1 = 0 ;
36477 int res1 = 0 ;
36478 PyObject *swig_obj[1] ;
36479
36480 if (!args) SWIG_fail;
36481 swig_obj[0] = args;
36482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36483 if (!SWIG_IsOK(res1)) {
36484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36485 }
36486 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 delete arg1;
36490
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 resultobj = SWIG_Py_Void();
36495 return resultobj;
36496 fail:
36497 return NULL;
36498 }
36499
36500
36501 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36502 PyObject *resultobj = 0;
36503 unsigned int result;
36504
36505 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36506 {
36507 PyThreadState* __tstate = wxPyBeginAllowThreads();
36508 result = (unsigned int)wxDisplay::GetCount();
36509 wxPyEndAllowThreads(__tstate);
36510 if (PyErr_Occurred()) SWIG_fail;
36511 }
36512 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36513 return resultobj;
36514 fail:
36515 return NULL;
36516 }
36517
36518
36519 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36520 PyObject *resultobj = 0;
36521 wxPoint *arg1 = 0 ;
36522 int result;
36523 wxPoint temp1 ;
36524 PyObject * obj0 = 0 ;
36525 char * kwnames[] = {
36526 (char *) "pt", NULL
36527 };
36528
36529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36530 {
36531 arg1 = &temp1;
36532 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36533 }
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 resultobj = SWIG_From_int(static_cast< int >(result));
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36548 PyObject *resultobj = 0;
36549 wxWindow *arg1 = (wxWindow *) 0 ;
36550 int result;
36551 void *argp1 = 0 ;
36552 int res1 = 0 ;
36553 PyObject * obj0 = 0 ;
36554 char * kwnames[] = {
36555 (char *) "window", NULL
36556 };
36557
36558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36560 if (!SWIG_IsOK(res1)) {
36561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36562 }
36563 arg1 = reinterpret_cast< wxWindow * >(argp1);
36564 {
36565 PyThreadState* __tstate = wxPyBeginAllowThreads();
36566 result = (int)wxDisplay::GetFromWindow(arg1);
36567 wxPyEndAllowThreads(__tstate);
36568 if (PyErr_Occurred()) SWIG_fail;
36569 }
36570 resultobj = SWIG_From_int(static_cast< int >(result));
36571 return resultobj;
36572 fail:
36573 return NULL;
36574 }
36575
36576
36577 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36578 PyObject *resultobj = 0;
36579 wxDisplay *arg1 = (wxDisplay *) 0 ;
36580 bool result;
36581 void *argp1 = 0 ;
36582 int res1 = 0 ;
36583 PyObject *swig_obj[1] ;
36584
36585 if (!args) SWIG_fail;
36586 swig_obj[0] = args;
36587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36588 if (!SWIG_IsOK(res1)) {
36589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36590 }
36591 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36592 {
36593 PyThreadState* __tstate = wxPyBeginAllowThreads();
36594 result = (bool)((wxDisplay const *)arg1)->IsOk();
36595 wxPyEndAllowThreads(__tstate);
36596 if (PyErr_Occurred()) SWIG_fail;
36597 }
36598 {
36599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36600 }
36601 return resultobj;
36602 fail:
36603 return NULL;
36604 }
36605
36606
36607 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36608 PyObject *resultobj = 0;
36609 wxDisplay *arg1 = (wxDisplay *) 0 ;
36610 wxRect result;
36611 void *argp1 = 0 ;
36612 int res1 = 0 ;
36613 PyObject *swig_obj[1] ;
36614
36615 if (!args) SWIG_fail;
36616 swig_obj[0] = args;
36617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36618 if (!SWIG_IsOK(res1)) {
36619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36620 }
36621 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36622 {
36623 PyThreadState* __tstate = wxPyBeginAllowThreads();
36624 result = ((wxDisplay const *)arg1)->GetGeometry();
36625 wxPyEndAllowThreads(__tstate);
36626 if (PyErr_Occurred()) SWIG_fail;
36627 }
36628 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36629 return resultobj;
36630 fail:
36631 return NULL;
36632 }
36633
36634
36635 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36636 PyObject *resultobj = 0;
36637 wxDisplay *arg1 = (wxDisplay *) 0 ;
36638 wxRect result;
36639 void *argp1 = 0 ;
36640 int res1 = 0 ;
36641 PyObject *swig_obj[1] ;
36642
36643 if (!args) SWIG_fail;
36644 swig_obj[0] = args;
36645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36646 if (!SWIG_IsOK(res1)) {
36647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36648 }
36649 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36650 {
36651 PyThreadState* __tstate = wxPyBeginAllowThreads();
36652 result = ((wxDisplay const *)arg1)->GetClientArea();
36653 wxPyEndAllowThreads(__tstate);
36654 if (PyErr_Occurred()) SWIG_fail;
36655 }
36656 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36657 return resultobj;
36658 fail:
36659 return NULL;
36660 }
36661
36662
36663 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36664 PyObject *resultobj = 0;
36665 wxDisplay *arg1 = (wxDisplay *) 0 ;
36666 wxString result;
36667 void *argp1 = 0 ;
36668 int res1 = 0 ;
36669 PyObject *swig_obj[1] ;
36670
36671 if (!args) SWIG_fail;
36672 swig_obj[0] = args;
36673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36674 if (!SWIG_IsOK(res1)) {
36675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36676 }
36677 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36678 {
36679 PyThreadState* __tstate = wxPyBeginAllowThreads();
36680 result = ((wxDisplay const *)arg1)->GetName();
36681 wxPyEndAllowThreads(__tstate);
36682 if (PyErr_Occurred()) SWIG_fail;
36683 }
36684 {
36685 #if wxUSE_UNICODE
36686 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36687 #else
36688 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36689 #endif
36690 }
36691 return resultobj;
36692 fail:
36693 return NULL;
36694 }
36695
36696
36697 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36698 PyObject *resultobj = 0;
36699 wxDisplay *arg1 = (wxDisplay *) 0 ;
36700 bool result;
36701 void *argp1 = 0 ;
36702 int res1 = 0 ;
36703 PyObject *swig_obj[1] ;
36704
36705 if (!args) SWIG_fail;
36706 swig_obj[0] = args;
36707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36708 if (!SWIG_IsOK(res1)) {
36709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36710 }
36711 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36712 {
36713 PyThreadState* __tstate = wxPyBeginAllowThreads();
36714 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36715 wxPyEndAllowThreads(__tstate);
36716 if (PyErr_Occurred()) SWIG_fail;
36717 }
36718 {
36719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36720 }
36721 return resultobj;
36722 fail:
36723 return NULL;
36724 }
36725
36726
36727 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36728 PyObject *resultobj = 0;
36729 wxDisplay *arg1 = (wxDisplay *) 0 ;
36730 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36731 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36732 PyObject *result = 0 ;
36733 void *argp1 = 0 ;
36734 int res1 = 0 ;
36735 void *argp2 = 0 ;
36736 int res2 = 0 ;
36737 PyObject * obj0 = 0 ;
36738 PyObject * obj1 = 0 ;
36739 char * kwnames[] = {
36740 (char *) "self",(char *) "mode", NULL
36741 };
36742
36743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36745 if (!SWIG_IsOK(res1)) {
36746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36747 }
36748 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36749 if (obj1) {
36750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36751 if (!SWIG_IsOK(res2)) {
36752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36753 }
36754 if (!argp2) {
36755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36756 }
36757 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36758 }
36759 {
36760 PyThreadState* __tstate = wxPyBeginAllowThreads();
36761 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36762 wxPyEndAllowThreads(__tstate);
36763 if (PyErr_Occurred()) SWIG_fail;
36764 }
36765 resultobj = result;
36766 return resultobj;
36767 fail:
36768 return NULL;
36769 }
36770
36771
36772 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36773 PyObject *resultobj = 0;
36774 wxDisplay *arg1 = (wxDisplay *) 0 ;
36775 wxVideoMode result;
36776 void *argp1 = 0 ;
36777 int res1 = 0 ;
36778 PyObject *swig_obj[1] ;
36779
36780 if (!args) SWIG_fail;
36781 swig_obj[0] = args;
36782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36783 if (!SWIG_IsOK(res1)) {
36784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36785 }
36786 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36787 {
36788 PyThreadState* __tstate = wxPyBeginAllowThreads();
36789 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36790 wxPyEndAllowThreads(__tstate);
36791 if (PyErr_Occurred()) SWIG_fail;
36792 }
36793 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36794 return resultobj;
36795 fail:
36796 return NULL;
36797 }
36798
36799
36800 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36801 PyObject *resultobj = 0;
36802 wxDisplay *arg1 = (wxDisplay *) 0 ;
36803 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36804 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36805 bool result;
36806 void *argp1 = 0 ;
36807 int res1 = 0 ;
36808 void *argp2 = 0 ;
36809 int res2 = 0 ;
36810 PyObject * obj0 = 0 ;
36811 PyObject * obj1 = 0 ;
36812 char * kwnames[] = {
36813 (char *) "self",(char *) "mode", NULL
36814 };
36815
36816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36818 if (!SWIG_IsOK(res1)) {
36819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36820 }
36821 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36822 if (obj1) {
36823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36824 if (!SWIG_IsOK(res2)) {
36825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36826 }
36827 if (!argp2) {
36828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36829 }
36830 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36831 }
36832 {
36833 PyThreadState* __tstate = wxPyBeginAllowThreads();
36834 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36835 wxPyEndAllowThreads(__tstate);
36836 if (PyErr_Occurred()) SWIG_fail;
36837 }
36838 {
36839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36840 }
36841 return resultobj;
36842 fail:
36843 return NULL;
36844 }
36845
36846
36847 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36848 PyObject *resultobj = 0;
36849 wxDisplay *arg1 = (wxDisplay *) 0 ;
36850 void *argp1 = 0 ;
36851 int res1 = 0 ;
36852 PyObject *swig_obj[1] ;
36853
36854 if (!args) SWIG_fail;
36855 swig_obj[0] = args;
36856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36857 if (!SWIG_IsOK(res1)) {
36858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36859 }
36860 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36861 {
36862 PyThreadState* __tstate = wxPyBeginAllowThreads();
36863 wxDisplay_ResetMode(arg1);
36864 wxPyEndAllowThreads(__tstate);
36865 if (PyErr_Occurred()) SWIG_fail;
36866 }
36867 resultobj = SWIG_Py_Void();
36868 return resultobj;
36869 fail:
36870 return NULL;
36871 }
36872
36873
36874 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36875 PyObject *obj;
36876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36877 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36878 return SWIG_Py_Void();
36879 }
36880
36881 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36882 return SWIG_Python_InitShadowInstance(args);
36883 }
36884
36885 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36886 PyObject *resultobj = 0;
36887 wxStandardPaths *result = 0 ;
36888
36889 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36890 {
36891 PyThreadState* __tstate = wxPyBeginAllowThreads();
36892 result = (wxStandardPaths *)wxStandardPaths_Get();
36893 wxPyEndAllowThreads(__tstate);
36894 if (PyErr_Occurred()) SWIG_fail;
36895 }
36896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36897 return resultobj;
36898 fail:
36899 return NULL;
36900 }
36901
36902
36903 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36904 PyObject *resultobj = 0;
36905 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36906 wxString result;
36907 void *argp1 = 0 ;
36908 int res1 = 0 ;
36909 PyObject *swig_obj[1] ;
36910
36911 if (!args) SWIG_fail;
36912 swig_obj[0] = args;
36913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36914 if (!SWIG_IsOK(res1)) {
36915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36916 }
36917 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36918 {
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 {
36925 #if wxUSE_UNICODE
36926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36927 #else
36928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36929 #endif
36930 }
36931 return resultobj;
36932 fail:
36933 return NULL;
36934 }
36935
36936
36937 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36938 PyObject *resultobj = 0;
36939 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36940 wxString result;
36941 void *argp1 = 0 ;
36942 int res1 = 0 ;
36943 PyObject *swig_obj[1] ;
36944
36945 if (!args) SWIG_fail;
36946 swig_obj[0] = args;
36947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36948 if (!SWIG_IsOK(res1)) {
36949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36950 }
36951 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36952 {
36953 PyThreadState* __tstate = wxPyBeginAllowThreads();
36954 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36955 wxPyEndAllowThreads(__tstate);
36956 if (PyErr_Occurred()) SWIG_fail;
36957 }
36958 {
36959 #if wxUSE_UNICODE
36960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36961 #else
36962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36963 #endif
36964 }
36965 return resultobj;
36966 fail:
36967 return NULL;
36968 }
36969
36970
36971 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36972 PyObject *resultobj = 0;
36973 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36974 wxString result;
36975 void *argp1 = 0 ;
36976 int res1 = 0 ;
36977 PyObject *swig_obj[1] ;
36978
36979 if (!args) SWIG_fail;
36980 swig_obj[0] = args;
36981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36982 if (!SWIG_IsOK(res1)) {
36983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36984 }
36985 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36986 {
36987 PyThreadState* __tstate = wxPyBeginAllowThreads();
36988 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36989 wxPyEndAllowThreads(__tstate);
36990 if (PyErr_Occurred()) SWIG_fail;
36991 }
36992 {
36993 #if wxUSE_UNICODE
36994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36995 #else
36996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36997 #endif
36998 }
36999 return resultobj;
37000 fail:
37001 return NULL;
37002 }
37003
37004
37005 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37006 PyObject *resultobj = 0;
37007 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37008 wxString result;
37009 void *argp1 = 0 ;
37010 int res1 = 0 ;
37011 PyObject *swig_obj[1] ;
37012
37013 if (!args) SWIG_fail;
37014 swig_obj[0] = args;
37015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37016 if (!SWIG_IsOK(res1)) {
37017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37018 }
37019 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37020 {
37021 PyThreadState* __tstate = wxPyBeginAllowThreads();
37022 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 {
37027 #if wxUSE_UNICODE
37028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37029 #else
37030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37031 #endif
37032 }
37033 return resultobj;
37034 fail:
37035 return NULL;
37036 }
37037
37038
37039 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37040 PyObject *resultobj = 0;
37041 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37042 wxString result;
37043 void *argp1 = 0 ;
37044 int res1 = 0 ;
37045 PyObject *swig_obj[1] ;
37046
37047 if (!args) SWIG_fail;
37048 swig_obj[0] = args;
37049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37050 if (!SWIG_IsOK(res1)) {
37051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37052 }
37053 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37054 {
37055 PyThreadState* __tstate = wxPyBeginAllowThreads();
37056 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37057 wxPyEndAllowThreads(__tstate);
37058 if (PyErr_Occurred()) SWIG_fail;
37059 }
37060 {
37061 #if wxUSE_UNICODE
37062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37063 #else
37064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37065 #endif
37066 }
37067 return resultobj;
37068 fail:
37069 return NULL;
37070 }
37071
37072
37073 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37074 PyObject *resultobj = 0;
37075 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37076 wxString result;
37077 void *argp1 = 0 ;
37078 int res1 = 0 ;
37079 PyObject *swig_obj[1] ;
37080
37081 if (!args) SWIG_fail;
37082 swig_obj[0] = args;
37083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37084 if (!SWIG_IsOK(res1)) {
37085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37086 }
37087 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37088 {
37089 PyThreadState* __tstate = wxPyBeginAllowThreads();
37090 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37091 wxPyEndAllowThreads(__tstate);
37092 if (PyErr_Occurred()) SWIG_fail;
37093 }
37094 {
37095 #if wxUSE_UNICODE
37096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37097 #else
37098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37099 #endif
37100 }
37101 return resultobj;
37102 fail:
37103 return NULL;
37104 }
37105
37106
37107 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37108 PyObject *resultobj = 0;
37109 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37110 wxString result;
37111 void *argp1 = 0 ;
37112 int res1 = 0 ;
37113 PyObject *swig_obj[1] ;
37114
37115 if (!args) SWIG_fail;
37116 swig_obj[0] = args;
37117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37118 if (!SWIG_IsOK(res1)) {
37119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37120 }
37121 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37122 {
37123 PyThreadState* __tstate = wxPyBeginAllowThreads();
37124 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37125 wxPyEndAllowThreads(__tstate);
37126 if (PyErr_Occurred()) SWIG_fail;
37127 }
37128 {
37129 #if wxUSE_UNICODE
37130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37131 #else
37132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37133 #endif
37134 }
37135 return resultobj;
37136 fail:
37137 return NULL;
37138 }
37139
37140
37141 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37142 PyObject *resultobj = 0;
37143 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37144 wxString result;
37145 void *argp1 = 0 ;
37146 int res1 = 0 ;
37147 PyObject *swig_obj[1] ;
37148
37149 if (!args) SWIG_fail;
37150 swig_obj[0] = args;
37151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37152 if (!SWIG_IsOK(res1)) {
37153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37154 }
37155 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37156 {
37157 PyThreadState* __tstate = wxPyBeginAllowThreads();
37158 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 {
37163 #if wxUSE_UNICODE
37164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37165 #else
37166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37167 #endif
37168 }
37169 return resultobj;
37170 fail:
37171 return NULL;
37172 }
37173
37174
37175 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37176 PyObject *resultobj = 0;
37177 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37178 wxString *arg2 = 0 ;
37179 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37180 wxString result;
37181 void *argp1 = 0 ;
37182 int res1 = 0 ;
37183 bool temp2 = false ;
37184 int val3 ;
37185 int ecode3 = 0 ;
37186 PyObject * obj0 = 0 ;
37187 PyObject * obj1 = 0 ;
37188 PyObject * obj2 = 0 ;
37189 char * kwnames[] = {
37190 (char *) "self",(char *) "lang",(char *) "category", NULL
37191 };
37192
37193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37195 if (!SWIG_IsOK(res1)) {
37196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37197 }
37198 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37199 {
37200 arg2 = wxString_in_helper(obj1);
37201 if (arg2 == NULL) SWIG_fail;
37202 temp2 = true;
37203 }
37204 if (obj2) {
37205 ecode3 = SWIG_AsVal_int(obj2, &val3);
37206 if (!SWIG_IsOK(ecode3)) {
37207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37208 }
37209 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37210 }
37211 {
37212 PyThreadState* __tstate = wxPyBeginAllowThreads();
37213 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37214 wxPyEndAllowThreads(__tstate);
37215 if (PyErr_Occurred()) SWIG_fail;
37216 }
37217 {
37218 #if wxUSE_UNICODE
37219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37220 #else
37221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37222 #endif
37223 }
37224 {
37225 if (temp2)
37226 delete arg2;
37227 }
37228 return resultobj;
37229 fail:
37230 {
37231 if (temp2)
37232 delete arg2;
37233 }
37234 return NULL;
37235 }
37236
37237
37238 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37239 PyObject *resultobj = 0;
37240 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37241 wxString result;
37242 void *argp1 = 0 ;
37243 int res1 = 0 ;
37244 PyObject *swig_obj[1] ;
37245
37246 if (!args) SWIG_fail;
37247 swig_obj[0] = args;
37248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37249 if (!SWIG_IsOK(res1)) {
37250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37251 }
37252 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37253 {
37254 PyThreadState* __tstate = wxPyBeginAllowThreads();
37255 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37256 wxPyEndAllowThreads(__tstate);
37257 if (PyErr_Occurred()) SWIG_fail;
37258 }
37259 {
37260 #if wxUSE_UNICODE
37261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37262 #else
37263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37264 #endif
37265 }
37266 return resultobj;
37267 fail:
37268 return NULL;
37269 }
37270
37271
37272 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37273 PyObject *resultobj = 0;
37274 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37275 wxString result;
37276 void *argp1 = 0 ;
37277 int res1 = 0 ;
37278 PyObject *swig_obj[1] ;
37279
37280 if (!args) SWIG_fail;
37281 swig_obj[0] = args;
37282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37283 if (!SWIG_IsOK(res1)) {
37284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37285 }
37286 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37290 wxPyEndAllowThreads(__tstate);
37291 if (PyErr_Occurred()) SWIG_fail;
37292 }
37293 {
37294 #if wxUSE_UNICODE
37295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37296 #else
37297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37298 #endif
37299 }
37300 return resultobj;
37301 fail:
37302 return NULL;
37303 }
37304
37305
37306 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37307 PyObject *resultobj = 0;
37308 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37309 wxString *arg2 = 0 ;
37310 void *argp1 = 0 ;
37311 int res1 = 0 ;
37312 bool temp2 = false ;
37313 PyObject * obj0 = 0 ;
37314 PyObject * obj1 = 0 ;
37315 char * kwnames[] = {
37316 (char *) "self",(char *) "prefix", NULL
37317 };
37318
37319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37321 if (!SWIG_IsOK(res1)) {
37322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37323 }
37324 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37325 {
37326 arg2 = wxString_in_helper(obj1);
37327 if (arg2 == NULL) SWIG_fail;
37328 temp2 = true;
37329 }
37330 {
37331 PyThreadState* __tstate = wxPyBeginAllowThreads();
37332 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37333 wxPyEndAllowThreads(__tstate);
37334 if (PyErr_Occurred()) SWIG_fail;
37335 }
37336 resultobj = SWIG_Py_Void();
37337 {
37338 if (temp2)
37339 delete arg2;
37340 }
37341 return resultobj;
37342 fail:
37343 {
37344 if (temp2)
37345 delete arg2;
37346 }
37347 return NULL;
37348 }
37349
37350
37351 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37352 PyObject *resultobj = 0;
37353 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37354 wxString result;
37355 void *argp1 = 0 ;
37356 int res1 = 0 ;
37357 PyObject *swig_obj[1] ;
37358
37359 if (!args) SWIG_fail;
37360 swig_obj[0] = args;
37361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37362 if (!SWIG_IsOK(res1)) {
37363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37364 }
37365 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37366 {
37367 PyThreadState* __tstate = wxPyBeginAllowThreads();
37368 result = wxStandardPaths_GetInstallPrefix(arg1);
37369 wxPyEndAllowThreads(__tstate);
37370 if (PyErr_Occurred()) SWIG_fail;
37371 }
37372 {
37373 #if wxUSE_UNICODE
37374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37375 #else
37376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37377 #endif
37378 }
37379 return resultobj;
37380 fail:
37381 return NULL;
37382 }
37383
37384
37385 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37386 PyObject *obj;
37387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37388 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37389 return SWIG_Py_Void();
37390 }
37391
37392 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37393 PyObject *resultobj = 0;
37394 wxEventType arg1 ;
37395 wxPowerEvent *result = 0 ;
37396 int val1 ;
37397 int ecode1 = 0 ;
37398 PyObject * obj0 = 0 ;
37399 char * kwnames[] = {
37400 (char *) "evtType", NULL
37401 };
37402
37403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37404 ecode1 = SWIG_AsVal_int(obj0, &val1);
37405 if (!SWIG_IsOK(ecode1)) {
37406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37407 }
37408 arg1 = static_cast< wxEventType >(val1);
37409 {
37410 PyThreadState* __tstate = wxPyBeginAllowThreads();
37411 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37412 wxPyEndAllowThreads(__tstate);
37413 if (PyErr_Occurred()) SWIG_fail;
37414 }
37415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37416 return resultobj;
37417 fail:
37418 return NULL;
37419 }
37420
37421
37422 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37423 PyObject *resultobj = 0;
37424 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37425 void *argp1 = 0 ;
37426 int res1 = 0 ;
37427 PyObject *swig_obj[1] ;
37428
37429 if (!args) SWIG_fail;
37430 swig_obj[0] = args;
37431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37432 if (!SWIG_IsOK(res1)) {
37433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37434 }
37435 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37436 {
37437 PyThreadState* __tstate = wxPyBeginAllowThreads();
37438 (arg1)->Veto();
37439 wxPyEndAllowThreads(__tstate);
37440 if (PyErr_Occurred()) SWIG_fail;
37441 }
37442 resultobj = SWIG_Py_Void();
37443 return resultobj;
37444 fail:
37445 return NULL;
37446 }
37447
37448
37449 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37450 PyObject *resultobj = 0;
37451 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37452 bool result;
37453 void *argp1 = 0 ;
37454 int res1 = 0 ;
37455 PyObject *swig_obj[1] ;
37456
37457 if (!args) SWIG_fail;
37458 swig_obj[0] = args;
37459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37460 if (!SWIG_IsOK(res1)) {
37461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37462 }
37463 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37464 {
37465 PyThreadState* __tstate = wxPyBeginAllowThreads();
37466 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37467 wxPyEndAllowThreads(__tstate);
37468 if (PyErr_Occurred()) SWIG_fail;
37469 }
37470 {
37471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37472 }
37473 return resultobj;
37474 fail:
37475 return NULL;
37476 }
37477
37478
37479 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37480 PyObject *obj;
37481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37482 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37483 return SWIG_Py_Void();
37484 }
37485
37486 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37487 return SWIG_Python_InitShadowInstance(args);
37488 }
37489
37490 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37491 PyObject *resultobj = 0;
37492 wxPowerType result;
37493
37494 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37495 {
37496 PyThreadState* __tstate = wxPyBeginAllowThreads();
37497 result = (wxPowerType)wxGetPowerType();
37498 wxPyEndAllowThreads(__tstate);
37499 if (PyErr_Occurred()) SWIG_fail;
37500 }
37501 resultobj = SWIG_From_int(static_cast< int >(result));
37502 return resultobj;
37503 fail:
37504 return NULL;
37505 }
37506
37507
37508 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37509 PyObject *resultobj = 0;
37510 wxBatteryState result;
37511
37512 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 result = (wxBatteryState)wxGetBatteryState();
37516 wxPyEndAllowThreads(__tstate);
37517 if (PyErr_Occurred()) SWIG_fail;
37518 }
37519 resultobj = SWIG_From_int(static_cast< int >(result));
37520 return resultobj;
37521 fail:
37522 return NULL;
37523 }
37524
37525
37526 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37527 PyObject *resultobj = 0;
37528 wxAboutDialogInfo *result = 0 ;
37529
37530 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37531 {
37532 PyThreadState* __tstate = wxPyBeginAllowThreads();
37533 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37534 wxPyEndAllowThreads(__tstate);
37535 if (PyErr_Occurred()) SWIG_fail;
37536 }
37537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37538 return resultobj;
37539 fail:
37540 return NULL;
37541 }
37542
37543
37544 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37545 PyObject *resultobj = 0;
37546 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37547 void *argp1 = 0 ;
37548 int res1 = 0 ;
37549 PyObject *swig_obj[1] ;
37550
37551 if (!args) SWIG_fail;
37552 swig_obj[0] = args;
37553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37554 if (!SWIG_IsOK(res1)) {
37555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37556 }
37557 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37558 {
37559 PyThreadState* __tstate = wxPyBeginAllowThreads();
37560 delete arg1;
37561
37562 wxPyEndAllowThreads(__tstate);
37563 if (PyErr_Occurred()) SWIG_fail;
37564 }
37565 resultobj = SWIG_Py_Void();
37566 return resultobj;
37567 fail:
37568 return NULL;
37569 }
37570
37571
37572 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37573 PyObject *resultobj = 0;
37574 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37575 wxString *arg2 = 0 ;
37576 void *argp1 = 0 ;
37577 int res1 = 0 ;
37578 bool temp2 = false ;
37579 PyObject * obj0 = 0 ;
37580 PyObject * obj1 = 0 ;
37581 char * kwnames[] = {
37582 (char *) "self",(char *) "name", NULL
37583 };
37584
37585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37587 if (!SWIG_IsOK(res1)) {
37588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37589 }
37590 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37591 {
37592 arg2 = wxString_in_helper(obj1);
37593 if (arg2 == NULL) SWIG_fail;
37594 temp2 = true;
37595 }
37596 {
37597 PyThreadState* __tstate = wxPyBeginAllowThreads();
37598 (arg1)->SetName((wxString const &)*arg2);
37599 wxPyEndAllowThreads(__tstate);
37600 if (PyErr_Occurred()) SWIG_fail;
37601 }
37602 resultobj = SWIG_Py_Void();
37603 {
37604 if (temp2)
37605 delete arg2;
37606 }
37607 return resultobj;
37608 fail:
37609 {
37610 if (temp2)
37611 delete arg2;
37612 }
37613 return NULL;
37614 }
37615
37616
37617 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37618 PyObject *resultobj = 0;
37619 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37620 wxString result;
37621 void *argp1 = 0 ;
37622 int res1 = 0 ;
37623 PyObject *swig_obj[1] ;
37624
37625 if (!args) SWIG_fail;
37626 swig_obj[0] = args;
37627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37628 if (!SWIG_IsOK(res1)) {
37629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37630 }
37631 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37632 {
37633 PyThreadState* __tstate = wxPyBeginAllowThreads();
37634 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37635 wxPyEndAllowThreads(__tstate);
37636 if (PyErr_Occurred()) SWIG_fail;
37637 }
37638 {
37639 #if wxUSE_UNICODE
37640 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37641 #else
37642 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37643 #endif
37644 }
37645 return resultobj;
37646 fail:
37647 return NULL;
37648 }
37649
37650
37651 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37652 PyObject *resultobj = 0;
37653 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37654 wxString *arg2 = 0 ;
37655 void *argp1 = 0 ;
37656 int res1 = 0 ;
37657 bool temp2 = false ;
37658 PyObject * obj0 = 0 ;
37659 PyObject * obj1 = 0 ;
37660 char * kwnames[] = {
37661 (char *) "self",(char *) "version", NULL
37662 };
37663
37664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37666 if (!SWIG_IsOK(res1)) {
37667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37668 }
37669 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37670 {
37671 arg2 = wxString_in_helper(obj1);
37672 if (arg2 == NULL) SWIG_fail;
37673 temp2 = true;
37674 }
37675 {
37676 PyThreadState* __tstate = wxPyBeginAllowThreads();
37677 (arg1)->SetVersion((wxString const &)*arg2);
37678 wxPyEndAllowThreads(__tstate);
37679 if (PyErr_Occurred()) SWIG_fail;
37680 }
37681 resultobj = SWIG_Py_Void();
37682 {
37683 if (temp2)
37684 delete arg2;
37685 }
37686 return resultobj;
37687 fail:
37688 {
37689 if (temp2)
37690 delete arg2;
37691 }
37692 return NULL;
37693 }
37694
37695
37696 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37697 PyObject *resultobj = 0;
37698 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37699 bool result;
37700 void *argp1 = 0 ;
37701 int res1 = 0 ;
37702 PyObject *swig_obj[1] ;
37703
37704 if (!args) SWIG_fail;
37705 swig_obj[0] = args;
37706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37707 if (!SWIG_IsOK(res1)) {
37708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37709 }
37710 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37711 {
37712 PyThreadState* __tstate = wxPyBeginAllowThreads();
37713 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37714 wxPyEndAllowThreads(__tstate);
37715 if (PyErr_Occurred()) SWIG_fail;
37716 }
37717 {
37718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37719 }
37720 return resultobj;
37721 fail:
37722 return NULL;
37723 }
37724
37725
37726 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37727 PyObject *resultobj = 0;
37728 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37729 wxString result;
37730 void *argp1 = 0 ;
37731 int res1 = 0 ;
37732 PyObject *swig_obj[1] ;
37733
37734 if (!args) SWIG_fail;
37735 swig_obj[0] = args;
37736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37737 if (!SWIG_IsOK(res1)) {
37738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37739 }
37740 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37741 {
37742 PyThreadState* __tstate = wxPyBeginAllowThreads();
37743 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37744 wxPyEndAllowThreads(__tstate);
37745 if (PyErr_Occurred()) SWIG_fail;
37746 }
37747 {
37748 #if wxUSE_UNICODE
37749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37750 #else
37751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37752 #endif
37753 }
37754 return resultobj;
37755 fail:
37756 return NULL;
37757 }
37758
37759
37760 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37761 PyObject *resultobj = 0;
37762 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37763 wxString *arg2 = 0 ;
37764 void *argp1 = 0 ;
37765 int res1 = 0 ;
37766 bool temp2 = false ;
37767 PyObject * obj0 = 0 ;
37768 PyObject * obj1 = 0 ;
37769 char * kwnames[] = {
37770 (char *) "self",(char *) "desc", NULL
37771 };
37772
37773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37775 if (!SWIG_IsOK(res1)) {
37776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37777 }
37778 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37779 {
37780 arg2 = wxString_in_helper(obj1);
37781 if (arg2 == NULL) SWIG_fail;
37782 temp2 = true;
37783 }
37784 {
37785 PyThreadState* __tstate = wxPyBeginAllowThreads();
37786 (arg1)->SetDescription((wxString const &)*arg2);
37787 wxPyEndAllowThreads(__tstate);
37788 if (PyErr_Occurred()) SWIG_fail;
37789 }
37790 resultobj = SWIG_Py_Void();
37791 {
37792 if (temp2)
37793 delete arg2;
37794 }
37795 return resultobj;
37796 fail:
37797 {
37798 if (temp2)
37799 delete arg2;
37800 }
37801 return NULL;
37802 }
37803
37804
37805 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37806 PyObject *resultobj = 0;
37807 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37808 bool result;
37809 void *argp1 = 0 ;
37810 int res1 = 0 ;
37811 PyObject *swig_obj[1] ;
37812
37813 if (!args) SWIG_fail;
37814 swig_obj[0] = args;
37815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37816 if (!SWIG_IsOK(res1)) {
37817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37818 }
37819 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37820 {
37821 PyThreadState* __tstate = wxPyBeginAllowThreads();
37822 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37823 wxPyEndAllowThreads(__tstate);
37824 if (PyErr_Occurred()) SWIG_fail;
37825 }
37826 {
37827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37828 }
37829 return resultobj;
37830 fail:
37831 return NULL;
37832 }
37833
37834
37835 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37836 PyObject *resultobj = 0;
37837 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37838 wxString result;
37839 void *argp1 = 0 ;
37840 int res1 = 0 ;
37841 PyObject *swig_obj[1] ;
37842
37843 if (!args) SWIG_fail;
37844 swig_obj[0] = args;
37845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37846 if (!SWIG_IsOK(res1)) {
37847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37848 }
37849 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37850 {
37851 PyThreadState* __tstate = wxPyBeginAllowThreads();
37852 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37853 wxPyEndAllowThreads(__tstate);
37854 if (PyErr_Occurred()) SWIG_fail;
37855 }
37856 {
37857 #if wxUSE_UNICODE
37858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37859 #else
37860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37861 #endif
37862 }
37863 return resultobj;
37864 fail:
37865 return NULL;
37866 }
37867
37868
37869 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37870 PyObject *resultobj = 0;
37871 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37872 wxString *arg2 = 0 ;
37873 void *argp1 = 0 ;
37874 int res1 = 0 ;
37875 bool temp2 = false ;
37876 PyObject * obj0 = 0 ;
37877 PyObject * obj1 = 0 ;
37878 char * kwnames[] = {
37879 (char *) "self",(char *) "copyright", NULL
37880 };
37881
37882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37884 if (!SWIG_IsOK(res1)) {
37885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37886 }
37887 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37888 {
37889 arg2 = wxString_in_helper(obj1);
37890 if (arg2 == NULL) SWIG_fail;
37891 temp2 = true;
37892 }
37893 {
37894 PyThreadState* __tstate = wxPyBeginAllowThreads();
37895 (arg1)->SetCopyright((wxString const &)*arg2);
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 resultobj = SWIG_Py_Void();
37900 {
37901 if (temp2)
37902 delete arg2;
37903 }
37904 return resultobj;
37905 fail:
37906 {
37907 if (temp2)
37908 delete arg2;
37909 }
37910 return NULL;
37911 }
37912
37913
37914 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37915 PyObject *resultobj = 0;
37916 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37917 bool result;
37918 void *argp1 = 0 ;
37919 int res1 = 0 ;
37920 PyObject *swig_obj[1] ;
37921
37922 if (!args) SWIG_fail;
37923 swig_obj[0] = args;
37924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37925 if (!SWIG_IsOK(res1)) {
37926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37927 }
37928 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37929 {
37930 PyThreadState* __tstate = wxPyBeginAllowThreads();
37931 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37932 wxPyEndAllowThreads(__tstate);
37933 if (PyErr_Occurred()) SWIG_fail;
37934 }
37935 {
37936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37937 }
37938 return resultobj;
37939 fail:
37940 return NULL;
37941 }
37942
37943
37944 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37945 PyObject *resultobj = 0;
37946 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37947 wxString result;
37948 void *argp1 = 0 ;
37949 int res1 = 0 ;
37950 PyObject *swig_obj[1] ;
37951
37952 if (!args) SWIG_fail;
37953 swig_obj[0] = args;
37954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37955 if (!SWIG_IsOK(res1)) {
37956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37957 }
37958 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37959 {
37960 PyThreadState* __tstate = wxPyBeginAllowThreads();
37961 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37962 wxPyEndAllowThreads(__tstate);
37963 if (PyErr_Occurred()) SWIG_fail;
37964 }
37965 {
37966 #if wxUSE_UNICODE
37967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37968 #else
37969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37970 #endif
37971 }
37972 return resultobj;
37973 fail:
37974 return NULL;
37975 }
37976
37977
37978 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37979 PyObject *resultobj = 0;
37980 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37981 wxString *arg2 = 0 ;
37982 void *argp1 = 0 ;
37983 int res1 = 0 ;
37984 bool temp2 = false ;
37985 PyObject * obj0 = 0 ;
37986 PyObject * obj1 = 0 ;
37987 char * kwnames[] = {
37988 (char *) "self",(char *) "licence", NULL
37989 };
37990
37991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37993 if (!SWIG_IsOK(res1)) {
37994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37995 }
37996 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37997 {
37998 arg2 = wxString_in_helper(obj1);
37999 if (arg2 == NULL) SWIG_fail;
38000 temp2 = true;
38001 }
38002 {
38003 PyThreadState* __tstate = wxPyBeginAllowThreads();
38004 (arg1)->SetLicence((wxString const &)*arg2);
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 resultobj = SWIG_Py_Void();
38009 {
38010 if (temp2)
38011 delete arg2;
38012 }
38013 return resultobj;
38014 fail:
38015 {
38016 if (temp2)
38017 delete arg2;
38018 }
38019 return NULL;
38020 }
38021
38022
38023 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38024 PyObject *resultobj = 0;
38025 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38026 wxString *arg2 = 0 ;
38027 void *argp1 = 0 ;
38028 int res1 = 0 ;
38029 bool temp2 = false ;
38030 PyObject * obj0 = 0 ;
38031 PyObject * obj1 = 0 ;
38032 char * kwnames[] = {
38033 (char *) "self",(char *) "licence", NULL
38034 };
38035
38036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38038 if (!SWIG_IsOK(res1)) {
38039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38040 }
38041 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38042 {
38043 arg2 = wxString_in_helper(obj1);
38044 if (arg2 == NULL) SWIG_fail;
38045 temp2 = true;
38046 }
38047 {
38048 PyThreadState* __tstate = wxPyBeginAllowThreads();
38049 (arg1)->SetLicense((wxString const &)*arg2);
38050 wxPyEndAllowThreads(__tstate);
38051 if (PyErr_Occurred()) SWIG_fail;
38052 }
38053 resultobj = SWIG_Py_Void();
38054 {
38055 if (temp2)
38056 delete arg2;
38057 }
38058 return resultobj;
38059 fail:
38060 {
38061 if (temp2)
38062 delete arg2;
38063 }
38064 return NULL;
38065 }
38066
38067
38068 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38069 PyObject *resultobj = 0;
38070 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38071 bool result;
38072 void *argp1 = 0 ;
38073 int res1 = 0 ;
38074 PyObject *swig_obj[1] ;
38075
38076 if (!args) SWIG_fail;
38077 swig_obj[0] = args;
38078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38079 if (!SWIG_IsOK(res1)) {
38080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38081 }
38082 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38083 {
38084 PyThreadState* __tstate = wxPyBeginAllowThreads();
38085 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 {
38090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38091 }
38092 return resultobj;
38093 fail:
38094 return NULL;
38095 }
38096
38097
38098 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38099 PyObject *resultobj = 0;
38100 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38101 wxString result;
38102 void *argp1 = 0 ;
38103 int res1 = 0 ;
38104 PyObject *swig_obj[1] ;
38105
38106 if (!args) SWIG_fail;
38107 swig_obj[0] = args;
38108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38109 if (!SWIG_IsOK(res1)) {
38110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38111 }
38112 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38113 {
38114 PyThreadState* __tstate = wxPyBeginAllowThreads();
38115 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38116 wxPyEndAllowThreads(__tstate);
38117 if (PyErr_Occurred()) SWIG_fail;
38118 }
38119 {
38120 #if wxUSE_UNICODE
38121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38122 #else
38123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38124 #endif
38125 }
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38133 PyObject *resultobj = 0;
38134 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38135 wxIcon *arg2 = 0 ;
38136 void *argp1 = 0 ;
38137 int res1 = 0 ;
38138 void *argp2 = 0 ;
38139 int res2 = 0 ;
38140 PyObject * obj0 = 0 ;
38141 PyObject * obj1 = 0 ;
38142 char * kwnames[] = {
38143 (char *) "self",(char *) "icon", NULL
38144 };
38145
38146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38148 if (!SWIG_IsOK(res1)) {
38149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38150 }
38151 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38153 if (!SWIG_IsOK(res2)) {
38154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38155 }
38156 if (!argp2) {
38157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38158 }
38159 arg2 = reinterpret_cast< wxIcon * >(argp2);
38160 {
38161 PyThreadState* __tstate = wxPyBeginAllowThreads();
38162 (arg1)->SetIcon((wxIcon const &)*arg2);
38163 wxPyEndAllowThreads(__tstate);
38164 if (PyErr_Occurred()) SWIG_fail;
38165 }
38166 resultobj = SWIG_Py_Void();
38167 return resultobj;
38168 fail:
38169 return NULL;
38170 }
38171
38172
38173 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38174 PyObject *resultobj = 0;
38175 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38176 bool result;
38177 void *argp1 = 0 ;
38178 int res1 = 0 ;
38179 PyObject *swig_obj[1] ;
38180
38181 if (!args) SWIG_fail;
38182 swig_obj[0] = args;
38183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38184 if (!SWIG_IsOK(res1)) {
38185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38186 }
38187 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38188 {
38189 PyThreadState* __tstate = wxPyBeginAllowThreads();
38190 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38191 wxPyEndAllowThreads(__tstate);
38192 if (PyErr_Occurred()) SWIG_fail;
38193 }
38194 {
38195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38196 }
38197 return resultobj;
38198 fail:
38199 return NULL;
38200 }
38201
38202
38203 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38204 PyObject *resultobj = 0;
38205 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38206 wxIcon result;
38207 void *argp1 = 0 ;
38208 int res1 = 0 ;
38209 PyObject *swig_obj[1] ;
38210
38211 if (!args) SWIG_fail;
38212 swig_obj[0] = args;
38213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38216 }
38217 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38218 {
38219 PyThreadState* __tstate = wxPyBeginAllowThreads();
38220 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38221 wxPyEndAllowThreads(__tstate);
38222 if (PyErr_Occurred()) SWIG_fail;
38223 }
38224 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38225 return resultobj;
38226 fail:
38227 return NULL;
38228 }
38229
38230
38231 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38232 PyObject *resultobj = 0;
38233 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38234 wxString *arg2 = 0 ;
38235 wxString const &arg3_defvalue = wxEmptyString ;
38236 wxString *arg3 = (wxString *) &arg3_defvalue ;
38237 void *argp1 = 0 ;
38238 int res1 = 0 ;
38239 bool temp2 = false ;
38240 bool temp3 = false ;
38241 PyObject * obj0 = 0 ;
38242 PyObject * obj1 = 0 ;
38243 PyObject * obj2 = 0 ;
38244 char * kwnames[] = {
38245 (char *) "self",(char *) "url",(char *) "desc", NULL
38246 };
38247
38248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38250 if (!SWIG_IsOK(res1)) {
38251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38252 }
38253 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38254 {
38255 arg2 = wxString_in_helper(obj1);
38256 if (arg2 == NULL) SWIG_fail;
38257 temp2 = true;
38258 }
38259 if (obj2) {
38260 {
38261 arg3 = wxString_in_helper(obj2);
38262 if (arg3 == NULL) SWIG_fail;
38263 temp3 = true;
38264 }
38265 }
38266 {
38267 PyThreadState* __tstate = wxPyBeginAllowThreads();
38268 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38269 wxPyEndAllowThreads(__tstate);
38270 if (PyErr_Occurred()) SWIG_fail;
38271 }
38272 resultobj = SWIG_Py_Void();
38273 {
38274 if (temp2)
38275 delete arg2;
38276 }
38277 {
38278 if (temp3)
38279 delete arg3;
38280 }
38281 return resultobj;
38282 fail:
38283 {
38284 if (temp2)
38285 delete arg2;
38286 }
38287 {
38288 if (temp3)
38289 delete arg3;
38290 }
38291 return NULL;
38292 }
38293
38294
38295 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38296 PyObject *resultobj = 0;
38297 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38298 wxString result;
38299 void *argp1 = 0 ;
38300 int res1 = 0 ;
38301 PyObject *swig_obj[1] ;
38302
38303 if (!args) SWIG_fail;
38304 swig_obj[0] = args;
38305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38306 if (!SWIG_IsOK(res1)) {
38307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38308 }
38309 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38310 {
38311 PyThreadState* __tstate = wxPyBeginAllowThreads();
38312 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38313 wxPyEndAllowThreads(__tstate);
38314 if (PyErr_Occurred()) SWIG_fail;
38315 }
38316 {
38317 #if wxUSE_UNICODE
38318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38319 #else
38320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38321 #endif
38322 }
38323 return resultobj;
38324 fail:
38325 return NULL;
38326 }
38327
38328
38329 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38330 PyObject *resultobj = 0;
38331 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38332 wxString result;
38333 void *argp1 = 0 ;
38334 int res1 = 0 ;
38335 PyObject *swig_obj[1] ;
38336
38337 if (!args) SWIG_fail;
38338 swig_obj[0] = args;
38339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38340 if (!SWIG_IsOK(res1)) {
38341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38342 }
38343 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38347 wxPyEndAllowThreads(__tstate);
38348 if (PyErr_Occurred()) SWIG_fail;
38349 }
38350 {
38351 #if wxUSE_UNICODE
38352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38353 #else
38354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38355 #endif
38356 }
38357 return resultobj;
38358 fail:
38359 return NULL;
38360 }
38361
38362
38363 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38364 PyObject *resultobj = 0;
38365 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38366 bool result;
38367 void *argp1 = 0 ;
38368 int res1 = 0 ;
38369 PyObject *swig_obj[1] ;
38370
38371 if (!args) SWIG_fail;
38372 swig_obj[0] = args;
38373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38374 if (!SWIG_IsOK(res1)) {
38375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38376 }
38377 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38378 {
38379 PyThreadState* __tstate = wxPyBeginAllowThreads();
38380 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38381 wxPyEndAllowThreads(__tstate);
38382 if (PyErr_Occurred()) SWIG_fail;
38383 }
38384 {
38385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38386 }
38387 return resultobj;
38388 fail:
38389 return NULL;
38390 }
38391
38392
38393 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38394 PyObject *resultobj = 0;
38395 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38396 wxArrayString *arg2 = 0 ;
38397 void *argp1 = 0 ;
38398 int res1 = 0 ;
38399 bool temp2 = false ;
38400 PyObject * obj0 = 0 ;
38401 PyObject * obj1 = 0 ;
38402 char * kwnames[] = {
38403 (char *) "self",(char *) "developers", NULL
38404 };
38405
38406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38408 if (!SWIG_IsOK(res1)) {
38409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38410 }
38411 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38412 {
38413 if (! PySequence_Check(obj1)) {
38414 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38415 SWIG_fail;
38416 }
38417 arg2 = new wxArrayString;
38418 temp2 = true;
38419 int i, len=PySequence_Length(obj1);
38420 for (i=0; i<len; i++) {
38421 PyObject* item = PySequence_GetItem(obj1, i);
38422 wxString* s = wxString_in_helper(item);
38423 if (PyErr_Occurred()) SWIG_fail;
38424 arg2->Add(*s);
38425 delete s;
38426 Py_DECREF(item);
38427 }
38428 }
38429 {
38430 PyThreadState* __tstate = wxPyBeginAllowThreads();
38431 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38432 wxPyEndAllowThreads(__tstate);
38433 if (PyErr_Occurred()) SWIG_fail;
38434 }
38435 resultobj = SWIG_Py_Void();
38436 {
38437 if (temp2) delete arg2;
38438 }
38439 return resultobj;
38440 fail:
38441 {
38442 if (temp2) delete arg2;
38443 }
38444 return NULL;
38445 }
38446
38447
38448 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38449 PyObject *resultobj = 0;
38450 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38451 wxString *arg2 = 0 ;
38452 void *argp1 = 0 ;
38453 int res1 = 0 ;
38454 bool temp2 = false ;
38455 PyObject * obj0 = 0 ;
38456 PyObject * obj1 = 0 ;
38457 char * kwnames[] = {
38458 (char *) "self",(char *) "developer", NULL
38459 };
38460
38461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38463 if (!SWIG_IsOK(res1)) {
38464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38465 }
38466 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38467 {
38468 arg2 = wxString_in_helper(obj1);
38469 if (arg2 == NULL) SWIG_fail;
38470 temp2 = true;
38471 }
38472 {
38473 PyThreadState* __tstate = wxPyBeginAllowThreads();
38474 (arg1)->AddDeveloper((wxString const &)*arg2);
38475 wxPyEndAllowThreads(__tstate);
38476 if (PyErr_Occurred()) SWIG_fail;
38477 }
38478 resultobj = SWIG_Py_Void();
38479 {
38480 if (temp2)
38481 delete arg2;
38482 }
38483 return resultobj;
38484 fail:
38485 {
38486 if (temp2)
38487 delete arg2;
38488 }
38489 return NULL;
38490 }
38491
38492
38493 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38494 PyObject *resultobj = 0;
38495 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38496 bool result;
38497 void *argp1 = 0 ;
38498 int res1 = 0 ;
38499 PyObject *swig_obj[1] ;
38500
38501 if (!args) SWIG_fail;
38502 swig_obj[0] = args;
38503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38504 if (!SWIG_IsOK(res1)) {
38505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38506 }
38507 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38508 {
38509 PyThreadState* __tstate = wxPyBeginAllowThreads();
38510 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38511 wxPyEndAllowThreads(__tstate);
38512 if (PyErr_Occurred()) SWIG_fail;
38513 }
38514 {
38515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38516 }
38517 return resultobj;
38518 fail:
38519 return NULL;
38520 }
38521
38522
38523 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38524 PyObject *resultobj = 0;
38525 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38526 wxArrayString *result = 0 ;
38527 void *argp1 = 0 ;
38528 int res1 = 0 ;
38529 PyObject *swig_obj[1] ;
38530
38531 if (!args) SWIG_fail;
38532 swig_obj[0] = args;
38533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38534 if (!SWIG_IsOK(res1)) {
38535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38536 }
38537 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38538 {
38539 PyThreadState* __tstate = wxPyBeginAllowThreads();
38540 {
38541 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38542 result = (wxArrayString *) &_result_ref;
38543 }
38544 wxPyEndAllowThreads(__tstate);
38545 if (PyErr_Occurred()) SWIG_fail;
38546 }
38547 {
38548 resultobj = wxArrayString2PyList_helper(*result);
38549 }
38550 return resultobj;
38551 fail:
38552 return NULL;
38553 }
38554
38555
38556 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38557 PyObject *resultobj = 0;
38558 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38559 wxArrayString *arg2 = 0 ;
38560 void *argp1 = 0 ;
38561 int res1 = 0 ;
38562 bool temp2 = false ;
38563 PyObject * obj0 = 0 ;
38564 PyObject * obj1 = 0 ;
38565 char * kwnames[] = {
38566 (char *) "self",(char *) "docwriters", NULL
38567 };
38568
38569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38571 if (!SWIG_IsOK(res1)) {
38572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38573 }
38574 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38575 {
38576 if (! PySequence_Check(obj1)) {
38577 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38578 SWIG_fail;
38579 }
38580 arg2 = new wxArrayString;
38581 temp2 = true;
38582 int i, len=PySequence_Length(obj1);
38583 for (i=0; i<len; i++) {
38584 PyObject* item = PySequence_GetItem(obj1, i);
38585 wxString* s = wxString_in_helper(item);
38586 if (PyErr_Occurred()) SWIG_fail;
38587 arg2->Add(*s);
38588 delete s;
38589 Py_DECREF(item);
38590 }
38591 }
38592 {
38593 PyThreadState* __tstate = wxPyBeginAllowThreads();
38594 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38595 wxPyEndAllowThreads(__tstate);
38596 if (PyErr_Occurred()) SWIG_fail;
38597 }
38598 resultobj = SWIG_Py_Void();
38599 {
38600 if (temp2) delete arg2;
38601 }
38602 return resultobj;
38603 fail:
38604 {
38605 if (temp2) delete arg2;
38606 }
38607 return NULL;
38608 }
38609
38610
38611 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38612 PyObject *resultobj = 0;
38613 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38614 wxString *arg2 = 0 ;
38615 void *argp1 = 0 ;
38616 int res1 = 0 ;
38617 bool temp2 = false ;
38618 PyObject * obj0 = 0 ;
38619 PyObject * obj1 = 0 ;
38620 char * kwnames[] = {
38621 (char *) "self",(char *) "docwriter", NULL
38622 };
38623
38624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38626 if (!SWIG_IsOK(res1)) {
38627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38628 }
38629 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38630 {
38631 arg2 = wxString_in_helper(obj1);
38632 if (arg2 == NULL) SWIG_fail;
38633 temp2 = true;
38634 }
38635 {
38636 PyThreadState* __tstate = wxPyBeginAllowThreads();
38637 (arg1)->AddDocWriter((wxString const &)*arg2);
38638 wxPyEndAllowThreads(__tstate);
38639 if (PyErr_Occurred()) SWIG_fail;
38640 }
38641 resultobj = SWIG_Py_Void();
38642 {
38643 if (temp2)
38644 delete arg2;
38645 }
38646 return resultobj;
38647 fail:
38648 {
38649 if (temp2)
38650 delete arg2;
38651 }
38652 return NULL;
38653 }
38654
38655
38656 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38657 PyObject *resultobj = 0;
38658 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38659 bool result;
38660 void *argp1 = 0 ;
38661 int res1 = 0 ;
38662 PyObject *swig_obj[1] ;
38663
38664 if (!args) SWIG_fail;
38665 swig_obj[0] = args;
38666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38667 if (!SWIG_IsOK(res1)) {
38668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38669 }
38670 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38671 {
38672 PyThreadState* __tstate = wxPyBeginAllowThreads();
38673 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38674 wxPyEndAllowThreads(__tstate);
38675 if (PyErr_Occurred()) SWIG_fail;
38676 }
38677 {
38678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38679 }
38680 return resultobj;
38681 fail:
38682 return NULL;
38683 }
38684
38685
38686 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38687 PyObject *resultobj = 0;
38688 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38689 wxArrayString *result = 0 ;
38690 void *argp1 = 0 ;
38691 int res1 = 0 ;
38692 PyObject *swig_obj[1] ;
38693
38694 if (!args) SWIG_fail;
38695 swig_obj[0] = args;
38696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38697 if (!SWIG_IsOK(res1)) {
38698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38699 }
38700 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38701 {
38702 PyThreadState* __tstate = wxPyBeginAllowThreads();
38703 {
38704 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38705 result = (wxArrayString *) &_result_ref;
38706 }
38707 wxPyEndAllowThreads(__tstate);
38708 if (PyErr_Occurred()) SWIG_fail;
38709 }
38710 {
38711 resultobj = wxArrayString2PyList_helper(*result);
38712 }
38713 return resultobj;
38714 fail:
38715 return NULL;
38716 }
38717
38718
38719 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38720 PyObject *resultobj = 0;
38721 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38722 wxArrayString *arg2 = 0 ;
38723 void *argp1 = 0 ;
38724 int res1 = 0 ;
38725 bool temp2 = false ;
38726 PyObject * obj0 = 0 ;
38727 PyObject * obj1 = 0 ;
38728 char * kwnames[] = {
38729 (char *) "self",(char *) "artists", NULL
38730 };
38731
38732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38734 if (!SWIG_IsOK(res1)) {
38735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38736 }
38737 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38738 {
38739 if (! PySequence_Check(obj1)) {
38740 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38741 SWIG_fail;
38742 }
38743 arg2 = new wxArrayString;
38744 temp2 = true;
38745 int i, len=PySequence_Length(obj1);
38746 for (i=0; i<len; i++) {
38747 PyObject* item = PySequence_GetItem(obj1, i);
38748 wxString* s = wxString_in_helper(item);
38749 if (PyErr_Occurred()) SWIG_fail;
38750 arg2->Add(*s);
38751 delete s;
38752 Py_DECREF(item);
38753 }
38754 }
38755 {
38756 PyThreadState* __tstate = wxPyBeginAllowThreads();
38757 (arg1)->SetArtists((wxArrayString const &)*arg2);
38758 wxPyEndAllowThreads(__tstate);
38759 if (PyErr_Occurred()) SWIG_fail;
38760 }
38761 resultobj = SWIG_Py_Void();
38762 {
38763 if (temp2) delete arg2;
38764 }
38765 return resultobj;
38766 fail:
38767 {
38768 if (temp2) delete arg2;
38769 }
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38775 PyObject *resultobj = 0;
38776 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38777 wxString *arg2 = 0 ;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 bool temp2 = false ;
38781 PyObject * obj0 = 0 ;
38782 PyObject * obj1 = 0 ;
38783 char * kwnames[] = {
38784 (char *) "self",(char *) "artist", NULL
38785 };
38786
38787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38789 if (!SWIG_IsOK(res1)) {
38790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38791 }
38792 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38793 {
38794 arg2 = wxString_in_helper(obj1);
38795 if (arg2 == NULL) SWIG_fail;
38796 temp2 = true;
38797 }
38798 {
38799 PyThreadState* __tstate = wxPyBeginAllowThreads();
38800 (arg1)->AddArtist((wxString const &)*arg2);
38801 wxPyEndAllowThreads(__tstate);
38802 if (PyErr_Occurred()) SWIG_fail;
38803 }
38804 resultobj = SWIG_Py_Void();
38805 {
38806 if (temp2)
38807 delete arg2;
38808 }
38809 return resultobj;
38810 fail:
38811 {
38812 if (temp2)
38813 delete arg2;
38814 }
38815 return NULL;
38816 }
38817
38818
38819 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38820 PyObject *resultobj = 0;
38821 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38822 bool result;
38823 void *argp1 = 0 ;
38824 int res1 = 0 ;
38825 PyObject *swig_obj[1] ;
38826
38827 if (!args) SWIG_fail;
38828 swig_obj[0] = args;
38829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38830 if (!SWIG_IsOK(res1)) {
38831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38832 }
38833 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38834 {
38835 PyThreadState* __tstate = wxPyBeginAllowThreads();
38836 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38837 wxPyEndAllowThreads(__tstate);
38838 if (PyErr_Occurred()) SWIG_fail;
38839 }
38840 {
38841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38842 }
38843 return resultobj;
38844 fail:
38845 return NULL;
38846 }
38847
38848
38849 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38850 PyObject *resultobj = 0;
38851 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38852 wxArrayString *result = 0 ;
38853 void *argp1 = 0 ;
38854 int res1 = 0 ;
38855 PyObject *swig_obj[1] ;
38856
38857 if (!args) SWIG_fail;
38858 swig_obj[0] = args;
38859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38860 if (!SWIG_IsOK(res1)) {
38861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38862 }
38863 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38864 {
38865 PyThreadState* __tstate = wxPyBeginAllowThreads();
38866 {
38867 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38868 result = (wxArrayString *) &_result_ref;
38869 }
38870 wxPyEndAllowThreads(__tstate);
38871 if (PyErr_Occurred()) SWIG_fail;
38872 }
38873 {
38874 resultobj = wxArrayString2PyList_helper(*result);
38875 }
38876 return resultobj;
38877 fail:
38878 return NULL;
38879 }
38880
38881
38882 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38883 PyObject *resultobj = 0;
38884 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38885 wxArrayString *arg2 = 0 ;
38886 void *argp1 = 0 ;
38887 int res1 = 0 ;
38888 bool temp2 = false ;
38889 PyObject * obj0 = 0 ;
38890 PyObject * obj1 = 0 ;
38891 char * kwnames[] = {
38892 (char *) "self",(char *) "translators", NULL
38893 };
38894
38895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38897 if (!SWIG_IsOK(res1)) {
38898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38899 }
38900 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38901 {
38902 if (! PySequence_Check(obj1)) {
38903 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38904 SWIG_fail;
38905 }
38906 arg2 = new wxArrayString;
38907 temp2 = true;
38908 int i, len=PySequence_Length(obj1);
38909 for (i=0; i<len; i++) {
38910 PyObject* item = PySequence_GetItem(obj1, i);
38911 wxString* s = wxString_in_helper(item);
38912 if (PyErr_Occurred()) SWIG_fail;
38913 arg2->Add(*s);
38914 delete s;
38915 Py_DECREF(item);
38916 }
38917 }
38918 {
38919 PyThreadState* __tstate = wxPyBeginAllowThreads();
38920 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38921 wxPyEndAllowThreads(__tstate);
38922 if (PyErr_Occurred()) SWIG_fail;
38923 }
38924 resultobj = SWIG_Py_Void();
38925 {
38926 if (temp2) delete arg2;
38927 }
38928 return resultobj;
38929 fail:
38930 {
38931 if (temp2) delete arg2;
38932 }
38933 return NULL;
38934 }
38935
38936
38937 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38938 PyObject *resultobj = 0;
38939 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38940 wxString *arg2 = 0 ;
38941 void *argp1 = 0 ;
38942 int res1 = 0 ;
38943 bool temp2 = false ;
38944 PyObject * obj0 = 0 ;
38945 PyObject * obj1 = 0 ;
38946 char * kwnames[] = {
38947 (char *) "self",(char *) "translator", NULL
38948 };
38949
38950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38952 if (!SWIG_IsOK(res1)) {
38953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38954 }
38955 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38956 {
38957 arg2 = wxString_in_helper(obj1);
38958 if (arg2 == NULL) SWIG_fail;
38959 temp2 = true;
38960 }
38961 {
38962 PyThreadState* __tstate = wxPyBeginAllowThreads();
38963 (arg1)->AddTranslator((wxString const &)*arg2);
38964 wxPyEndAllowThreads(__tstate);
38965 if (PyErr_Occurred()) SWIG_fail;
38966 }
38967 resultobj = SWIG_Py_Void();
38968 {
38969 if (temp2)
38970 delete arg2;
38971 }
38972 return resultobj;
38973 fail:
38974 {
38975 if (temp2)
38976 delete arg2;
38977 }
38978 return NULL;
38979 }
38980
38981
38982 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38983 PyObject *resultobj = 0;
38984 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38985 bool result;
38986 void *argp1 = 0 ;
38987 int res1 = 0 ;
38988 PyObject *swig_obj[1] ;
38989
38990 if (!args) SWIG_fail;
38991 swig_obj[0] = args;
38992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38993 if (!SWIG_IsOK(res1)) {
38994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38995 }
38996 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38997 {
38998 PyThreadState* __tstate = wxPyBeginAllowThreads();
38999 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39000 wxPyEndAllowThreads(__tstate);
39001 if (PyErr_Occurred()) SWIG_fail;
39002 }
39003 {
39004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39005 }
39006 return resultobj;
39007 fail:
39008 return NULL;
39009 }
39010
39011
39012 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39013 PyObject *resultobj = 0;
39014 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39015 wxArrayString *result = 0 ;
39016 void *argp1 = 0 ;
39017 int res1 = 0 ;
39018 PyObject *swig_obj[1] ;
39019
39020 if (!args) SWIG_fail;
39021 swig_obj[0] = args;
39022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39023 if (!SWIG_IsOK(res1)) {
39024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39025 }
39026 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39027 {
39028 PyThreadState* __tstate = wxPyBeginAllowThreads();
39029 {
39030 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39031 result = (wxArrayString *) &_result_ref;
39032 }
39033 wxPyEndAllowThreads(__tstate);
39034 if (PyErr_Occurred()) SWIG_fail;
39035 }
39036 {
39037 resultobj = wxArrayString2PyList_helper(*result);
39038 }
39039 return resultobj;
39040 fail:
39041 return NULL;
39042 }
39043
39044
39045 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39046 PyObject *resultobj = 0;
39047 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39048 bool result;
39049 void *argp1 = 0 ;
39050 int res1 = 0 ;
39051 PyObject *swig_obj[1] ;
39052
39053 if (!args) SWIG_fail;
39054 swig_obj[0] = args;
39055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39056 if (!SWIG_IsOK(res1)) {
39057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39058 }
39059 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39060 {
39061 PyThreadState* __tstate = wxPyBeginAllowThreads();
39062 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39063 wxPyEndAllowThreads(__tstate);
39064 if (PyErr_Occurred()) SWIG_fail;
39065 }
39066 {
39067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39068 }
39069 return resultobj;
39070 fail:
39071 return NULL;
39072 }
39073
39074
39075 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39076 PyObject *resultobj = 0;
39077 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39078 wxString result;
39079 void *argp1 = 0 ;
39080 int res1 = 0 ;
39081 PyObject *swig_obj[1] ;
39082
39083 if (!args) SWIG_fail;
39084 swig_obj[0] = args;
39085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39086 if (!SWIG_IsOK(res1)) {
39087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39088 }
39089 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39090 {
39091 PyThreadState* __tstate = wxPyBeginAllowThreads();
39092 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39093 wxPyEndAllowThreads(__tstate);
39094 if (PyErr_Occurred()) SWIG_fail;
39095 }
39096 {
39097 #if wxUSE_UNICODE
39098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39099 #else
39100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39101 #endif
39102 }
39103 return resultobj;
39104 fail:
39105 return NULL;
39106 }
39107
39108
39109 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39110 PyObject *obj;
39111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39112 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39113 return SWIG_Py_Void();
39114 }
39115
39116 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39117 return SWIG_Python_InitShadowInstance(args);
39118 }
39119
39120 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39121 PyObject *resultobj = 0;
39122 wxAboutDialogInfo *arg1 = 0 ;
39123 void *argp1 = 0 ;
39124 int res1 = 0 ;
39125 PyObject * obj0 = 0 ;
39126 char * kwnames[] = {
39127 (char *) "info", NULL
39128 };
39129
39130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39131 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39132 if (!SWIG_IsOK(res1)) {
39133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39134 }
39135 if (!argp1) {
39136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39137 }
39138 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39139 {
39140 PyThreadState* __tstate = wxPyBeginAllowThreads();
39141 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39142 wxPyEndAllowThreads(__tstate);
39143 if (PyErr_Occurred()) SWIG_fail;
39144 }
39145 resultobj = SWIG_Py_Void();
39146 return resultobj;
39147 fail:
39148 return NULL;
39149 }
39150
39151
39152 static PyMethodDef SwigMethods[] = {
39153 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39154 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39155 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39156 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39157 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39158 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39159 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39160 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39161 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39162 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39163 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39164 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39165 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39166 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39167 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39168 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39169 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39170 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39171 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39172 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39173 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39174 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39175 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39176 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39177 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39178 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39179 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39180 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39181 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39182 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39183 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39184 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39185 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39186 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39187 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39188 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39189 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39195 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39196 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39197 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39198 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39199 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39200 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39201 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39202 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39203 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39204 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39205 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39206 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39207 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39208 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39209 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39210 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39214 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39215 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39216 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39217 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39218 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39219 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39220 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39221 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39222 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39223 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39224 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39225 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39226 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39227 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39228 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39234 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39235 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39236 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39237 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39238 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39239 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39240 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39241 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39242 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39243 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39244 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39245 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39250 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39251 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39252 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39253 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39255 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39256 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39257 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39258 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39259 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39260 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39261 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39262 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39263 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39264 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39265 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39267 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39268 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39269 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39270 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39271 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39273 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39274 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39276 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39277 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39278 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39279 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39280 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39281 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39282 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39283 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39284 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39285 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39290 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39291 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39292 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39293 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39294 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39295 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39296 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39297 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39298 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39299 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39300 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39301 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39302 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39304 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39305 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39306 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39307 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39308 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39310 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39311 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39312 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39313 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39314 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39316 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39318 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39319 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39320 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39324 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39326 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39327 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39328 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39329 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39330 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39331 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39332 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39333 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39334 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39335 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39336 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39337 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39338 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39340 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39341 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39342 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39343 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39344 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39346 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39347 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39348 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39349 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39350 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39351 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39352 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39353 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39354 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39355 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39356 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39357 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39363 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39364 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39365 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39367 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39368 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39369 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39370 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39371 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39372 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39373 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39374 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39375 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39376 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39377 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39379 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39382 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39383 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39384 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39385 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39386 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39387 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39388 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39389 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39390 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39391 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39393 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39394 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39395 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39396 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39397 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39398 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39399 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39400 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39401 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39402 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39403 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39406 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39407 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39408 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39410 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39411 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39414 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39415 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39416 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39418 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39419 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39420 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39421 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39422 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39423 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39424 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39426 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39427 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39428 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39429 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39430 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39431 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39432 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39433 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39434 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39436 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39437 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39438 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39439 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39440 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39442 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39443 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39444 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39445 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39446 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39447 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39448 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39450 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39452 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39453 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39454 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39455 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39456 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39457 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39458 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39459 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39460 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39461 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39462 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39467 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39468 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39469 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39470 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39472 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39473 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39474 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39475 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39476 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39477 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39478 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39479 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39480 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39481 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39482 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39483 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39484 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39485 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39487 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39488 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39489 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39491 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39492 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39493 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39494 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39495 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39496 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39497 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39498 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39499 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39500 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39501 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39502 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39503 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39504 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39505 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39506 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39507 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39508 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39509 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39510 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39511 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39512 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39515 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39516 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39517 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39518 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39519 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39520 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39521 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39522 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39523 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39524 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39526 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39527 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39528 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39529 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39530 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39531 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39532 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39533 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39534 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39535 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39536 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39537 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39538 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39539 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39540 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39541 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39542 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39543 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39544 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39545 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39546 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39547 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39548 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39549 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39550 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39551 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39552 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39553 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39554 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39555 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39557 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39558 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39559 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39560 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39561 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39562 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39563 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39564 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39565 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39566 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39571 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39572 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39573 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39575 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39576 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39577 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39578 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39579 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39580 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39581 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39583 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39584 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39585 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39586 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39587 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39588 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39589 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39590 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39591 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39592 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39593 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39594 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39595 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39596 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39597 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39598 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39599 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39600 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39601 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39602 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39603 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39604 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39605 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39606 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39608 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39609 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39610 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39611 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39612 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39613 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39614 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39620 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39622 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39623 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39625 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39627 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39628 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39632 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39633 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39634 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39636 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39637 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39638 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39639 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39640 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39641 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39642 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39643 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39644 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39645 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39649 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39650 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39651 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39652 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39655 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39656 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39658 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39659 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39661 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39682 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39684 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39686 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39688 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39689 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39693 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39694 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39696 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39697 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39698 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39700 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39701 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39702 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39704 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39705 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39706 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39707 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39710 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39721 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39725 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39726 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39727 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39728 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39734 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39735 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39740 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39764 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39765 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39766 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39767 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39768 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39780 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39781 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39807 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39808 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39809 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39810 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39823 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39824 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39825 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39826 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39827 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39828 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39830 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39832 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39834 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39836 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39838 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39840 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39842 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39846 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39847 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39851 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39862 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39863 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39864 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39865 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39868 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39869 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39870 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39871 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39872 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39873 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39875 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39876 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39878 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39880 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39882 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39884 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39886 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39891 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39892 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39893 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39894 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39895 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39898 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39902 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39910 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39911 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39912 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39913 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39914 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39915 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39917 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39918 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39919 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39920 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39921 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39922 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39923 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39925 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39926 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39927 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39935 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39937 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39939 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39940 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39942 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39943 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39946 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39947 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39948 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39949 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39950 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39951 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39952 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39954 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39955 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39957 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39958 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39961 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39962 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39964 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39965 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39966 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39967 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39970 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39971 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39972 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39973 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39975 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39976 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39977 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39978 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39979 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39980 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39981 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39982 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39984 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39986 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39987 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39988 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
39990 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39991 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39992 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39994 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39995 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39996 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39998 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39999 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40002 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40003 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40004 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40005 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40006 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40007 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40008 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40009 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40010 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40011 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40012 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40013 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40015 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40016 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40017 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40018 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40019 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40020 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40023 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40024 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40026 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40027 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40028 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40032 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40033 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40034 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40035 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40036 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40037 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40038 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40039 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40040 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40041 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40042 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40043 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40047 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40048 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40049 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40050 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40051 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40052 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40053 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40054 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40055 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40056 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40057 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40059 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40060 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40061 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40062 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40063 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40064 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40065 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40067 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40068 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40069 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40070 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40071 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40072 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40073 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40074 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40075 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40076 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40077 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40078 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40079 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40082 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40083 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40084 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40085 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40086 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40088 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40090 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40091 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40092 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40093 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40094 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40095 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40096 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40097 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40098 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40099 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40100 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40101 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40102 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40103 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40104 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40105 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40106 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40107 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40108 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40109 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40110 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40111 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40112 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40113 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40114 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40115 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40116 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40117 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40118 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40119 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40120 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40121 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40122 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40123 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40124 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40125 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40126 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40127 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40128 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40129 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40130 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40131 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40132 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40133 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40134 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40135 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40136 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40137 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40138 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40139 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40140 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40141 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40142 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40143 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40144 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40145 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40146 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40147 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40148 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40149 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40150 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40151 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40152 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40153 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40154 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40155 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40156 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40157 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40158 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40159 { NULL, NULL, 0, NULL }
40160 };
40161
40162
40163 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40164
40165 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40166 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40167 }
40168 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40169 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40170 }
40171 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40172 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40173 }
40174 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40175 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40176 }
40177 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40178 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40179 }
40180 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40181 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40182 }
40183 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40184 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40185 }
40186 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40187 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40188 }
40189 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40190 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40191 }
40192 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40193 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40194 }
40195 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40196 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40197 }
40198 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40199 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40200 }
40201 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40202 return (void *)((wxEvent *) ((wxPyEvent *) x));
40203 }
40204 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40205 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40206 }
40207 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40208 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40209 }
40210 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40211 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40212 }
40213 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40214 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40215 }
40216 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40217 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40218 }
40219 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40220 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40221 }
40222 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40223 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40224 }
40225 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40226 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40227 }
40228 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40229 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40230 }
40231 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40232 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40233 }
40234 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40235 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40236 }
40237 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40238 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40239 }
40240 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40241 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40242 }
40243 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40244 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40245 }
40246 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40247 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40248 }
40249 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40250 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40251 }
40252 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40253 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40254 }
40255 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40256 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40257 }
40258 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40259 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40260 }
40261 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40262 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40263 }
40264 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40265 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40266 }
40267 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40268 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40269 }
40270 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40271 return (void *)((wxEvent *) ((wxShowEvent *) x));
40272 }
40273 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40274 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40275 }
40276 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40277 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40278 }
40279 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40280 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40281 }
40282 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40283 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40284 }
40285 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40286 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40287 }
40288 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40289 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40290 }
40291 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40292 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40293 }
40294 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40295 return (void *)((wxConfigBase *) ((wxConfig *) x));
40296 }
40297 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40298 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40299 }
40300 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40301 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40302 }
40303 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40304 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40305 }
40306 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40307 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40308 }
40309 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40310 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40311 }
40312 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40313 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40314 }
40315 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40316 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40317 }
40318 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40319 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40320 }
40321 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40322 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40323 }
40324 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40325 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40326 }
40327 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40328 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40329 }
40330 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40331 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40332 }
40333 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40334 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40335 }
40336 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40337 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40338 }
40339 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40340 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40341 }
40342 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40343 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40344 }
40345 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40346 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40347 }
40348 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40349 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40350 }
40351 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40352 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40353 }
40354 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40355 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40356 }
40357 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40358 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40359 }
40360 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40361 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40362 }
40363 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40364 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40365 }
40366 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40367 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40368 }
40369 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40370 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40371 }
40372 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40373 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40374 }
40375 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40376 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40377 }
40378 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40379 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40380 }
40381 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40382 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40383 }
40384 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40385 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40386 }
40387 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40388 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40389 }
40390 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40391 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40392 }
40393 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40394 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40395 }
40396 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40397 return (void *)((wxObject *) ((wxSizerItem *) x));
40398 }
40399 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40400 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40401 }
40402 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40403 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40404 }
40405 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40406 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40407 }
40408 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40409 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40410 }
40411 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40412 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40413 }
40414 static void *_p_wxSizerTo_p_wxObject(void *x) {
40415 return (void *)((wxObject *) ((wxSizer *) x));
40416 }
40417 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40418 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40419 }
40420 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40421 return (void *)((wxObject *) ((wxFileHistory *) x));
40422 }
40423 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40424 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40425 }
40426 static void *_p_wxEventTo_p_wxObject(void *x) {
40427 return (void *)((wxObject *) ((wxEvent *) x));
40428 }
40429 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40430 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40431 }
40432 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40433 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40434 }
40435 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40436 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40437 }
40438 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40439 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40440 }
40441 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40442 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40443 }
40444 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40445 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40446 }
40447 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40448 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40449 }
40450 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40451 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40452 }
40453 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40454 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40455 }
40456 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40457 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40458 }
40459 static void *_p_wxControlTo_p_wxObject(void *x) {
40460 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40461 }
40462 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40463 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40464 }
40465 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40466 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40467 }
40468 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40469 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40470 }
40471 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40472 return (void *)((wxObject *) ((wxFSFile *) x));
40473 }
40474 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40475 return (void *)((wxObject *) ((wxClipboard *) x));
40476 }
40477 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40478 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40479 }
40480 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40481 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40482 }
40483 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40485 }
40486 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40487 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40488 }
40489 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40490 return (void *)((wxObject *) ((wxToolTip *) x));
40491 }
40492 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40493 return (void *)((wxObject *) ((wxMenuItem *) x));
40494 }
40495 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40496 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40497 }
40498 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40499 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40500 }
40501 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40502 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40503 }
40504 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40505 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40506 }
40507 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40508 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40509 }
40510 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40511 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40512 }
40513 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40514 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40515 }
40516 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40517 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40518 }
40519 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40520 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40521 }
40522 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40523 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40524 }
40525 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40526 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40527 }
40528 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40529 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40530 }
40531 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40532 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40533 }
40534 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40535 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40536 }
40537 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40538 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40539 }
40540 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40541 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40542 }
40543 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40544 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40545 }
40546 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40547 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40548 }
40549 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40550 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40551 }
40552 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40553 return (void *)((wxObject *) ((wxImageHandler *) x));
40554 }
40555 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40556 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40557 }
40558 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40559 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40560 }
40561 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40562 return (void *)((wxObject *) ((wxEvtHandler *) x));
40563 }
40564 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40565 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40566 }
40567 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40568 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40569 }
40570 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40571 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40572 }
40573 static void *_p_wxImageTo_p_wxObject(void *x) {
40574 return (void *)((wxObject *) ((wxImage *) x));
40575 }
40576 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40577 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40578 }
40579 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40580 return (void *)((wxObject *) ((wxSystemOptions *) x));
40581 }
40582 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40583 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40584 }
40585 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40586 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40587 }
40588 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40589 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40590 }
40591 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40592 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40593 }
40594 static void *_p_wxWindowTo_p_wxObject(void *x) {
40595 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40596 }
40597 static void *_p_wxMenuTo_p_wxObject(void *x) {
40598 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40599 }
40600 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40601 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40602 }
40603 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40604 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40605 }
40606 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40607 return (void *)((wxObject *) ((wxFileSystem *) x));
40608 }
40609 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40610 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40611 }
40612 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40613 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40614 }
40615 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40616 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40617 }
40618 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40619 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40620 }
40621 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40622 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40623 }
40624 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40625 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40626 }
40627 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40628 return (void *)((wxObject *) ((wxBusyInfo *) x));
40629 }
40630 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40631 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40632 }
40633 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40634 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40635 }
40636 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40637 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40638 }
40639 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40640 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40641 }
40642 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40643 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40644 }
40645 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40646 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40647 }
40648 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40649 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40650 }
40651 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40652 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40653 }
40654 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40655 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40656 }
40657 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40658 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40659 }
40660 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40661 return (void *)((wxLog *) ((wxLogBuffer *) x));
40662 }
40663 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40664 return (void *)((wxLog *) ((wxLogStderr *) x));
40665 }
40666 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40667 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40668 }
40669 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40670 return (void *)((wxLog *) ((wxLogWindow *) x));
40671 }
40672 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40673 return (void *)((wxLog *) ((wxLogChain *) x));
40674 }
40675 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40676 return (void *)((wxLog *) ((wxLogGui *) x));
40677 }
40678 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40679 return (void *)((wxLog *) ((wxPyLog *) x));
40680 }
40681 static void *_p_wxControlTo_p_wxWindow(void *x) {
40682 return (void *)((wxWindow *) ((wxControl *) x));
40683 }
40684 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40685 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40686 }
40687 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40688 return (void *)((wxWindow *) ((wxMenuBar *) x));
40689 }
40690 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40691 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40692 }
40693 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40694 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40695 }
40696 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40697 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};
40698 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40699 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40700 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40701 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40702 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40703 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40704 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40705 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40706 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40707 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40708 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40709 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40710 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40711 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40712 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40713 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40714 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40715 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40716 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40717 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40731 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40732 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40733 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40734 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40735 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40736 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40737 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40738 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40739 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40740 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40741 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40742 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40743 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40754 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40769 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40773 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40774 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40775 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40779 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40802 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40803 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40804 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40805 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40806 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40809 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40810 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40811 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40812 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40813 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40814 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40817 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40818 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40825 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40828 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40832 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40833 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40834 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40835 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40836 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40837 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40838 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40839 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40840 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40841 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40842 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40843 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40850 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40851 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40852 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40853 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40854 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40855 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40856 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40857 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40858 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40859 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40860 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40861 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40862 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40863 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40866 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40867 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40868 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40870
40871 static swig_type_info *swig_type_initial[] = {
40872 &_swigt__p_char,
40873 &_swigt__p_form_ops_t,
40874 &_swigt__p_int,
40875 &_swigt__p_unsigned_char,
40876 &_swigt__p_unsigned_int,
40877 &_swigt__p_unsigned_long,
40878 &_swigt__p_void,
40879 &_swigt__p_wxANIHandler,
40880 &_swigt__p_wxAboutDialogInfo,
40881 &_swigt__p_wxAcceleratorTable,
40882 &_swigt__p_wxActivateEvent,
40883 &_swigt__p_wxArrayString,
40884 &_swigt__p_wxBMPHandler,
40885 &_swigt__p_wxBitmap,
40886 &_swigt__p_wxBitmapDataObject,
40887 &_swigt__p_wxBoxSizer,
40888 &_swigt__p_wxBusyCursor,
40889 &_swigt__p_wxBusyInfo,
40890 &_swigt__p_wxCURHandler,
40891 &_swigt__p_wxCaret,
40892 &_swigt__p_wxChar,
40893 &_swigt__p_wxChildFocusEvent,
40894 &_swigt__p_wxClipboard,
40895 &_swigt__p_wxClipboardLocker,
40896 &_swigt__p_wxClipboardTextEvent,
40897 &_swigt__p_wxCloseEvent,
40898 &_swigt__p_wxColour,
40899 &_swigt__p_wxCommandEvent,
40900 &_swigt__p_wxConfig,
40901 &_swigt__p_wxConfigBase,
40902 &_swigt__p_wxConfigPathChanger,
40903 &_swigt__p_wxContextMenuEvent,
40904 &_swigt__p_wxControl,
40905 &_swigt__p_wxControlWithItems,
40906 &_swigt__p_wxCursor,
40907 &_swigt__p_wxCustomDataObject,
40908 &_swigt__p_wxDC,
40909 &_swigt__p_wxDataFormat,
40910 &_swigt__p_wxDataObject,
40911 &_swigt__p_wxDataObjectComposite,
40912 &_swigt__p_wxDataObjectSimple,
40913 &_swigt__p_wxDateEvent,
40914 &_swigt__p_wxDateSpan,
40915 &_swigt__p_wxDateTime,
40916 &_swigt__p_wxDateTime__TimeZone,
40917 &_swigt__p_wxDisplay,
40918 &_swigt__p_wxDisplayChangedEvent,
40919 &_swigt__p_wxDropFilesEvent,
40920 &_swigt__p_wxDuplexMode,
40921 &_swigt__p_wxEraseEvent,
40922 &_swigt__p_wxEvent,
40923 &_swigt__p_wxEvtHandler,
40924 &_swigt__p_wxFSFile,
40925 &_swigt__p_wxFileConfig,
40926 &_swigt__p_wxFileDataObject,
40927 &_swigt__p_wxFileHistory,
40928 &_swigt__p_wxFileSystem,
40929 &_swigt__p_wxFileType,
40930 &_swigt__p_wxFileTypeInfo,
40931 &_swigt__p_wxFlexGridSizer,
40932 &_swigt__p_wxFocusEvent,
40933 &_swigt__p_wxFont,
40934 &_swigt__p_wxFrame,
40935 &_swigt__p_wxGBSizerItem,
40936 &_swigt__p_wxGIFHandler,
40937 &_swigt__p_wxGridBagSizer,
40938 &_swigt__p_wxGridSizer,
40939 &_swigt__p_wxICOHandler,
40940 &_swigt__p_wxIcon,
40941 &_swigt__p_wxIconizeEvent,
40942 &_swigt__p_wxIdleEvent,
40943 &_swigt__p_wxImage,
40944 &_swigt__p_wxImageHandler,
40945 &_swigt__p_wxIndividualLayoutConstraint,
40946 &_swigt__p_wxInitDialogEvent,
40947 &_swigt__p_wxJPEGHandler,
40948 &_swigt__p_wxJoystick,
40949 &_swigt__p_wxJoystickEvent,
40950 &_swigt__p_wxKeyEvent,
40951 &_swigt__p_wxKillError,
40952 &_swigt__p_wxLayoutConstraints,
40953 &_swigt__p_wxLog,
40954 &_swigt__p_wxLogBuffer,
40955 &_swigt__p_wxLogChain,
40956 &_swigt__p_wxLogGui,
40957 &_swigt__p_wxLogNull,
40958 &_swigt__p_wxLogStderr,
40959 &_swigt__p_wxLogTextCtrl,
40960 &_swigt__p_wxLogWindow,
40961 &_swigt__p_wxMaximizeEvent,
40962 &_swigt__p_wxMenu,
40963 &_swigt__p_wxMenuBar,
40964 &_swigt__p_wxMenuEvent,
40965 &_swigt__p_wxMenuItem,
40966 &_swigt__p_wxMetafile,
40967 &_swigt__p_wxMetafileDataObject,
40968 &_swigt__p_wxMimeTypesManager,
40969 &_swigt__p_wxMouseCaptureChangedEvent,
40970 &_swigt__p_wxMouseCaptureLostEvent,
40971 &_swigt__p_wxMouseEvent,
40972 &_swigt__p_wxMouseState,
40973 &_swigt__p_wxMoveEvent,
40974 &_swigt__p_wxMutexGuiLocker,
40975 &_swigt__p_wxNavigationKeyEvent,
40976 &_swigt__p_wxNcPaintEvent,
40977 &_swigt__p_wxNotifyEvent,
40978 &_swigt__p_wxObject,
40979 &_swigt__p_wxOutputStream,
40980 &_swigt__p_wxPCXHandler,
40981 &_swigt__p_wxPNGHandler,
40982 &_swigt__p_wxPNMHandler,
40983 &_swigt__p_wxPaintEvent,
40984 &_swigt__p_wxPaletteChangedEvent,
40985 &_swigt__p_wxPaperSize,
40986 &_swigt__p_wxPlatformInfo,
40987 &_swigt__p_wxPoint,
40988 &_swigt__p_wxPowerEvent,
40989 &_swigt__p_wxProcessEvent,
40990 &_swigt__p_wxPyApp,
40991 &_swigt__p_wxPyArtProvider,
40992 &_swigt__p_wxPyBitmapDataObject,
40993 &_swigt__p_wxPyCommandEvent,
40994 &_swigt__p_wxPyDataObjectSimple,
40995 &_swigt__p_wxPyDropSource,
40996 &_swigt__p_wxPyDropTarget,
40997 &_swigt__p_wxPyEvent,
40998 &_swigt__p_wxPyFileDropTarget,
40999 &_swigt__p_wxPyImageHandler,
41000 &_swigt__p_wxPyLog,
41001 &_swigt__p_wxPyProcess,
41002 &_swigt__p_wxPySizer,
41003 &_swigt__p_wxPyTextDataObject,
41004 &_swigt__p_wxPyTextDropTarget,
41005 &_swigt__p_wxPyTimer,
41006 &_swigt__p_wxPyTipProvider,
41007 &_swigt__p_wxPyValidator,
41008 &_swigt__p_wxQueryNewPaletteEvent,
41009 &_swigt__p_wxRect,
41010 &_swigt__p_wxScrollEvent,
41011 &_swigt__p_wxScrollWinEvent,
41012 &_swigt__p_wxSetCursorEvent,
41013 &_swigt__p_wxShowEvent,
41014 &_swigt__p_wxSingleInstanceChecker,
41015 &_swigt__p_wxSize,
41016 &_swigt__p_wxSizeEvent,
41017 &_swigt__p_wxSizer,
41018 &_swigt__p_wxSizerItem,
41019 &_swigt__p_wxSound,
41020 &_swigt__p_wxStandardPaths,
41021 &_swigt__p_wxStaticBoxSizer,
41022 &_swigt__p_wxStdDialogButtonSizer,
41023 &_swigt__p_wxStopWatch,
41024 &_swigt__p_wxString,
41025 &_swigt__p_wxSysColourChangedEvent,
41026 &_swigt__p_wxSystemOptions,
41027 &_swigt__p_wxSystemSettings,
41028 &_swigt__p_wxTIFFHandler,
41029 &_swigt__p_wxTextCtrl,
41030 &_swigt__p_wxTextDataObject,
41031 &_swigt__p_wxTimeSpan,
41032 &_swigt__p_wxTimer,
41033 &_swigt__p_wxTimerEvent,
41034 &_swigt__p_wxTimerRunner,
41035 &_swigt__p_wxTipProvider,
41036 &_swigt__p_wxToolTip,
41037 &_swigt__p_wxURLDataObject,
41038 &_swigt__p_wxUpdateUIEvent,
41039 &_swigt__p_wxValidator,
41040 &_swigt__p_wxVideoMode,
41041 &_swigt__p_wxWindow,
41042 &_swigt__p_wxWindowCreateEvent,
41043 &_swigt__p_wxWindowDestroyEvent,
41044 &_swigt__p_wxWindowDisabler,
41045 &_swigt__p_wxXPMHandler,
41046 };
41047
41048 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41052 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41053 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41054 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41055 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41058 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}};
41059 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41061 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41067 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}};
41068 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41073 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}};
41074 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41075 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}};
41076 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41119 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}};
41120 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41126 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}};
41127 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41138 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}};
41139 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41182 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_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_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}};
41183 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41193 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}};
41194 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41211 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}};
41212 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41216 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}};
41217 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41219 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41220 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}};
41221 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41222
41223 static swig_cast_info *swig_cast_initial[] = {
41224 _swigc__p_char,
41225 _swigc__p_form_ops_t,
41226 _swigc__p_int,
41227 _swigc__p_unsigned_char,
41228 _swigc__p_unsigned_int,
41229 _swigc__p_unsigned_long,
41230 _swigc__p_void,
41231 _swigc__p_wxANIHandler,
41232 _swigc__p_wxAboutDialogInfo,
41233 _swigc__p_wxAcceleratorTable,
41234 _swigc__p_wxActivateEvent,
41235 _swigc__p_wxArrayString,
41236 _swigc__p_wxBMPHandler,
41237 _swigc__p_wxBitmap,
41238 _swigc__p_wxBitmapDataObject,
41239 _swigc__p_wxBoxSizer,
41240 _swigc__p_wxBusyCursor,
41241 _swigc__p_wxBusyInfo,
41242 _swigc__p_wxCURHandler,
41243 _swigc__p_wxCaret,
41244 _swigc__p_wxChar,
41245 _swigc__p_wxChildFocusEvent,
41246 _swigc__p_wxClipboard,
41247 _swigc__p_wxClipboardLocker,
41248 _swigc__p_wxClipboardTextEvent,
41249 _swigc__p_wxCloseEvent,
41250 _swigc__p_wxColour,
41251 _swigc__p_wxCommandEvent,
41252 _swigc__p_wxConfig,
41253 _swigc__p_wxConfigBase,
41254 _swigc__p_wxConfigPathChanger,
41255 _swigc__p_wxContextMenuEvent,
41256 _swigc__p_wxControl,
41257 _swigc__p_wxControlWithItems,
41258 _swigc__p_wxCursor,
41259 _swigc__p_wxCustomDataObject,
41260 _swigc__p_wxDC,
41261 _swigc__p_wxDataFormat,
41262 _swigc__p_wxDataObject,
41263 _swigc__p_wxDataObjectComposite,
41264 _swigc__p_wxDataObjectSimple,
41265 _swigc__p_wxDateEvent,
41266 _swigc__p_wxDateSpan,
41267 _swigc__p_wxDateTime,
41268 _swigc__p_wxDateTime__TimeZone,
41269 _swigc__p_wxDisplay,
41270 _swigc__p_wxDisplayChangedEvent,
41271 _swigc__p_wxDropFilesEvent,
41272 _swigc__p_wxDuplexMode,
41273 _swigc__p_wxEraseEvent,
41274 _swigc__p_wxEvent,
41275 _swigc__p_wxEvtHandler,
41276 _swigc__p_wxFSFile,
41277 _swigc__p_wxFileConfig,
41278 _swigc__p_wxFileDataObject,
41279 _swigc__p_wxFileHistory,
41280 _swigc__p_wxFileSystem,
41281 _swigc__p_wxFileType,
41282 _swigc__p_wxFileTypeInfo,
41283 _swigc__p_wxFlexGridSizer,
41284 _swigc__p_wxFocusEvent,
41285 _swigc__p_wxFont,
41286 _swigc__p_wxFrame,
41287 _swigc__p_wxGBSizerItem,
41288 _swigc__p_wxGIFHandler,
41289 _swigc__p_wxGridBagSizer,
41290 _swigc__p_wxGridSizer,
41291 _swigc__p_wxICOHandler,
41292 _swigc__p_wxIcon,
41293 _swigc__p_wxIconizeEvent,
41294 _swigc__p_wxIdleEvent,
41295 _swigc__p_wxImage,
41296 _swigc__p_wxImageHandler,
41297 _swigc__p_wxIndividualLayoutConstraint,
41298 _swigc__p_wxInitDialogEvent,
41299 _swigc__p_wxJPEGHandler,
41300 _swigc__p_wxJoystick,
41301 _swigc__p_wxJoystickEvent,
41302 _swigc__p_wxKeyEvent,
41303 _swigc__p_wxKillError,
41304 _swigc__p_wxLayoutConstraints,
41305 _swigc__p_wxLog,
41306 _swigc__p_wxLogBuffer,
41307 _swigc__p_wxLogChain,
41308 _swigc__p_wxLogGui,
41309 _swigc__p_wxLogNull,
41310 _swigc__p_wxLogStderr,
41311 _swigc__p_wxLogTextCtrl,
41312 _swigc__p_wxLogWindow,
41313 _swigc__p_wxMaximizeEvent,
41314 _swigc__p_wxMenu,
41315 _swigc__p_wxMenuBar,
41316 _swigc__p_wxMenuEvent,
41317 _swigc__p_wxMenuItem,
41318 _swigc__p_wxMetafile,
41319 _swigc__p_wxMetafileDataObject,
41320 _swigc__p_wxMimeTypesManager,
41321 _swigc__p_wxMouseCaptureChangedEvent,
41322 _swigc__p_wxMouseCaptureLostEvent,
41323 _swigc__p_wxMouseEvent,
41324 _swigc__p_wxMouseState,
41325 _swigc__p_wxMoveEvent,
41326 _swigc__p_wxMutexGuiLocker,
41327 _swigc__p_wxNavigationKeyEvent,
41328 _swigc__p_wxNcPaintEvent,
41329 _swigc__p_wxNotifyEvent,
41330 _swigc__p_wxObject,
41331 _swigc__p_wxOutputStream,
41332 _swigc__p_wxPCXHandler,
41333 _swigc__p_wxPNGHandler,
41334 _swigc__p_wxPNMHandler,
41335 _swigc__p_wxPaintEvent,
41336 _swigc__p_wxPaletteChangedEvent,
41337 _swigc__p_wxPaperSize,
41338 _swigc__p_wxPlatformInfo,
41339 _swigc__p_wxPoint,
41340 _swigc__p_wxPowerEvent,
41341 _swigc__p_wxProcessEvent,
41342 _swigc__p_wxPyApp,
41343 _swigc__p_wxPyArtProvider,
41344 _swigc__p_wxPyBitmapDataObject,
41345 _swigc__p_wxPyCommandEvent,
41346 _swigc__p_wxPyDataObjectSimple,
41347 _swigc__p_wxPyDropSource,
41348 _swigc__p_wxPyDropTarget,
41349 _swigc__p_wxPyEvent,
41350 _swigc__p_wxPyFileDropTarget,
41351 _swigc__p_wxPyImageHandler,
41352 _swigc__p_wxPyLog,
41353 _swigc__p_wxPyProcess,
41354 _swigc__p_wxPySizer,
41355 _swigc__p_wxPyTextDataObject,
41356 _swigc__p_wxPyTextDropTarget,
41357 _swigc__p_wxPyTimer,
41358 _swigc__p_wxPyTipProvider,
41359 _swigc__p_wxPyValidator,
41360 _swigc__p_wxQueryNewPaletteEvent,
41361 _swigc__p_wxRect,
41362 _swigc__p_wxScrollEvent,
41363 _swigc__p_wxScrollWinEvent,
41364 _swigc__p_wxSetCursorEvent,
41365 _swigc__p_wxShowEvent,
41366 _swigc__p_wxSingleInstanceChecker,
41367 _swigc__p_wxSize,
41368 _swigc__p_wxSizeEvent,
41369 _swigc__p_wxSizer,
41370 _swigc__p_wxSizerItem,
41371 _swigc__p_wxSound,
41372 _swigc__p_wxStandardPaths,
41373 _swigc__p_wxStaticBoxSizer,
41374 _swigc__p_wxStdDialogButtonSizer,
41375 _swigc__p_wxStopWatch,
41376 _swigc__p_wxString,
41377 _swigc__p_wxSysColourChangedEvent,
41378 _swigc__p_wxSystemOptions,
41379 _swigc__p_wxSystemSettings,
41380 _swigc__p_wxTIFFHandler,
41381 _swigc__p_wxTextCtrl,
41382 _swigc__p_wxTextDataObject,
41383 _swigc__p_wxTimeSpan,
41384 _swigc__p_wxTimer,
41385 _swigc__p_wxTimerEvent,
41386 _swigc__p_wxTimerRunner,
41387 _swigc__p_wxTipProvider,
41388 _swigc__p_wxToolTip,
41389 _swigc__p_wxURLDataObject,
41390 _swigc__p_wxUpdateUIEvent,
41391 _swigc__p_wxValidator,
41392 _swigc__p_wxVideoMode,
41393 _swigc__p_wxWindow,
41394 _swigc__p_wxWindowCreateEvent,
41395 _swigc__p_wxWindowDestroyEvent,
41396 _swigc__p_wxWindowDisabler,
41397 _swigc__p_wxXPMHandler,
41398 };
41399
41400
41401 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41402
41403 static swig_const_info swig_const_table[] = {
41404 {0, 0, 0, 0.0, 0, 0}};
41405
41406 #ifdef __cplusplus
41407 }
41408 #endif
41409 /* -----------------------------------------------------------------------------
41410 * Type initialization:
41411 * This problem is tough by the requirement that no dynamic
41412 * memory is used. Also, since swig_type_info structures store pointers to
41413 * swig_cast_info structures and swig_cast_info structures store pointers back
41414 * to swig_type_info structures, we need some lookup code at initialization.
41415 * The idea is that swig generates all the structures that are needed.
41416 * The runtime then collects these partially filled structures.
41417 * The SWIG_InitializeModule function takes these initial arrays out of
41418 * swig_module, and does all the lookup, filling in the swig_module.types
41419 * array with the correct data and linking the correct swig_cast_info
41420 * structures together.
41421 *
41422 * The generated swig_type_info structures are assigned staticly to an initial
41423 * array. We just loop though that array, and handle each type individually.
41424 * First we lookup if this type has been already loaded, and if so, use the
41425 * loaded structure instead of the generated one. Then we have to fill in the
41426 * cast linked list. The cast data is initially stored in something like a
41427 * two-dimensional array. Each row corresponds to a type (there are the same
41428 * number of rows as there are in the swig_type_initial array). Each entry in
41429 * a column is one of the swig_cast_info structures for that type.
41430 * The cast_initial array is actually an array of arrays, because each row has
41431 * a variable number of columns. So to actually build the cast linked list,
41432 * we find the array of casts associated with the type, and loop through it
41433 * adding the casts to the list. The one last trick we need to do is making
41434 * sure the type pointer in the swig_cast_info struct is correct.
41435 *
41436 * First off, we lookup the cast->type name to see if it is already loaded.
41437 * There are three cases to handle:
41438 * 1) If the cast->type has already been loaded AND the type we are adding
41439 * casting info to has not been loaded (it is in this module), THEN we
41440 * replace the cast->type pointer with the type pointer that has already
41441 * been loaded.
41442 * 2) If BOTH types (the one we are adding casting info to, and the
41443 * cast->type) are loaded, THEN the cast info has already been loaded by
41444 * the previous module so we just ignore it.
41445 * 3) Finally, if cast->type has not already been loaded, then we add that
41446 * swig_cast_info to the linked list (because the cast->type) pointer will
41447 * be correct.
41448 * ----------------------------------------------------------------------------- */
41449
41450 #ifdef __cplusplus
41451 extern "C" {
41452 #if 0
41453 } /* c-mode */
41454 #endif
41455 #endif
41456
41457 #if 0
41458 #define SWIGRUNTIME_DEBUG
41459 #endif
41460
41461 SWIGRUNTIME void
41462 SWIG_InitializeModule(void *clientdata) {
41463 size_t i;
41464 swig_module_info *module_head;
41465 static int init_run = 0;
41466
41467 clientdata = clientdata;
41468
41469 if (init_run) return;
41470 init_run = 1;
41471
41472 /* Initialize the swig_module */
41473 swig_module.type_initial = swig_type_initial;
41474 swig_module.cast_initial = swig_cast_initial;
41475
41476 /* Try and load any already created modules */
41477 module_head = SWIG_GetModule(clientdata);
41478 if (module_head) {
41479 swig_module.next = module_head->next;
41480 module_head->next = &swig_module;
41481 } else {
41482 /* This is the first module loaded */
41483 swig_module.next = &swig_module;
41484 SWIG_SetModule(clientdata, &swig_module);
41485 }
41486
41487 /* Now work on filling in swig_module.types */
41488 #ifdef SWIGRUNTIME_DEBUG
41489 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41490 #endif
41491 for (i = 0; i < swig_module.size; ++i) {
41492 swig_type_info *type = 0;
41493 swig_type_info *ret;
41494 swig_cast_info *cast;
41495
41496 #ifdef SWIGRUNTIME_DEBUG
41497 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41498 #endif
41499
41500 /* if there is another module already loaded */
41501 if (swig_module.next != &swig_module) {
41502 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41503 }
41504 if (type) {
41505 /* Overwrite clientdata field */
41506 #ifdef SWIGRUNTIME_DEBUG
41507 printf("SWIG_InitializeModule: found type %s\n", type->name);
41508 #endif
41509 if (swig_module.type_initial[i]->clientdata) {
41510 type->clientdata = swig_module.type_initial[i]->clientdata;
41511 #ifdef SWIGRUNTIME_DEBUG
41512 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41513 #endif
41514 }
41515 } else {
41516 type = swig_module.type_initial[i];
41517 }
41518
41519 /* Insert casting types */
41520 cast = swig_module.cast_initial[i];
41521 while (cast->type) {
41522 /* Don't need to add information already in the list */
41523 ret = 0;
41524 #ifdef SWIGRUNTIME_DEBUG
41525 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41526 #endif
41527 if (swig_module.next != &swig_module) {
41528 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41529 #ifdef SWIGRUNTIME_DEBUG
41530 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41531 #endif
41532 }
41533 if (ret) {
41534 if (type == swig_module.type_initial[i]) {
41535 #ifdef SWIGRUNTIME_DEBUG
41536 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41537 #endif
41538 cast->type = ret;
41539 ret = 0;
41540 } else {
41541 /* Check for casting already in the list */
41542 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41543 #ifdef SWIGRUNTIME_DEBUG
41544 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41545 #endif
41546 if (!ocast) ret = 0;
41547 }
41548 }
41549
41550 if (!ret) {
41551 #ifdef SWIGRUNTIME_DEBUG
41552 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41553 #endif
41554 if (type->cast) {
41555 type->cast->prev = cast;
41556 cast->next = type->cast;
41557 }
41558 type->cast = cast;
41559 }
41560 cast++;
41561 }
41562 /* Set entry in modules->types array equal to the type */
41563 swig_module.types[i] = type;
41564 }
41565 swig_module.types[i] = 0;
41566
41567 #ifdef SWIGRUNTIME_DEBUG
41568 printf("**** SWIG_InitializeModule: Cast List ******\n");
41569 for (i = 0; i < swig_module.size; ++i) {
41570 int j = 0;
41571 swig_cast_info *cast = swig_module.cast_initial[i];
41572 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41573 while (cast->type) {
41574 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41575 cast++;
41576 ++j;
41577 }
41578 printf("---- Total casts: %d\n",j);
41579 }
41580 printf("**** SWIG_InitializeModule: Cast List ******\n");
41581 #endif
41582 }
41583
41584 /* This function will propagate the clientdata field of type to
41585 * any new swig_type_info structures that have been added into the list
41586 * of equivalent types. It is like calling
41587 * SWIG_TypeClientData(type, clientdata) a second time.
41588 */
41589 SWIGRUNTIME void
41590 SWIG_PropagateClientData(void) {
41591 size_t i;
41592 swig_cast_info *equiv;
41593 static int init_run = 0;
41594
41595 if (init_run) return;
41596 init_run = 1;
41597
41598 for (i = 0; i < swig_module.size; i++) {
41599 if (swig_module.types[i]->clientdata) {
41600 equiv = swig_module.types[i]->cast;
41601 while (equiv) {
41602 if (!equiv->converter) {
41603 if (equiv->type && !equiv->type->clientdata)
41604 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41605 }
41606 equiv = equiv->next;
41607 }
41608 }
41609 }
41610 }
41611
41612 #ifdef __cplusplus
41613 #if 0
41614 {
41615 /* c-mode */
41616 #endif
41617 }
41618 #endif
41619
41620
41621
41622 #ifdef __cplusplus
41623 extern "C" {
41624 #endif
41625
41626 /* Python-specific SWIG API */
41627 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41628 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41629 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41630
41631 /* -----------------------------------------------------------------------------
41632 * global variable support code.
41633 * ----------------------------------------------------------------------------- */
41634
41635 typedef struct swig_globalvar {
41636 char *name; /* Name of global variable */
41637 PyObject *(*get_attr)(void); /* Return the current value */
41638 int (*set_attr)(PyObject *); /* Set the value */
41639 struct swig_globalvar *next;
41640 } swig_globalvar;
41641
41642 typedef struct swig_varlinkobject {
41643 PyObject_HEAD
41644 swig_globalvar *vars;
41645 } swig_varlinkobject;
41646
41647 SWIGINTERN PyObject *
41648 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41649 return PyString_FromString("<Swig global variables>");
41650 }
41651
41652 SWIGINTERN PyObject *
41653 swig_varlink_str(swig_varlinkobject *v) {
41654 PyObject *str = PyString_FromString("(");
41655 swig_globalvar *var;
41656 for (var = v->vars; var; var=var->next) {
41657 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41658 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41659 }
41660 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41661 return str;
41662 }
41663
41664 SWIGINTERN int
41665 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41666 PyObject *str = swig_varlink_str(v);
41667 fprintf(fp,"Swig global variables ");
41668 fprintf(fp,"%s\n", PyString_AsString(str));
41669 Py_DECREF(str);
41670 return 0;
41671 }
41672
41673 SWIGINTERN void
41674 swig_varlink_dealloc(swig_varlinkobject *v) {
41675 swig_globalvar *var = v->vars;
41676 while (var) {
41677 swig_globalvar *n = var->next;
41678 free(var->name);
41679 free(var);
41680 var = n;
41681 }
41682 }
41683
41684 SWIGINTERN PyObject *
41685 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41686 PyObject *res = NULL;
41687 swig_globalvar *var = v->vars;
41688 while (var) {
41689 if (strcmp(var->name,n) == 0) {
41690 res = (*var->get_attr)();
41691 break;
41692 }
41693 var = var->next;
41694 }
41695 if (res == NULL && !PyErr_Occurred()) {
41696 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41697 }
41698 return res;
41699 }
41700
41701 SWIGINTERN int
41702 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41703 int res = 1;
41704 swig_globalvar *var = v->vars;
41705 while (var) {
41706 if (strcmp(var->name,n) == 0) {
41707 res = (*var->set_attr)(p);
41708 break;
41709 }
41710 var = var->next;
41711 }
41712 if (res == 1 && !PyErr_Occurred()) {
41713 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41714 }
41715 return res;
41716 }
41717
41718 SWIGINTERN PyTypeObject*
41719 swig_varlink_type(void) {
41720 static char varlink__doc__[] = "Swig var link object";
41721 static PyTypeObject varlink_type;
41722 static int type_init = 0;
41723 if (!type_init) {
41724 const PyTypeObject tmp
41725 = {
41726 PyObject_HEAD_INIT(NULL)
41727 0, /* Number of items in variable part (ob_size) */
41728 (char *)"swigvarlink", /* Type name (tp_name) */
41729 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41730 0, /* Itemsize (tp_itemsize) */
41731 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41732 (printfunc) swig_varlink_print, /* Print (tp_print) */
41733 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41734 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41735 0, /* tp_compare */
41736 (reprfunc) swig_varlink_repr, /* tp_repr */
41737 0, /* tp_as_number */
41738 0, /* tp_as_sequence */
41739 0, /* tp_as_mapping */
41740 0, /* tp_hash */
41741 0, /* tp_call */
41742 (reprfunc)swig_varlink_str, /* tp_str */
41743 0, /* tp_getattro */
41744 0, /* tp_setattro */
41745 0, /* tp_as_buffer */
41746 0, /* tp_flags */
41747 varlink__doc__, /* tp_doc */
41748 0, /* tp_traverse */
41749 0, /* tp_clear */
41750 0, /* tp_richcompare */
41751 0, /* tp_weaklistoffset */
41752 #if PY_VERSION_HEX >= 0x02020000
41753 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41754 #endif
41755 #if PY_VERSION_HEX >= 0x02030000
41756 0, /* tp_del */
41757 #endif
41758 #ifdef COUNT_ALLOCS
41759 0,0,0,0 /* tp_alloc -> tp_next */
41760 #endif
41761 };
41762 varlink_type = tmp;
41763 varlink_type.ob_type = &PyType_Type;
41764 type_init = 1;
41765 }
41766 return &varlink_type;
41767 }
41768
41769 /* Create a variable linking object for use later */
41770 SWIGINTERN PyObject *
41771 SWIG_Python_newvarlink(void) {
41772 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41773 if (result) {
41774 result->vars = 0;
41775 }
41776 return ((PyObject*) result);
41777 }
41778
41779 SWIGINTERN void
41780 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41781 swig_varlinkobject *v = (swig_varlinkobject *) p;
41782 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41783 if (gv) {
41784 size_t size = strlen(name)+1;
41785 gv->name = (char *)malloc(size);
41786 if (gv->name) {
41787 strncpy(gv->name,name,size);
41788 gv->get_attr = get_attr;
41789 gv->set_attr = set_attr;
41790 gv->next = v->vars;
41791 }
41792 }
41793 v->vars = gv;
41794 }
41795
41796 SWIGINTERN PyObject *
41797 SWIG_globals() {
41798 static PyObject *_SWIG_globals = 0;
41799 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41800 return _SWIG_globals;
41801 }
41802
41803 /* -----------------------------------------------------------------------------
41804 * constants/methods manipulation
41805 * ----------------------------------------------------------------------------- */
41806
41807 /* Install Constants */
41808 SWIGINTERN void
41809 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41810 PyObject *obj = 0;
41811 size_t i;
41812 for (i = 0; constants[i].type; ++i) {
41813 switch(constants[i].type) {
41814 case SWIG_PY_POINTER:
41815 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41816 break;
41817 case SWIG_PY_BINARY:
41818 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41819 break;
41820 default:
41821 obj = 0;
41822 break;
41823 }
41824 if (obj) {
41825 PyDict_SetItemString(d, constants[i].name, obj);
41826 Py_DECREF(obj);
41827 }
41828 }
41829 }
41830
41831 /* -----------------------------------------------------------------------------*/
41832 /* Fix SwigMethods to carry the callback ptrs when needed */
41833 /* -----------------------------------------------------------------------------*/
41834
41835 SWIGINTERN void
41836 SWIG_Python_FixMethods(PyMethodDef *methods,
41837 swig_const_info *const_table,
41838 swig_type_info **types,
41839 swig_type_info **types_initial) {
41840 size_t i;
41841 for (i = 0; methods[i].ml_name; ++i) {
41842 const char *c = methods[i].ml_doc;
41843 if (c && (c = strstr(c, "swig_ptr: "))) {
41844 int j;
41845 swig_const_info *ci = 0;
41846 const char *name = c + 10;
41847 for (j = 0; const_table[j].type; ++j) {
41848 if (strncmp(const_table[j].name, name,
41849 strlen(const_table[j].name)) == 0) {
41850 ci = &(const_table[j]);
41851 break;
41852 }
41853 }
41854 if (ci) {
41855 size_t shift = (ci->ptype) - types;
41856 swig_type_info *ty = types_initial[shift];
41857 size_t ldoc = (c - methods[i].ml_doc);
41858 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41859 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41860 if (ndoc) {
41861 char *buff = ndoc;
41862 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41863 if (ptr) {
41864 strncpy(buff, methods[i].ml_doc, ldoc);
41865 buff += ldoc;
41866 strncpy(buff, "swig_ptr: ", 10);
41867 buff += 10;
41868 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41869 methods[i].ml_doc = ndoc;
41870 }
41871 }
41872 }
41873 }
41874 }
41875 }
41876
41877 #ifdef __cplusplus
41878 }
41879 #endif
41880
41881 /* -----------------------------------------------------------------------------*
41882 * Partial Init method
41883 * -----------------------------------------------------------------------------*/
41884
41885 #ifdef __cplusplus
41886 extern "C"
41887 #endif
41888 SWIGEXPORT void SWIG_init(void) {
41889 PyObject *m, *d;
41890
41891 /* Fix SwigMethods to carry the callback ptrs when needed */
41892 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41893
41894 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41895 d = PyModule_GetDict(m);
41896
41897 SWIG_InitializeModule(0);
41898 SWIG_InstallConstants(d,swig_const_table);
41899
41900
41901 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41902 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41903 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41904 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41905 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41906 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41907 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41908 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41909 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41910 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41911 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41912 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41913 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41914 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41915 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41916 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41917 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41918 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41919 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41920 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41921 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41922 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41923 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41924 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41925 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41926 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41927 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41928 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41929 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41930 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41931 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41932 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41933 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41934 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41935 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41936 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41937 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41938 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41939 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41940 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41941 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41942 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41943 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41944 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41945 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41946 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41947 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41948 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41949 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41950 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41951 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41952 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41953 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41954 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41955 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41956 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41957 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41958 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41959 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41960 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41961 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41962 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41963 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41964 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41965 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41966 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41967 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41968 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41969 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41970 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41971 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41972 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41973 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41974 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41975 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41976 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41977 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41978 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41979 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41980 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41981 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41982 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41983 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41984 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41985 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41986 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41987 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41988 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41989 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41990 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41991 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41992 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41993 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41994 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41995 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41996 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41997 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41998 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41999 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42000 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42001 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42002 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42003 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42004 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42005 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42006 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42007 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42008 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42009 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42010 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42011 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42012 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42013 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42014 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42015 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42016 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42017 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42018 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42019 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42020 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42021 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42022 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42023 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42024 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42025 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42026 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42027 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42028 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42029 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42030 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42031 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42032 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42033 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42034 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42035 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42036 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42037 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42038 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42039 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42040 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42041 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42042 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42043 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42044 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42045 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42046 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42047 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42048 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42049
42050 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42051
42052 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42053 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42054 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42055 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42056 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42057 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42058 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42059 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42060 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42061 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42062 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42063 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42064 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42065 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42066 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42067 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42068 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42069 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42070 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42071 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42072 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42073 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42074 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42075 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42076 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42077 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42078 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42079 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42080 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42081 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42082 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42083 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42084 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42085 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42086 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42087 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42088 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42089 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42090 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42091 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42092 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42093 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42094 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42095 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42096 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42097 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42098 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42099 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42100 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42101 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42102 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42103 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42104 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42105
42106 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42107
42108 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42109 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42110 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42111 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42112 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42113 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42114 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42115 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42116 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42117 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42118 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42119 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42120 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42121 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42122 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42123 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42124 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42125 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42126 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42127 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42128 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42129 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42130 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42131 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42132 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42133 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42134 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42135 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42184
42185 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42186
42187 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42188 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42189 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42190 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42191 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42192 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42193 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42194 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42195 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42196 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42197 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42198 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42199 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42200 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42201 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42202 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42203 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42204 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42205 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42206 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42207 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42208 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42209 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42210 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42211 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42212 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42213 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42214 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42215 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42216 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42217 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42218 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42219 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42220 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42221 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42222 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42223 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42224 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42225 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42226 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42227 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42228 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42229 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42230 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42231 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42232 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42233 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42234 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42235 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42236 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42237 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42238 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42239 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42240 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42241 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42242 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42243 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42244 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42245 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42246 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42247 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42248 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42249 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42250 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42251 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42252 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42253 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42254 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42255 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42256 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42257 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42258 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42259 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42260 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42261 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42262 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42263 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42264 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42265 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42266 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42267 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42268 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42269 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42270 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42271 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42272 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42273 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42274 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42275 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42276 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42277 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42278 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42279 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42280 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42281 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42282 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42283 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42284 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42285 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42286 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42287 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42288 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42289 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42290 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42291 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42292 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42293 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42294 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42295 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42296 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42297 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42298 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42299 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42300 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42301 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42302 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42303 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42304 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42305 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42306 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42307 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42308 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42309 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42310 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42311 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42312 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42313 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42314 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42315 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42316 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42317 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42318 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42319 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42320 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42321 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42322 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42323 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42324 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42325 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42326 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42327 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42328 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42329 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42330 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42331 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42332 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42333 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42334 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42335 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42336 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42337 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42338 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42339 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42340 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42341 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42342 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42343 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42344 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42345 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42346 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42347 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42348 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42349 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42350 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42351 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42352 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42353 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42354 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42355 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42356 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42357 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42358 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42359 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42360 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42361 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42362 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42363 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42364 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42365 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42366 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42367 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42368 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42369 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42370 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42371 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42372 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42373 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42374 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42375 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42376 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42377 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42378 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42379 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42380 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42381 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42382 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42383 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42384 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42385 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42386 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42387 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42388 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42389 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42390
42391 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42392 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42393 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42394 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42395
42396 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42397 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42398 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42399 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42400 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42401 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42402 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42403 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42404 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42405 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42406 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42407 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42408 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42409 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42410 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42411 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42412 }
42413
wxWidgets (Impactor)