]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
use computed justification
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTGAHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTIFFHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTextCtrl swig_types[157]
2624 #define SWIGTYPE_p_wxTextDataObject swig_types[158]
2625 #define SWIGTYPE_p_wxTimeSpan swig_types[159]
2626 #define SWIGTYPE_p_wxTimer swig_types[160]
2627 #define SWIGTYPE_p_wxTimerEvent swig_types[161]
2628 #define SWIGTYPE_p_wxTimerRunner swig_types[162]
2629 #define SWIGTYPE_p_wxTipProvider swig_types[163]
2630 #define SWIGTYPE_p_wxToolTip swig_types[164]
2631 #define SWIGTYPE_p_wxURLDataObject swig_types[165]
2632 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[166]
2633 #define SWIGTYPE_p_wxValidator swig_types[167]
2634 #define SWIGTYPE_p_wxVideoMode swig_types[168]
2635 #define SWIGTYPE_p_wxWindow swig_types[169]
2636 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDisabler swig_types[172]
2639 #define SWIGTYPE_p_wxXPMHandler swig_types[173]
2640 static swig_type_info *swig_types[175];
2641 static swig_module_info swig_module = {swig_types, 174, 0, 0, 0, 0};
2642 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2643 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2644
2645 /* -------- TYPES TABLE (END) -------- */
2646
2647 #if (PY_VERSION_HEX <= 0x02000000)
2648 # if !defined(SWIG_PYTHON_CLASSIC)
2649 # error "This python version requires to use swig with the '-classic' option"
2650 # endif
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodern' option"
2654 #endif
2655 #if (PY_VERSION_HEX <= 0x02020000)
2656 # error "This python version requires to use swig with the '-nomodernargs' option"
2657 #endif
2658 #ifndef METH_O
2659 # error "This python version requires to use swig with the '-nofastunpack' option"
2660 #endif
2661
2662 /*-----------------------------------------------
2663 @(target):= _misc_.so
2664 ------------------------------------------------*/
2665 #define SWIG_init init_misc_
2666
2667 #define SWIG_name "_misc_"
2668
2669 #define SWIGVERSION 0x010329
2670
2671
2672 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2673 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2674
2675
2676 #include <stdexcept>
2677
2678
2679 namespace swig {
2680 class PyObject_ptr {
2681 protected:
2682 PyObject *_obj;
2683
2684 public:
2685 PyObject_ptr() :_obj(0)
2686 {
2687 }
2688
2689 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2690 {
2691 Py_XINCREF(_obj);
2692 }
2693
2694 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2695 {
2696 if (initial_ref) Py_XINCREF(_obj);
2697 }
2698
2699 PyObject_ptr & operator=(const PyObject_ptr& item)
2700 {
2701 Py_XINCREF(item._obj);
2702 Py_XDECREF(_obj);
2703 _obj = item._obj;
2704 return *this;
2705 }
2706
2707 ~PyObject_ptr()
2708 {
2709 Py_XDECREF(_obj);
2710 }
2711
2712 operator PyObject *() const
2713 {
2714 return _obj;
2715 }
2716
2717 PyObject *operator->() const
2718 {
2719 return _obj;
2720 }
2721 };
2722 }
2723
2724
2725 namespace swig {
2726 struct PyObject_var : PyObject_ptr {
2727 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2728
2729 PyObject_var & operator = (PyObject* obj)
2730 {
2731 Py_XDECREF(_obj);
2732 _obj = obj;
2733 return *this;
2734 }
2735 };
2736 }
2737
2738
2739 #include "wx/wxPython/wxPython.h"
2740 #include "wx/wxPython/pyclasses.h"
2741 #include "wx/wxPython/pyistream.h"
2742
2743 static const wxString wxPyEmptyString(wxEmptyString);
2744
2745
2746
2747 #define SWIG_From_long PyInt_FromLong
2748
2749
2750 SWIGINTERNINLINE PyObject *
2751 SWIG_From_int (int value)
2752 {
2753 return SWIG_From_long (value);
2754 }
2755
2756
2757 #include <limits.h>
2758 #ifndef LLONG_MIN
2759 # define LLONG_MIN LONG_LONG_MIN
2760 #endif
2761 #ifndef LLONG_MAX
2762 # define LLONG_MAX LONG_LONG_MAX
2763 #endif
2764 #ifndef ULLONG_MAX
2765 # define ULLONG_MAX ULONG_LONG_MAX
2766 #endif
2767
2768
2769 SWIGINTERN int
2770 SWIG_AsVal_long (PyObject* obj, long* val)
2771 {
2772 if (PyNumber_Check(obj)) {
2773 if (val) *val = PyInt_AsLong(obj);
2774 return SWIG_OK;
2775 }
2776 return SWIG_TypeError;
2777 }
2778
2779
2780 SWIGINTERN int
2781 SWIG_AsVal_int (PyObject * obj, int *val)
2782 {
2783 long v;
2784 int res = SWIG_AsVal_long (obj, &v);
2785 if (SWIG_IsOK(res)) {
2786 if ((v < INT_MIN || v > INT_MAX)) {
2787 return SWIG_OverflowError;
2788 } else {
2789 if (val) *val = static_cast< int >(v);
2790 }
2791 }
2792 return res;
2793 }
2794
2795 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2796
2797 #include <wx/stockitem.h>
2798
2799 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2800 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2801 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2802
2803 SWIGINTERN int
2804 SWIG_AsVal_bool (PyObject *obj, bool *val)
2805 {
2806 if (obj == Py_True) {
2807 if (val) *val = true;
2808 return SWIG_OK;
2809 } else if (obj == Py_False) {
2810 if (val) *val = false;
2811 return SWIG_OK;
2812 } else {
2813 long v = 0;
2814 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2815 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2816 return res;
2817 }
2818 }
2819
2820
2821 wxMemorySize wxGetFreeMemory()
2822 { wxPyRaiseNotImplemented(); return 0; }
2823
2824
2825 SWIGINTERN int
2826 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2827 {
2828 long v = 0;
2829 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2830 return SWIG_TypeError;
2831 }
2832 else if (val)
2833 *val = (unsigned long)v;
2834 return SWIG_OK;
2835 }
2836
2837
2838 SWIGINTERNINLINE PyObject*
2839 SWIG_From_unsigned_SS_long (unsigned long value)
2840 {
2841 return (value > LONG_MAX) ?
2842 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2843 }
2844
2845
2846 void* wxGetXDisplay()
2847 {
2848 #ifdef __WXGTK__
2849 return wxGetDisplay();
2850 #else
2851 return NULL;
2852 #endif
2853 }
2854
2855
2856 wxWindow* FindWindowAtPointer() {
2857 wxPoint unused;
2858 return wxFindWindowAtPointer(unused);
2859 }
2860
2861
2862 void wxWakeUpMainThread() {}
2863
2864
2865 bool wxThread_IsMain() {
2866 #ifdef WXP_WITH_THREAD
2867 return wxThread::IsMain();
2868 #else
2869 return true;
2870 #endif
2871 }
2872
2873 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2874 delete self;
2875 }
2876
2877 #include <wx/snglinst.h>
2878
2879
2880 #ifdef __WXMSW__
2881 #include <wx/msw/private.h>
2882 #include <wx/dynload.h>
2883 #endif
2884
2885
2886
2887 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2888 #if 0
2889 , int method
2890 #endif
2891 )
2892 {
2893 #ifdef __WXMSW__
2894 #if 0
2895 switch (method)
2896 {
2897 case 1:
2898 // This one only partially works. Appears to be an undocumented
2899 // "standard" convention that not all widgets adhear to. For
2900 // example, for some widgets backgrounds or non-client areas may
2901 // not be painted.
2902 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2903 break;
2904
2905 case 2:
2906 #endif
2907 // This one works much better, nearly all widgets and their
2908 // children are captured correctly[**]. Prior to the big
2909 // background erase changes that Vadim did in 2004-2005 this
2910 // method failed badly on XP with Themes activated, most native
2911 // widgets draw only partially, if at all. Without themes it
2912 // worked just like on Win2k. After those changes this method
2913 // works very well.
2914 //
2915 // ** For example the radio buttons in a wxRadioBox are not its
2916 // children by default, but you can capture it via the panel
2917 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2918 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2919 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2920 PRF_ERASEBKGND | PRF_OWNED );
2921 return true;
2922 #if 0
2923 break;
2924
2925 case 3:
2926 // This one is only defined in the latest SDK and is only
2927 // available on XP. MSDN says it is similar to sending WM_PRINT
2928 // so I expect that it will work similar to the above. Since it
2929 // is avaialble only on XP, it can't be compiled like this and
2930 // will have to be loaded dynamically.
2931 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2932
2933 // fall through
2934
2935 case 4:
2936 // Use PrintWindow if available, or fallback to WM_PRINT
2937 // otherwise. Unfortunately using PrintWindow is even worse than
2938 // WM_PRINT. For most native widgets nothing is drawn to the dc
2939 // at all, with or without Themes.
2940 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2941 static bool s_triedToLoad = false;
2942 static PrintWindow_t pfnPrintWindow = NULL;
2943 if ( !s_triedToLoad )
2944 {
2945
2946 s_triedToLoad = true;
2947 wxDynamicLibrary dllUser32(_T("user32.dll"));
2948 if ( dllUser32.IsLoaded() )
2949 {
2950 wxLogNull nolog; // Don't report errors here
2951 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2952 }
2953 }
2954 if (pfnPrintWindow)
2955 {
2956 //printf("Using PrintWindow\n");
2957 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2958 }
2959 else
2960 {
2961 //printf("Using WM_PRINT\n");
2962 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2963 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2964 PRF_ERASEBKGND | PRF_OWNED );
2965 }
2966 }
2967 #endif // 0
2968 #else
2969 return false;
2970 #endif // __WXMSW__
2971 }
2972
2973
2974
2975 #include <wx/tipdlg.h>
2976
2977
2978 SWIGINTERNINLINE PyObject *
2979 SWIG_From_size_t (size_t value)
2980 {
2981 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2982 }
2983
2984
2985 class wxPyTipProvider : public wxTipProvider {
2986 public:
2987 wxPyTipProvider(size_t currentTip)
2988 : wxTipProvider(currentTip) {}
2989
2990 DEC_PYCALLBACK_STRING__pure(GetTip);
2991 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2992 PYPRIVATE;
2993 };
2994
2995 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2996 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2997
2998
2999 SWIGINTERNINLINE int
3000 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3001 {
3002 unsigned long v;
3003 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3004 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3005 return res;
3006 }
3007
3008
3009 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3010
3011 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3012
3013 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3014 : wxTimer(owner, id)
3015 {
3016 if (owner == NULL)
3017 SetOwner(this);
3018 }
3019
3020 wxPyTimer::~wxPyTimer()
3021 {
3022 // printf("-=* ~wxPyTimer\n");
3023 }
3024
3025
3026
3027 SWIGINTERN swig_type_info*
3028 SWIG_pchar_descriptor()
3029 {
3030 static int init = 0;
3031 static swig_type_info* info = 0;
3032 if (!init) {
3033 info = SWIG_TypeQuery("_p_char");
3034 init = 1;
3035 }
3036 return info;
3037 }
3038
3039
3040 SWIGINTERNINLINE PyObject *
3041 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3042 {
3043 if (carray) {
3044 if (size > INT_MAX) {
3045 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3046 return pchar_descriptor ?
3047 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3048 } else {
3049 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3050 }
3051 } else {
3052 return SWIG_Py_Void();
3053 }
3054 }
3055
3056
3057 SWIGINTERNINLINE PyObject *
3058 SWIG_FromCharPtr(const char *cptr)
3059 {
3060 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3061 }
3062
3063
3064 SWIGINTERN int
3065 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3066 {
3067 unsigned long v;
3068 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3069 if (SWIG_IsOK(res)) {
3070 if ((v > UINT_MAX)) {
3071 return SWIG_OverflowError;
3072 } else {
3073 if (val) *val = static_cast< unsigned int >(v);
3074 }
3075 }
3076 return res;
3077 }
3078
3079 SWIGINTERN wxString wxLog_TimeStamp(){
3080 wxString msg;
3081 wxLog::TimeStamp(&msg);
3082 return msg;
3083 }
3084 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3085 // Make some wrappers that double any % signs so they are 'escaped'
3086 void wxPyLogFatalError(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogFatalError(m);
3091 }
3092
3093 void wxPyLogError(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogError(m);
3098 }
3099
3100 void wxPyLogWarning(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogWarning(m);
3105 }
3106
3107 void wxPyLogMessage(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogMessage(m);
3112 }
3113
3114 void wxPyLogInfo(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogInfo(m);
3119 }
3120
3121 void wxPyLogDebug(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogDebug(m);
3126 }
3127
3128 void wxPyLogVerbose(const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogVerbose(m);
3133 }
3134
3135 void wxPyLogStatus(const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogStatus(m);
3140 }
3141
3142 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogStatus(pFrame, m);
3147 }
3148
3149 void wxPyLogSysError(const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogSysError(m);
3154 }
3155
3156 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogGeneric(level, m);
3161 }
3162
3163 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3164 {
3165 wxString m(msg);
3166 m.Replace(wxT("%"), wxT("%%"));
3167 wxLogTrace(mask, m);
3168 }
3169
3170 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3171 {
3172 wxString m(msg);
3173 m.Replace(wxT("%"), wxT("%%"));
3174 wxLogTrace(mask, m);
3175 }
3176
3177
3178
3179 // A wxLog class that can be derived from in wxPython
3180 class wxPyLog : public wxLog {
3181 public:
3182 wxPyLog() : wxLog() {}
3183
3184 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3185 bool found;
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3188 PyObject* s = wx2PyString(szString);
3189 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3190 Py_DECREF(s);
3191 }
3192 wxPyEndBlockThreads(blocked);
3193 if (! found)
3194 wxLog::DoLog(level, szString, t);
3195 }
3196
3197 virtual void DoLogString(const wxChar *szString, time_t t) {
3198 bool found;
3199 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3200 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3201 PyObject* s = wx2PyString(szString);
3202 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3203 Py_DECREF(s);
3204 }
3205 wxPyEndBlockThreads(blocked);
3206 if (! found)
3207 wxLog::DoLogString(szString, t);
3208 }
3209
3210 DEC_PYCALLBACK_VOID_(Flush);
3211 PYPRIVATE;
3212 };
3213 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3214
3215
3216
3217
3218 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3219
3220
3221 #include <wx/joystick.h>
3222
3223
3224 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3225 // A C++ stub class for wxJoystick for platforms that don't have it.
3226 class wxJoystick : public wxObject {
3227 public:
3228 wxJoystick(int joystick = wxJOYSTICK1) {
3229 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3230 PyErr_SetString(PyExc_NotImplementedError,
3231 "wxJoystick is not available on this platform.");
3232 wxPyEndBlockThreads(blocked);
3233 }
3234 wxPoint GetPosition() { return wxPoint(-1,-1); }
3235 int GetZPosition() { return -1; }
3236 int GetButtonState() { return -1; }
3237 int GetPOVPosition() { return -1; }
3238 int GetPOVCTSPosition() { return -1; }
3239 int GetRudderPosition() { return -1; }
3240 int GetUPosition() { return -1; }
3241 int GetVPosition() { return -1; }
3242 int GetMovementThreshold() { return -1; }
3243 void SetMovementThreshold(int threshold) {}
3244
3245 bool IsOk(void) { return false; }
3246 int GetNumberJoysticks() { return -1; }
3247 int GetManufacturerId() { return -1; }
3248 int GetProductId() { return -1; }
3249 wxString GetProductName() { return wxEmptyString; }
3250 int GetXMin() { return -1; }
3251 int GetYMin() { return -1; }
3252 int GetZMin() { return -1; }
3253 int GetXMax() { return -1; }
3254 int GetYMax() { return -1; }
3255 int GetZMax() { return -1; }
3256 int GetNumberButtons() { return -1; }
3257 int GetNumberAxes() { return -1; }
3258 int GetMaxButtons() { return -1; }
3259 int GetMaxAxes() { return -1; }
3260 int GetPollingMin() { return -1; }
3261 int GetPollingMax() { return -1; }
3262 int GetRudderMin() { return -1; }
3263 int GetRudderMax() { return -1; }
3264 int GetUMin() { return -1; }
3265 int GetUMax() { return -1; }
3266 int GetVMin() { return -1; }
3267 int GetVMax() { return -1; }
3268
3269 bool HasRudder() { return false; }
3270 bool HasZ() { return false; }
3271 bool HasU() { return false; }
3272 bool HasV() { return false; }
3273 bool HasPOV() { return false; }
3274 bool HasPOV4Dir() { return false; }
3275 bool HasPOVCTS() { return false; }
3276
3277 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3278 bool ReleaseCapture() { return false; }
3279 };
3280 #endif
3281
3282
3283 #include <wx/sound.h>
3284
3285
3286 #if !wxUSE_SOUND
3287 // A C++ stub class for wxWave for platforms that don't have it.
3288 class wxSound : public wxObject
3289 {
3290 public:
3291 wxSound() {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297 wxSound(const wxString&/*, bool*/) {
3298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3299 PyErr_SetString(PyExc_NotImplementedError,
3300 "wxSound is not available on this platform.");
3301 wxPyEndBlockThreads(blocked);
3302 }
3303 wxSound(int, const wxByte*) {
3304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3305 PyErr_SetString(PyExc_NotImplementedError,
3306 "wxSound is not available on this platform.");
3307 wxPyEndBlockThreads(blocked);
3308 }
3309
3310 ~wxSound() {};
3311
3312 bool Create(const wxString&/*, bool*/) { return false; }
3313 bool Create(int, const wxByte*) { return false; };
3314 bool IsOk() { return false; };
3315 bool Play(unsigned) const { return false; }
3316 static bool Play(const wxString&, unsigned) { return false; }
3317 static void Stop() {}
3318 };
3319
3320 #endif
3321
3322 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3323 if (fileName.Length() == 0)
3324 return new wxSound;
3325 else
3326 return new wxSound(fileName);
3327 }
3328 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3329 unsigned char* buffer; int size;
3330 wxSound *sound = NULL;
3331
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (!PyArg_Parse(data, "t#", &buffer, &size))
3334 goto done;
3335 sound = new wxSound(size, buffer);
3336 done:
3337 wxPyEndBlockThreads(blocked);
3338 return sound;
3339 }
3340 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3341 #ifndef __WXMAC__
3342 unsigned char* buffer;
3343 int size;
3344 bool rv = false;
3345
3346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3347 if (!PyArg_Parse(data, "t#", &buffer, &size))
3348 goto done;
3349 rv = self->Create(size, buffer);
3350 done:
3351 wxPyEndBlockThreads(blocked);
3352 return rv;
3353 #else
3354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3355 PyErr_SetString(PyExc_NotImplementedError,
3356 "Create from data is not available on this platform.");
3357 wxPyEndBlockThreads(blocked);
3358 return false;
3359 #endif
3360 }
3361
3362 #include <wx/mimetype.h>
3363
3364 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3365 wxString str;
3366 if (self->GetMimeType(&str))
3367 return wx2PyString(str);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3372 wxArrayString arr;
3373 if (self->GetMimeTypes(arr))
3374 return wxArrayString2PyList_helper(arr);
3375 else
3376 RETURN_NONE();
3377 }
3378 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3379 wxArrayString arr;
3380 if (self->GetExtensions(arr))
3381 return wxArrayString2PyList_helper(arr);
3382 else
3383 RETURN_NONE();
3384 }
3385 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3386 wxIconLocation loc;
3387 if (self->GetIcon(&loc))
3388 return new wxIcon(loc);
3389 else
3390 return NULL;
3391 }
3392 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3393 wxIconLocation loc;
3394 if (self->GetIcon(&loc)) {
3395 wxString iconFile = loc.GetFileName();
3396 int iconIndex = -1;
3397
3398
3399
3400 // Make a tuple and put the values in it
3401 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3402 PyObject* tuple = PyTuple_New(3);
3403 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3404 wxT("wxIcon"), true));
3405 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3406 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3407 wxPyEndBlockThreads(blocked);
3408 return tuple;
3409 }
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3414 wxString str;
3415 if (self->GetDescription(&str))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxString str;
3422 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3423 return wx2PyString(str);
3424 else
3425 RETURN_NONE();
3426 }
3427 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3428 wxString str;
3429 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3430 return wx2PyString(str);
3431 else
3432 RETURN_NONE();
3433 }
3434 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3435 wxArrayString verbs;
3436 wxArrayString commands;
3437 if (self->GetAllCommands(&verbs, &commands,
3438 wxFileType::MessageParameters(filename, mimetype))) {
3439 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3440 PyObject* tuple = PyTuple_New(2);
3441 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3442 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3443 wxPyEndBlockThreads(blocked);
3444 return tuple;
3445 }
3446 else
3447 RETURN_NONE();
3448 }
3449 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3450 return wxFileType::ExpandCommand(command,
3451 wxFileType::MessageParameters(filename, mimetype));
3452 }
3453 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3454 wxArrayString arr;
3455 self->EnumAllFileTypes(arr);
3456 return wxArrayString2PyList_helper(arr);
3457 }
3458
3459 #include <wx/artprov.h>
3460
3461 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3462 static const wxString wxPyART_MENU(wxART_MENU);
3463 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3464 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3465 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3466 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3467 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3468 static const wxString wxPyART_OTHER(wxART_OTHER);
3469 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3470 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3471 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3472 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3473 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3474 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3475 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3476 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3477 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3478 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3479 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3480 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3481 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3482 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3483 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3484 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3485 static const wxString wxPyART_PRINT(wxART_PRINT);
3486 static const wxString wxPyART_HELP(wxART_HELP);
3487 static const wxString wxPyART_TIP(wxART_TIP);
3488 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3489 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3490 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3491 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3492 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3493 static const wxString wxPyART_CDROM(wxART_CDROM);
3494 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3495 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3496 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3497 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3498 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3499 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3500 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3501 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3502 static const wxString wxPyART_ERROR(wxART_ERROR);
3503 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3504 static const wxString wxPyART_WARNING(wxART_WARNING);
3505 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3506 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3507 static const wxString wxPyART_COPY(wxART_COPY);
3508 static const wxString wxPyART_CUT(wxART_CUT);
3509 static const wxString wxPyART_PASTE(wxART_PASTE);
3510 static const wxString wxPyART_DELETE(wxART_DELETE);
3511 static const wxString wxPyART_NEW(wxART_NEW);
3512 static const wxString wxPyART_UNDO(wxART_UNDO);
3513 static const wxString wxPyART_REDO(wxART_REDO);
3514 static const wxString wxPyART_QUIT(wxART_QUIT);
3515 static const wxString wxPyART_FIND(wxART_FIND);
3516 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3517 // Python aware wxArtProvider
3518 class wxPyArtProvider : public wxArtProvider {
3519 public:
3520
3521 virtual wxBitmap CreateBitmap(const wxArtID& id,
3522 const wxArtClient& client,
3523 const wxSize& size) {
3524 wxBitmap rval = wxNullBitmap;
3525 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3526 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3527 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3528 PyObject* ro;
3529 wxBitmap* ptr;
3530 PyObject* s1, *s2;
3531 s1 = wx2PyString(id);
3532 s2 = wx2PyString(client);
3533 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3534 Py_DECREF(so);
3535 Py_DECREF(s1);
3536 Py_DECREF(s2);
3537 if (ro) {
3538 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3539 rval = *ptr;
3540 Py_DECREF(ro);
3541 }
3542 }
3543 wxPyEndBlockThreads(blocked);
3544 return rval;
3545 }
3546
3547 PYPRIVATE;
3548 };
3549
3550 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3551
3552
3553
3554 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3555 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3556 PyObject* ret = PyTuple_New(3);
3557 if (ret) {
3558 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3559 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3560 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3561 }
3562 wxPyEndBlockThreads(blocked);
3563 return ret;
3564 }
3565
3566 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3567 bool cont;
3568 long index = 0;
3569 wxString value;
3570
3571 cont = self->GetFirstGroup(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3575 bool cont;
3576 wxString value;
3577
3578 cont = self->GetNextGroup(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3582 bool cont;
3583 long index = 0;
3584 wxString value;
3585
3586 cont = self->GetFirstEntry(value, index);
3587 return __EnumerationHelper(cont, value, index);
3588 }
3589 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3590 bool cont;
3591 wxString value;
3592
3593 cont = self->GetNextEntry(value, index);
3594 return __EnumerationHelper(cont, value, index);
3595 }
3596 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3597 long rv;
3598 self->Read(key, &rv, defaultVal);
3599 return rv;
3600 }
3601
3602 SWIGINTERN int
3603 SWIG_AsVal_double (PyObject *obj, double* val)
3604 {
3605 if (PyNumber_Check(obj)) {
3606 if (val) *val = PyFloat_AsDouble(obj);
3607 return SWIG_OK;
3608 }
3609 return SWIG_TypeError;
3610 }
3611
3612 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3613 double rv;
3614 self->Read(key, &rv, defaultVal);
3615 return rv;
3616 }
3617
3618 #define SWIG_From_double PyFloat_FromDouble
3619
3620 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3621 bool rv;
3622 self->Read(key, &rv, defaultVal);
3623 return rv;
3624 }
3625
3626 #include <wx/datetime.h>
3627
3628 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3629 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3630
3631 #define LOCAL_TZ wxDateTime::Local
3632
3633 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3634 wxString am;
3635 wxString pm;
3636 wxDateTime::GetAmPmStrings(&am, &pm);
3637 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3638 PyObject* tup = PyTuple_New(2);
3639 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3640 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3641 wxPyEndBlockThreads(blocked);
3642 return tup;
3643 }
3644
3645 SWIGINTERNINLINE PyObject *
3646 SWIG_From_unsigned_SS_int (unsigned int value)
3647 {
3648 return SWIG_From_unsigned_SS_long (value);
3649 }
3650
3651 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3652 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3653 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3654 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3655 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3656 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3658 return (*self < *other);
3659 }
3660 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3662 return (*self <= *other);
3663 }
3664 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3665 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3666 return (*self > *other);
3667 }
3668 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3669 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3670 return (*self >= *other);
3671 }
3672 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3673 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3674 return (*self == *other);
3675 }
3676 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3677 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3678 return (*self != *other);
3679 }
3680 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3681 const wxChar* rv;
3682 const wxChar* _date = date;
3683 rv = self->ParseRfc822Date(_date);
3684 if (rv == NULL) return -1;
3685 return rv - _date;
3686 }
3687 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3688 const wxChar* rv;
3689 const wxChar* _date = date;
3690 rv = self->ParseFormat(_date, format, dateDef);
3691 if (rv == NULL) return -1;
3692 return rv - _date;
3693 }
3694 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3695 const wxChar* rv;
3696 const wxChar* _datetime = datetime;
3697 rv = self->ParseDateTime(_datetime);
3698 if (rv == NULL) return -1;
3699 return rv - _datetime;
3700 }
3701 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3702 const wxChar* rv;
3703 const wxChar* _date = date;
3704 rv = self->ParseDate(_date);
3705 if (rv == NULL) return -1;
3706 return rv - _date;
3707 }
3708 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3709 const wxChar* rv;
3710 const wxChar* _time = time;
3711 rv = self->ParseTime(_time);
3712 if (rv == NULL) return -1;
3713 return rv - _time;
3714 }
3715 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3716 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3717 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3718 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3719 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3720 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3721 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3722 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3723 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3724 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3725 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3726 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3727 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3728 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3729 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3730 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3731
3732 #include <wx/dataobj.h>
3733
3734 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3735 size_t count = self->GetFormatCount(dir);
3736 wxDataFormat* formats = new wxDataFormat[count];
3737 self->GetAllFormats(formats, dir);
3738
3739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3740 PyObject* list = PyList_New(count);
3741 for (size_t i=0; i<count; i++) {
3742 wxDataFormat* format = new wxDataFormat(formats[i]);
3743 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3744 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3745 }
3746 wxPyEndBlockThreads(blocked);
3747 delete [] formats;
3748 return list;
3749 }
3750 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3751 PyObject* rval = NULL;
3752 size_t size = self->GetDataSize(format);
3753 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3754 if (size) {
3755 char* buf = new char[size];
3756 if (self->GetDataHere(format, buf))
3757 rval = PyString_FromStringAndSize(buf, size);
3758 delete [] buf;
3759 }
3760 if (! rval) {
3761 rval = Py_None;
3762 Py_INCREF(rval);
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return rval;
3766 }
3767 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3768 bool rval;
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 if (PyString_Check(data)) {
3771 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3772 }
3773 else {
3774 // raise a TypeError if not a string
3775 PyErr_SetString(PyExc_TypeError, "String expected.");
3776 rval = false;
3777 }
3778 wxPyEndBlockThreads(blocked);
3779 return rval;
3780 }
3781 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3782 PyObject* rval = NULL;
3783 size_t size = self->GetDataSize();
3784 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3785 if (size) {
3786 char* buf = new char[size];
3787 if (self->GetDataHere(buf))
3788 rval = PyString_FromStringAndSize(buf, size);
3789 delete [] buf;
3790 }
3791 if (! rval) {
3792 rval = Py_None;
3793 Py_INCREF(rval);
3794 }
3795 wxPyEndBlockThreads(blocked);
3796 return rval;
3797 }
3798 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3799 bool rval;
3800 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3801 if (PyString_Check(data)) {
3802 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3803 }
3804 else {
3805 // raise a TypeError if not a string
3806 PyErr_SetString(PyExc_TypeError, "String expected.");
3807 rval = false;
3808 }
3809 wxPyEndBlockThreads(blocked);
3810 return rval;
3811 }
3812 // Create a new class for wxPython to use
3813 class wxPyDataObjectSimple : public wxDataObjectSimple {
3814 public:
3815 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3816 : wxDataObjectSimple(format) {}
3817
3818 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3819 bool GetDataHere(void *buf) const;
3820 bool SetData(size_t len, const void *buf);
3821 PYPRIVATE;
3822 };
3823
3824 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3825
3826 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3827 // We need to get the data for this object and write it to buf. I think
3828 // the best way to do this for wxPython is to have the Python method
3829 // return either a string or None and then act appropriately with the
3830 // C++ version.
3831
3832 bool rval = false;
3833 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3834 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3835 PyObject* ro;
3836 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3837 if (ro) {
3838 rval = (ro != Py_None && PyString_Check(ro));
3839 if (rval)
3840 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3841 Py_DECREF(ro);
3842 }
3843 }
3844 wxPyEndBlockThreads(blocked);
3845 return rval;
3846 }
3847
3848 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3849 // For this one we simply need to make a string from buf and len
3850 // and send it to the Python method.
3851 bool rval = false;
3852 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3853 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3854 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3855 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3856 Py_DECREF(data);
3857 }
3858 wxPyEndBlockThreads(blocked);
3859 return rval;
3860 }
3861
3862 // Create a new class for wxPython to use
3863 class wxPyTextDataObject : public wxTextDataObject {
3864 public:
3865 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3866 : wxTextDataObject(text) {}
3867
3868 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3869 DEC_PYCALLBACK_STRING__const(GetText);
3870 DEC_PYCALLBACK__STRING(SetText);
3871 PYPRIVATE;
3872 };
3873
3874 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3875 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3876 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3877
3878
3879 // Create a new class for wxPython to use
3880 class wxPyBitmapDataObject : public wxBitmapDataObject {
3881 public:
3882 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3883 : wxBitmapDataObject(bitmap) {}
3884
3885 wxBitmap GetBitmap() const;
3886 void SetBitmap(const wxBitmap& bitmap);
3887 PYPRIVATE;
3888 };
3889
3890 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3891 wxBitmap* rval = &wxNullBitmap;
3892 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3893 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3894 PyObject* ro;
3895 wxBitmap* ptr;
3896 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3897 if (ro) {
3898 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3899 rval = ptr;
3900 Py_DECREF(ro);
3901 }
3902 }
3903 wxPyEndBlockThreads(blocked);
3904 return *rval;
3905 }
3906
3907 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3909 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3910 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3911 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3912 Py_DECREF(bo);
3913 }
3914 wxPyEndBlockThreads(blocked);
3915 }
3916
3917 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3918 return new wxCustomDataObject(wxDataFormat(formatName));
3919 }
3920 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3921 bool rval;
3922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3923 if (PyString_Check(data)) {
3924 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3925 }
3926 else {
3927 // raise a TypeError if not a string
3928 PyErr_SetString(PyExc_TypeError, "String expected.");
3929 rval = false;
3930 }
3931 wxPyEndBlockThreads(blocked);
3932 return rval;
3933 }
3934 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3935 PyObject* obj;
3936 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3937 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3938 wxPyEndBlockThreads(blocked);
3939 return obj;
3940 }
3941
3942 class wxMetafileDataObject : public wxDataObjectSimple
3943 {
3944 public:
3945 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3946 };
3947
3948
3949 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3950
3951
3952 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3953 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3954 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3955 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3956 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3957
3958
3959 class wxPyTextDropTarget : public wxTextDropTarget {
3960 public:
3961 wxPyTextDropTarget() {}
3962
3963 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3964
3965 DEC_PYCALLBACK__(OnLeave);
3966 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3967 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3968 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3969 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3970
3971 PYPRIVATE;
3972 };
3973
3974 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3975 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3976 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3977 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3978 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3979 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3980
3981
3982
3983 class wxPyFileDropTarget : public wxFileDropTarget {
3984 public:
3985 wxPyFileDropTarget() {}
3986
3987 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3988
3989 DEC_PYCALLBACK__(OnLeave);
3990 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3991 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3992 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3993 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3994
3995 PYPRIVATE;
3996 };
3997
3998 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3999 const wxArrayString& filenames) {
4000 bool rval = false;
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
4003 PyObject* list = wxArrayString2PyList_helper(filenames);
4004 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
4005 Py_DECREF(list);
4006 }
4007 wxPyEndBlockThreads(blocked);
4008 return rval;
4009 }
4010
4011
4012
4013 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4014 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4015 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4016 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4017 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4018
4019
4020
4021
4022 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4023
4024 #include <wx/display.h>
4025 #include <wx/vidmode.h>
4026
4027 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4028 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4029
4030 #if !wxUSE_DISPLAY
4031 const wxVideoMode wxDefaultVideoMode;
4032 #endif
4033
4034 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4035 #if wxUSE_DISPLAY
4036 PyObject* pyList = NULL;
4037 wxArrayVideoModes arr = self->GetModes(mode);
4038 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4039 pyList = PyList_New(0);
4040 for (size_t i=0; i < arr.GetCount(); i++)
4041 {
4042 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4043 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4044 PyList_Append(pyList, pyObj);
4045 Py_DECREF(pyObj);
4046 }
4047 wxPyEndBlockThreads(blocked);
4048 return pyList;
4049 #else
4050 wxPyRaiseNotImplemented();
4051 return NULL;
4052 #endif
4053 }
4054 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4055 #if wxUSE_DISPLAY
4056 return self->GetCurrentMode();
4057 #else
4058 wxPyRaiseNotImplemented();
4059 return wxDefaultVideoMode;
4060 #endif
4061 }
4062 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4063 #if wxUSE_DISPLAY
4064 return self->ChangeMode(mode);
4065 #else
4066 wxPyRaiseNotImplemented();
4067 return false;
4068 #endif
4069 }
4070 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4071 #if wxUSE_DISPLAY
4072 self->ResetMode();
4073 #else
4074 wxPyRaiseNotImplemented();
4075 #endif
4076 }
4077
4078 #include <wx/stdpaths.h>
4079
4080 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4081 return (wxStandardPaths*) &wxStandardPaths::Get();
4082 }
4083
4084 #ifndef wxHAS_POWER_EVENTS
4085 // Dummy class and other definitions for platforms that don't have them
4086
4087 // See wxPython_int.h for wxPowerEvent
4088
4089 enum {
4090 wxEVT_POWER_SUSPENDING,
4091 wxEVT_POWER_SUSPENDED,
4092 wxEVT_POWER_SUSPEND_CANCEL,
4093 wxEVT_POWER_RESUME,
4094 };
4095
4096 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4097 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4098
4099 #endif
4100
4101
4102 #include <wx/aboutdlg.h>
4103
4104 #ifdef __cplusplus
4105 extern "C" {
4106 #endif
4107 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4108 PyObject *resultobj = 0;
4109 wxSystemColour arg1 ;
4110 wxColour result;
4111 int val1 ;
4112 int ecode1 = 0 ;
4113 PyObject * obj0 = 0 ;
4114 char * kwnames[] = {
4115 (char *) "index", NULL
4116 };
4117
4118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4119 ecode1 = SWIG_AsVal_int(obj0, &val1);
4120 if (!SWIG_IsOK(ecode1)) {
4121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4122 }
4123 arg1 = static_cast< wxSystemColour >(val1);
4124 {
4125 if (!wxPyCheckForApp()) SWIG_fail;
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 result = wxSystemSettings::GetColour(arg1);
4128 wxPyEndAllowThreads(__tstate);
4129 if (PyErr_Occurred()) SWIG_fail;
4130 }
4131 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4132 return resultobj;
4133 fail:
4134 return NULL;
4135 }
4136
4137
4138 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4139 PyObject *resultobj = 0;
4140 wxSystemFont arg1 ;
4141 wxFont result;
4142 int val1 ;
4143 int ecode1 = 0 ;
4144 PyObject * obj0 = 0 ;
4145 char * kwnames[] = {
4146 (char *) "index", NULL
4147 };
4148
4149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4150 ecode1 = SWIG_AsVal_int(obj0, &val1);
4151 if (!SWIG_IsOK(ecode1)) {
4152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4153 }
4154 arg1 = static_cast< wxSystemFont >(val1);
4155 {
4156 if (!wxPyCheckForApp()) SWIG_fail;
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = wxSystemSettings::GetFont(arg1);
4159 wxPyEndAllowThreads(__tstate);
4160 if (PyErr_Occurred()) SWIG_fail;
4161 }
4162 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4163 return resultobj;
4164 fail:
4165 return NULL;
4166 }
4167
4168
4169 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4170 PyObject *resultobj = 0;
4171 wxSystemMetric arg1 ;
4172 wxWindow *arg2 = (wxWindow *) NULL ;
4173 int result;
4174 int val1 ;
4175 int ecode1 = 0 ;
4176 void *argp2 = 0 ;
4177 int res2 = 0 ;
4178 PyObject * obj0 = 0 ;
4179 PyObject * obj1 = 0 ;
4180 char * kwnames[] = {
4181 (char *) "index",(char *) "win", NULL
4182 };
4183
4184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4185 ecode1 = SWIG_AsVal_int(obj0, &val1);
4186 if (!SWIG_IsOK(ecode1)) {
4187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4188 }
4189 arg1 = static_cast< wxSystemMetric >(val1);
4190 if (obj1) {
4191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4192 if (!SWIG_IsOK(res2)) {
4193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4194 }
4195 arg2 = reinterpret_cast< wxWindow * >(argp2);
4196 }
4197 {
4198 if (!wxPyCheckForApp()) SWIG_fail;
4199 PyThreadState* __tstate = wxPyBeginAllowThreads();
4200 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4201 wxPyEndAllowThreads(__tstate);
4202 if (PyErr_Occurred()) SWIG_fail;
4203 }
4204 resultobj = SWIG_From_int(static_cast< int >(result));
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj = 0;
4213 wxSystemFeature arg1 ;
4214 bool result;
4215 int val1 ;
4216 int ecode1 = 0 ;
4217 PyObject * obj0 = 0 ;
4218 char * kwnames[] = {
4219 (char *) "index", NULL
4220 };
4221
4222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4223 ecode1 = SWIG_AsVal_int(obj0, &val1);
4224 if (!SWIG_IsOK(ecode1)) {
4225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4226 }
4227 arg1 = static_cast< wxSystemFeature >(val1);
4228 {
4229 if (!wxPyCheckForApp()) SWIG_fail;
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = (bool)wxSystemSettings::HasFeature(arg1);
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 {
4236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4237 }
4238 return resultobj;
4239 fail:
4240 return NULL;
4241 }
4242
4243
4244 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4245 PyObject *resultobj = 0;
4246 wxSystemScreenType result;
4247
4248 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4249 {
4250 if (!wxPyCheckForApp()) SWIG_fail;
4251 PyThreadState* __tstate = wxPyBeginAllowThreads();
4252 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 resultobj = SWIG_From_int(static_cast< int >(result));
4257 return resultobj;
4258 fail:
4259 return NULL;
4260 }
4261
4262
4263 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4264 PyObject *resultobj = 0;
4265 wxSystemScreenType arg1 ;
4266 int val1 ;
4267 int ecode1 = 0 ;
4268 PyObject * obj0 = 0 ;
4269 char * kwnames[] = {
4270 (char *) "screen", NULL
4271 };
4272
4273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4274 ecode1 = SWIG_AsVal_int(obj0, &val1);
4275 if (!SWIG_IsOK(ecode1)) {
4276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4277 }
4278 arg1 = static_cast< wxSystemScreenType >(val1);
4279 {
4280 if (!wxPyCheckForApp()) SWIG_fail;
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 wxSystemSettings::SetScreenType(arg1);
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 resultobj = SWIG_Py_Void();
4287 return resultobj;
4288 fail:
4289 return NULL;
4290 }
4291
4292
4293 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4294 PyObject *obj;
4295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4296 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4297 return SWIG_Py_Void();
4298 }
4299
4300 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4301 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4302 return 1;
4303 }
4304
4305
4306 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4307 PyObject *pyobj = 0;
4308
4309 {
4310 #if wxUSE_UNICODE
4311 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4312 #else
4313 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4314 #endif
4315 }
4316 return pyobj;
4317 }
4318
4319
4320 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4321 PyObject *resultobj = 0;
4322 wxSystemOptions *result = 0 ;
4323
4324 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4325 {
4326 PyThreadState* __tstate = wxPyBeginAllowThreads();
4327 result = (wxSystemOptions *)new wxSystemOptions();
4328 wxPyEndAllowThreads(__tstate);
4329 if (PyErr_Occurred()) SWIG_fail;
4330 }
4331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj = 0;
4340 wxString *arg1 = 0 ;
4341 wxString *arg2 = 0 ;
4342 bool temp1 = false ;
4343 bool temp2 = false ;
4344 PyObject * obj0 = 0 ;
4345 PyObject * obj1 = 0 ;
4346 char * kwnames[] = {
4347 (char *) "name",(char *) "value", NULL
4348 };
4349
4350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4351 {
4352 arg1 = wxString_in_helper(obj0);
4353 if (arg1 == NULL) SWIG_fail;
4354 temp1 = true;
4355 }
4356 {
4357 arg2 = wxString_in_helper(obj1);
4358 if (arg2 == NULL) SWIG_fail;
4359 temp2 = true;
4360 }
4361 {
4362 PyThreadState* __tstate = wxPyBeginAllowThreads();
4363 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4364 wxPyEndAllowThreads(__tstate);
4365 if (PyErr_Occurred()) SWIG_fail;
4366 }
4367 resultobj = SWIG_Py_Void();
4368 {
4369 if (temp1)
4370 delete arg1;
4371 }
4372 {
4373 if (temp2)
4374 delete arg2;
4375 }
4376 return resultobj;
4377 fail:
4378 {
4379 if (temp1)
4380 delete arg1;
4381 }
4382 {
4383 if (temp2)
4384 delete arg2;
4385 }
4386 return NULL;
4387 }
4388
4389
4390 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4391 PyObject *resultobj = 0;
4392 wxString *arg1 = 0 ;
4393 int arg2 ;
4394 bool temp1 = false ;
4395 int val2 ;
4396 int ecode2 = 0 ;
4397 PyObject * obj0 = 0 ;
4398 PyObject * obj1 = 0 ;
4399 char * kwnames[] = {
4400 (char *) "name",(char *) "value", NULL
4401 };
4402
4403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4404 {
4405 arg1 = wxString_in_helper(obj0);
4406 if (arg1 == NULL) SWIG_fail;
4407 temp1 = true;
4408 }
4409 ecode2 = SWIG_AsVal_int(obj1, &val2);
4410 if (!SWIG_IsOK(ecode2)) {
4411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4412 }
4413 arg2 = static_cast< int >(val2);
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 resultobj = SWIG_Py_Void();
4421 {
4422 if (temp1)
4423 delete arg1;
4424 }
4425 return resultobj;
4426 fail:
4427 {
4428 if (temp1)
4429 delete arg1;
4430 }
4431 return NULL;
4432 }
4433
4434
4435 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj = 0;
4437 wxString *arg1 = 0 ;
4438 wxString result;
4439 bool temp1 = false ;
4440 PyObject * obj0 = 0 ;
4441 char * kwnames[] = {
4442 (char *) "name", NULL
4443 };
4444
4445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4446 {
4447 arg1 = wxString_in_helper(obj0);
4448 if (arg1 == NULL) SWIG_fail;
4449 temp1 = true;
4450 }
4451 {
4452 PyThreadState* __tstate = wxPyBeginAllowThreads();
4453 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4454 wxPyEndAllowThreads(__tstate);
4455 if (PyErr_Occurred()) SWIG_fail;
4456 }
4457 {
4458 #if wxUSE_UNICODE
4459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4460 #else
4461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4462 #endif
4463 }
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return resultobj;
4469 fail:
4470 {
4471 if (temp1)
4472 delete arg1;
4473 }
4474 return NULL;
4475 }
4476
4477
4478 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4479 PyObject *resultobj = 0;
4480 wxString *arg1 = 0 ;
4481 int result;
4482 bool temp1 = false ;
4483 PyObject * obj0 = 0 ;
4484 char * kwnames[] = {
4485 (char *) "name", NULL
4486 };
4487
4488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4489 {
4490 arg1 = wxString_in_helper(obj0);
4491 if (arg1 == NULL) SWIG_fail;
4492 temp1 = true;
4493 }
4494 {
4495 PyThreadState* __tstate = wxPyBeginAllowThreads();
4496 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4497 wxPyEndAllowThreads(__tstate);
4498 if (PyErr_Occurred()) SWIG_fail;
4499 }
4500 resultobj = SWIG_From_int(static_cast< int >(result));
4501 {
4502 if (temp1)
4503 delete arg1;
4504 }
4505 return resultobj;
4506 fail:
4507 {
4508 if (temp1)
4509 delete arg1;
4510 }
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4516 PyObject *resultobj = 0;
4517 wxString *arg1 = 0 ;
4518 bool result;
4519 bool temp1 = false ;
4520 PyObject * obj0 = 0 ;
4521 char * kwnames[] = {
4522 (char *) "name", NULL
4523 };
4524
4525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4526 {
4527 arg1 = wxString_in_helper(obj0);
4528 if (arg1 == NULL) SWIG_fail;
4529 temp1 = true;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4539 }
4540 {
4541 if (temp1)
4542 delete arg1;
4543 }
4544 return resultobj;
4545 fail:
4546 {
4547 if (temp1)
4548 delete arg1;
4549 }
4550 return NULL;
4551 }
4552
4553
4554 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4555 PyObject *resultobj = 0;
4556 wxString *arg1 = 0 ;
4557 bool result;
4558 bool temp1 = false ;
4559 PyObject * obj0 = 0 ;
4560 char * kwnames[] = {
4561 (char *) "name", NULL
4562 };
4563
4564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4565 {
4566 arg1 = wxString_in_helper(obj0);
4567 if (arg1 == NULL) SWIG_fail;
4568 temp1 = true;
4569 }
4570 {
4571 PyThreadState* __tstate = wxPyBeginAllowThreads();
4572 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4573 wxPyEndAllowThreads(__tstate);
4574 if (PyErr_Occurred()) SWIG_fail;
4575 }
4576 {
4577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4578 }
4579 {
4580 if (temp1)
4581 delete arg1;
4582 }
4583 return resultobj;
4584 fail:
4585 {
4586 if (temp1)
4587 delete arg1;
4588 }
4589 return NULL;
4590 }
4591
4592
4593 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4594 PyObject *obj;
4595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4596 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4597 return SWIG_Py_Void();
4598 }
4599
4600 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4601 return SWIG_Python_InitShadowInstance(args);
4602 }
4603
4604 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4605 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4606 return 1;
4607 }
4608
4609
4610 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4611 PyObject *pyobj = 0;
4612
4613 {
4614 #if wxUSE_UNICODE
4615 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4616 #else
4617 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4618 #endif
4619 }
4620 return pyobj;
4621 }
4622
4623
4624 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4625 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4626 return 1;
4627 }
4628
4629
4630 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4631 PyObject *pyobj = 0;
4632
4633 {
4634 #if wxUSE_UNICODE
4635 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4636 #else
4637 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4638 #endif
4639 }
4640 return pyobj;
4641 }
4642
4643
4644 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4645 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4646 return 1;
4647 }
4648
4649
4650 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4651 PyObject *pyobj = 0;
4652
4653 {
4654 #if wxUSE_UNICODE
4655 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4656 #else
4657 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4658 #endif
4659 }
4660 return pyobj;
4661 }
4662
4663
4664 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4665 PyObject *resultobj = 0;
4666 long result;
4667
4668 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4669 {
4670 PyThreadState* __tstate = wxPyBeginAllowThreads();
4671 result = (long)wxNewId();
4672 wxPyEndAllowThreads(__tstate);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 resultobj = SWIG_From_long(static_cast< long >(result));
4676 return resultobj;
4677 fail:
4678 return NULL;
4679 }
4680
4681
4682 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4683 PyObject *resultobj = 0;
4684 long arg1 ;
4685 long val1 ;
4686 int ecode1 = 0 ;
4687 PyObject * obj0 = 0 ;
4688 char * kwnames[] = {
4689 (char *) "id", NULL
4690 };
4691
4692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4693 ecode1 = SWIG_AsVal_long(obj0, &val1);
4694 if (!SWIG_IsOK(ecode1)) {
4695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4696 }
4697 arg1 = static_cast< long >(val1);
4698 {
4699 PyThreadState* __tstate = wxPyBeginAllowThreads();
4700 wxRegisterId(arg1);
4701 wxPyEndAllowThreads(__tstate);
4702 if (PyErr_Occurred()) SWIG_fail;
4703 }
4704 resultobj = SWIG_Py_Void();
4705 return resultobj;
4706 fail:
4707 return NULL;
4708 }
4709
4710
4711 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4712 PyObject *resultobj = 0;
4713 long result;
4714
4715 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = (long)wxGetCurrentId();
4719 wxPyEndAllowThreads(__tstate);
4720 if (PyErr_Occurred()) SWIG_fail;
4721 }
4722 resultobj = SWIG_From_long(static_cast< long >(result));
4723 return resultobj;
4724 fail:
4725 return NULL;
4726 }
4727
4728
4729 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4730 PyObject *resultobj = 0;
4731 int arg1 ;
4732 bool result;
4733 int val1 ;
4734 int ecode1 = 0 ;
4735 PyObject * obj0 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "id", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4741 ecode1 = SWIG_AsVal_int(obj0, &val1);
4742 if (!SWIG_IsOK(ecode1)) {
4743 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4744 }
4745 arg1 = static_cast< int >(val1);
4746 {
4747 PyThreadState* __tstate = wxPyBeginAllowThreads();
4748 result = (bool)wxIsStockID(arg1);
4749 wxPyEndAllowThreads(__tstate);
4750 if (PyErr_Occurred()) SWIG_fail;
4751 }
4752 {
4753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4754 }
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 int arg1 ;
4764 wxString *arg2 = 0 ;
4765 bool result;
4766 int val1 ;
4767 int ecode1 = 0 ;
4768 bool temp2 = false ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "id",(char *) "label", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4776 ecode1 = SWIG_AsVal_int(obj0, &val1);
4777 if (!SWIG_IsOK(ecode1)) {
4778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4779 }
4780 arg1 = static_cast< int >(val1);
4781 {
4782 arg2 = wxString_in_helper(obj1);
4783 if (arg2 == NULL) SWIG_fail;
4784 temp2 = true;
4785 }
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 {
4793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4794 }
4795 {
4796 if (temp2)
4797 delete arg2;
4798 }
4799 return resultobj;
4800 fail:
4801 {
4802 if (temp2)
4803 delete arg2;
4804 }
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 int arg1 ;
4812 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4813 wxString result;
4814 int val1 ;
4815 int ecode1 = 0 ;
4816 long val2 ;
4817 int ecode2 = 0 ;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char * kwnames[] = {
4821 (char *) "id",(char *) "flags", NULL
4822 };
4823
4824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4825 ecode1 = SWIG_AsVal_int(obj0, &val1);
4826 if (!SWIG_IsOK(ecode1)) {
4827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4828 }
4829 arg1 = static_cast< int >(val1);
4830 if (obj1) {
4831 ecode2 = SWIG_AsVal_long(obj1, &val2);
4832 if (!SWIG_IsOK(ecode2)) {
4833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4834 }
4835 arg2 = static_cast< long >(val2);
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 result = wxGetStockLabel(arg1,arg2);
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 {
4844 #if wxUSE_UNICODE
4845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4846 #else
4847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4848 #endif
4849 }
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj = 0;
4858 int arg1 ;
4859 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4860 wxString result;
4861 int val1 ;
4862 int ecode1 = 0 ;
4863 int val2 ;
4864 int ecode2 = 0 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 char * kwnames[] = {
4868 (char *) "id",(char *) "client", NULL
4869 };
4870
4871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4872 ecode1 = SWIG_AsVal_int(obj0, &val1);
4873 if (!SWIG_IsOK(ecode1)) {
4874 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4875 }
4876 arg1 = static_cast< int >(val1);
4877 if (obj1) {
4878 ecode2 = SWIG_AsVal_int(obj1, &val2);
4879 if (!SWIG_IsOK(ecode2)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4881 }
4882 arg2 = static_cast< wxStockHelpStringClient >(val2);
4883 }
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 result = wxGetStockHelpString(arg1,arg2);
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 {
4891 #if wxUSE_UNICODE
4892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4893 #else
4894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4895 #endif
4896 }
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4904 PyObject *resultobj = 0;
4905
4906 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4907 {
4908 if (!wxPyCheckForApp()) SWIG_fail;
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 wxBell();
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_Py_Void();
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4922 PyObject *resultobj = 0;
4923
4924 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4925 {
4926 if (!wxPyCheckForApp()) SWIG_fail;
4927 PyThreadState* __tstate = wxPyBeginAllowThreads();
4928 wxEndBusyCursor();
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 resultobj = SWIG_Py_Void();
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj = 0;
4941 bool arg1 = (bool) true ;
4942 long result;
4943 bool val1 ;
4944 int ecode1 = 0 ;
4945 PyObject * obj0 = 0 ;
4946 char * kwnames[] = {
4947 (char *) "resetTimer", NULL
4948 };
4949
4950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4951 if (obj0) {
4952 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4953 if (!SWIG_IsOK(ecode1)) {
4954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4955 }
4956 arg1 = static_cast< bool >(val1);
4957 }
4958 {
4959 PyThreadState* __tstate = wxPyBeginAllowThreads();
4960 result = (long)wxGetElapsedTime(arg1);
4961 wxPyEndAllowThreads(__tstate);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 resultobj = SWIG_From_long(static_cast< long >(result));
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4972 PyObject *resultobj = 0;
4973 bool result;
4974
4975 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (bool)wxIsBusy();
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4984 }
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4992 PyObject *resultobj = 0;
4993 wxString result;
4994
4995 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4996 {
4997 PyThreadState* __tstate = wxPyBeginAllowThreads();
4998 result = wxNow();
4999 wxPyEndAllowThreads(__tstate);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 {
5003 #if wxUSE_UNICODE
5004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5005 #else
5006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5007 #endif
5008 }
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5016 PyObject *resultobj = 0;
5017 wxString const &arg1_defvalue = wxPyEmptyString ;
5018 wxString *arg1 = (wxString *) &arg1_defvalue ;
5019 bool result;
5020 bool temp1 = false ;
5021 PyObject * obj0 = 0 ;
5022 char * kwnames[] = {
5023 (char *) "command", NULL
5024 };
5025
5026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5027 if (obj0) {
5028 {
5029 arg1 = wxString_in_helper(obj0);
5030 if (arg1 == NULL) SWIG_fail;
5031 temp1 = true;
5032 }
5033 }
5034 {
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (bool)wxShell((wxString const &)*arg1);
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 {
5041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5042 }
5043 {
5044 if (temp1)
5045 delete arg1;
5046 }
5047 return resultobj;
5048 fail:
5049 {
5050 if (temp1)
5051 delete arg1;
5052 }
5053 return NULL;
5054 }
5055
5056
5057 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5058 PyObject *resultobj = 0;
5059
5060 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5061 {
5062 PyThreadState* __tstate = wxPyBeginAllowThreads();
5063 wxStartTimer();
5064 wxPyEndAllowThreads(__tstate);
5065 if (PyErr_Occurred()) SWIG_fail;
5066 }
5067 resultobj = SWIG_Py_Void();
5068 return resultobj;
5069 fail:
5070 return NULL;
5071 }
5072
5073
5074 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5075 PyObject *resultobj = 0;
5076 int *arg1 = (int *) 0 ;
5077 int *arg2 = (int *) 0 ;
5078 int result;
5079 int temp1 ;
5080 int res1 = SWIG_TMPOBJ ;
5081 int temp2 ;
5082 int res2 = SWIG_TMPOBJ ;
5083
5084 arg1 = &temp1;
5085 arg2 = &temp2;
5086 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5087 {
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 result = (int)wxGetOsVersion(arg1,arg2);
5090 wxPyEndAllowThreads(__tstate);
5091 if (PyErr_Occurred()) SWIG_fail;
5092 }
5093 resultobj = SWIG_From_int(static_cast< int >(result));
5094 if (SWIG_IsTmpObj(res1)) {
5095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5096 } else {
5097 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5099 }
5100 if (SWIG_IsTmpObj(res2)) {
5101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5102 } else {
5103 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5105 }
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5113 PyObject *resultobj = 0;
5114 wxString result;
5115
5116 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5117 {
5118 PyThreadState* __tstate = wxPyBeginAllowThreads();
5119 result = wxGetOsDescription();
5120 wxPyEndAllowThreads(__tstate);
5121 if (PyErr_Occurred()) SWIG_fail;
5122 }
5123 {
5124 #if wxUSE_UNICODE
5125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5126 #else
5127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5128 #endif
5129 }
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 bool result;
5139
5140 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 result = (bool)wxIsPlatformLittleEndian();
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 {
5148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5149 }
5150 return resultobj;
5151 fail:
5152 return NULL;
5153 }
5154
5155
5156 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5157 PyObject *resultobj = 0;
5158 bool result;
5159
5160 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (bool)wxIsPlatform64Bit();
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5169 }
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxMemorySize result;
5179
5180 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = wxGetFreeMemory();
5184 wxPyEndAllowThreads(__tstate);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 {
5188 #if wxUSE_LONGLONG
5189 resultobj = PyLong_FromLongLong((&result)->GetValue());
5190 #else
5191 resultobj = PyInt_FromLong(result);
5192 #endif
5193 }
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj = 0;
5202 wxShutdownFlags arg1 ;
5203 bool result;
5204 int val1 ;
5205 int ecode1 = 0 ;
5206 PyObject * obj0 = 0 ;
5207 char * kwnames[] = {
5208 (char *) "wFlags", NULL
5209 };
5210
5211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5212 ecode1 = SWIG_AsVal_int(obj0, &val1);
5213 if (!SWIG_IsOK(ecode1)) {
5214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5215 }
5216 arg1 = static_cast< wxShutdownFlags >(val1);
5217 {
5218 if (!wxPyCheckForApp()) SWIG_fail;
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = (bool)wxShutdown(arg1);
5221 wxPyEndAllowThreads(__tstate);
5222 if (PyErr_Occurred()) SWIG_fail;
5223 }
5224 {
5225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5226 }
5227 return resultobj;
5228 fail:
5229 return NULL;
5230 }
5231
5232
5233 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5234 PyObject *resultobj = 0;
5235 int arg1 ;
5236 int val1 ;
5237 int ecode1 = 0 ;
5238 PyObject * obj0 = 0 ;
5239 char * kwnames[] = {
5240 (char *) "secs", NULL
5241 };
5242
5243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5244 ecode1 = SWIG_AsVal_int(obj0, &val1);
5245 if (!SWIG_IsOK(ecode1)) {
5246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5247 }
5248 arg1 = static_cast< int >(val1);
5249 {
5250 PyThreadState* __tstate = wxPyBeginAllowThreads();
5251 wxSleep(arg1);
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 resultobj = SWIG_Py_Void();
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj = 0;
5264 unsigned long arg1 ;
5265 unsigned long val1 ;
5266 int ecode1 = 0 ;
5267 PyObject * obj0 = 0 ;
5268 char * kwnames[] = {
5269 (char *) "milliseconds", NULL
5270 };
5271
5272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5273 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5274 if (!SWIG_IsOK(ecode1)) {
5275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5276 }
5277 arg1 = static_cast< unsigned long >(val1);
5278 {
5279 PyThreadState* __tstate = wxPyBeginAllowThreads();
5280 wxMilliSleep(arg1);
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 resultobj = SWIG_Py_Void();
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 unsigned long arg1 ;
5294 unsigned long val1 ;
5295 int ecode1 = 0 ;
5296 PyObject * obj0 = 0 ;
5297 char * kwnames[] = {
5298 (char *) "microseconds", NULL
5299 };
5300
5301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5302 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5303 if (!SWIG_IsOK(ecode1)) {
5304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5305 }
5306 arg1 = static_cast< unsigned long >(val1);
5307 {
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 wxMicroSleep(arg1);
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 resultobj = SWIG_Py_Void();
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5321 PyObject *resultobj = 0;
5322 bool arg1 ;
5323 bool val1 ;
5324 int ecode1 = 0 ;
5325 PyObject * obj0 = 0 ;
5326 char * kwnames[] = {
5327 (char *) "enable", NULL
5328 };
5329
5330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5331 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5332 if (!SWIG_IsOK(ecode1)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5334 }
5335 arg1 = static_cast< bool >(val1);
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 wxEnableTopLevelWindows(arg1);
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 resultobj = SWIG_Py_Void();
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5350 PyObject *resultobj = 0;
5351 wxString *arg1 = 0 ;
5352 wxString result;
5353 bool temp1 = false ;
5354 PyObject * obj0 = 0 ;
5355 char * kwnames[] = {
5356 (char *) "in", NULL
5357 };
5358
5359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5360 {
5361 arg1 = wxString_in_helper(obj0);
5362 if (arg1 == NULL) SWIG_fail;
5363 temp1 = true;
5364 }
5365 {
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 result = wxStripMenuCodes((wxString const &)*arg1);
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 #if wxUSE_UNICODE
5373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5374 #else
5375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5376 #endif
5377 }
5378 {
5379 if (temp1)
5380 delete arg1;
5381 }
5382 return resultobj;
5383 fail:
5384 {
5385 if (temp1)
5386 delete arg1;
5387 }
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 wxString result;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = wxGetEmailAddress();
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 {
5404 #if wxUSE_UNICODE
5405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5406 #else
5407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5408 #endif
5409 }
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxString result;
5419
5420 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = wxGetHostName();
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 #if wxUSE_UNICODE
5429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5430 #else
5431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5432 #endif
5433 }
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5441 PyObject *resultobj = 0;
5442 wxString result;
5443
5444 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 result = wxGetFullHostName();
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 {
5452 #if wxUSE_UNICODE
5453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5454 #else
5455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5456 #endif
5457 }
5458 return resultobj;
5459 fail:
5460 return NULL;
5461 }
5462
5463
5464 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5465 PyObject *resultobj = 0;
5466 wxString result;
5467
5468 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = wxGetUserId();
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 {
5476 #if wxUSE_UNICODE
5477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5478 #else
5479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5480 #endif
5481 }
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5489 PyObject *resultobj = 0;
5490 wxString result;
5491
5492 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = wxGetUserName();
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 {
5500 #if wxUSE_UNICODE
5501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5502 #else
5503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5504 #endif
5505 }
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5513 PyObject *resultobj = 0;
5514 wxString result;
5515
5516 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5517 {
5518 PyThreadState* __tstate = wxPyBeginAllowThreads();
5519 result = wxGetHomeDir();
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 #if wxUSE_UNICODE
5525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5526 #else
5527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5528 #endif
5529 }
5530 return resultobj;
5531 fail:
5532 return NULL;
5533 }
5534
5535
5536 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5537 PyObject *resultobj = 0;
5538 wxString const &arg1_defvalue = wxPyEmptyString ;
5539 wxString *arg1 = (wxString *) &arg1_defvalue ;
5540 wxString result;
5541 bool temp1 = false ;
5542 PyObject * obj0 = 0 ;
5543 char * kwnames[] = {
5544 (char *) "user", NULL
5545 };
5546
5547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5548 if (obj0) {
5549 {
5550 arg1 = wxString_in_helper(obj0);
5551 if (arg1 == NULL) SWIG_fail;
5552 temp1 = true;
5553 }
5554 }
5555 {
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 result = wxGetUserHome((wxString const &)*arg1);
5558 wxPyEndAllowThreads(__tstate);
5559 if (PyErr_Occurred()) SWIG_fail;
5560 }
5561 {
5562 #if wxUSE_UNICODE
5563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5564 #else
5565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5566 #endif
5567 }
5568 {
5569 if (temp1)
5570 delete arg1;
5571 }
5572 return resultobj;
5573 fail:
5574 {
5575 if (temp1)
5576 delete arg1;
5577 }
5578 return NULL;
5579 }
5580
5581
5582 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5583 PyObject *resultobj = 0;
5584 unsigned long result;
5585
5586 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5587 {
5588 PyThreadState* __tstate = wxPyBeginAllowThreads();
5589 result = (unsigned long)wxGetProcessId();
5590 wxPyEndAllowThreads(__tstate);
5591 if (PyErr_Occurred()) SWIG_fail;
5592 }
5593 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 PyObject *resultobj = 0;
5602
5603 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5604 {
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 wxTrap();
5607 wxPyEndAllowThreads(__tstate);
5608 if (PyErr_Occurred()) SWIG_fail;
5609 }
5610 resultobj = SWIG_Py_Void();
5611 return resultobj;
5612 fail:
5613 return NULL;
5614 }
5615
5616
5617 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5618 PyObject *resultobj = 0;
5619 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5620 wxString *arg1 = (wxString *) &arg1_defvalue ;
5621 wxString const &arg2_defvalue = wxPyEmptyString ;
5622 wxString *arg2 = (wxString *) &arg2_defvalue ;
5623 wxString const &arg3_defvalue = wxPyEmptyString ;
5624 wxString *arg3 = (wxString *) &arg3_defvalue ;
5625 wxString const &arg4_defvalue = wxPyEmptyString ;
5626 wxString *arg4 = (wxString *) &arg4_defvalue ;
5627 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5628 wxString *arg5 = (wxString *) &arg5_defvalue ;
5629 int arg6 = (int) 0 ;
5630 wxWindow *arg7 = (wxWindow *) NULL ;
5631 int arg8 = (int) -1 ;
5632 int arg9 = (int) -1 ;
5633 wxString result;
5634 bool temp1 = false ;
5635 bool temp2 = false ;
5636 bool temp3 = false ;
5637 bool temp4 = false ;
5638 bool temp5 = false ;
5639 int val6 ;
5640 int ecode6 = 0 ;
5641 void *argp7 = 0 ;
5642 int res7 = 0 ;
5643 int val8 ;
5644 int ecode8 = 0 ;
5645 int val9 ;
5646 int ecode9 = 0 ;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 PyObject * obj2 = 0 ;
5650 PyObject * obj3 = 0 ;
5651 PyObject * obj4 = 0 ;
5652 PyObject * obj5 = 0 ;
5653 PyObject * obj6 = 0 ;
5654 PyObject * obj7 = 0 ;
5655 PyObject * obj8 = 0 ;
5656 char * kwnames[] = {
5657 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5658 };
5659
5660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5661 if (obj0) {
5662 {
5663 arg1 = wxString_in_helper(obj0);
5664 if (arg1 == NULL) SWIG_fail;
5665 temp1 = true;
5666 }
5667 }
5668 if (obj1) {
5669 {
5670 arg2 = wxString_in_helper(obj1);
5671 if (arg2 == NULL) SWIG_fail;
5672 temp2 = true;
5673 }
5674 }
5675 if (obj2) {
5676 {
5677 arg3 = wxString_in_helper(obj2);
5678 if (arg3 == NULL) SWIG_fail;
5679 temp3 = true;
5680 }
5681 }
5682 if (obj3) {
5683 {
5684 arg4 = wxString_in_helper(obj3);
5685 if (arg4 == NULL) SWIG_fail;
5686 temp4 = true;
5687 }
5688 }
5689 if (obj4) {
5690 {
5691 arg5 = wxString_in_helper(obj4);
5692 if (arg5 == NULL) SWIG_fail;
5693 temp5 = true;
5694 }
5695 }
5696 if (obj5) {
5697 ecode6 = SWIG_AsVal_int(obj5, &val6);
5698 if (!SWIG_IsOK(ecode6)) {
5699 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5700 }
5701 arg6 = static_cast< int >(val6);
5702 }
5703 if (obj6) {
5704 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5705 if (!SWIG_IsOK(res7)) {
5706 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5707 }
5708 arg7 = reinterpret_cast< wxWindow * >(argp7);
5709 }
5710 if (obj7) {
5711 ecode8 = SWIG_AsVal_int(obj7, &val8);
5712 if (!SWIG_IsOK(ecode8)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5714 }
5715 arg8 = static_cast< int >(val8);
5716 }
5717 if (obj8) {
5718 ecode9 = SWIG_AsVal_int(obj8, &val9);
5719 if (!SWIG_IsOK(ecode9)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5721 }
5722 arg9 = static_cast< int >(val9);
5723 }
5724 {
5725 if (!wxPyCheckForApp()) SWIG_fail;
5726 PyThreadState* __tstate = wxPyBeginAllowThreads();
5727 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5728 wxPyEndAllowThreads(__tstate);
5729 if (PyErr_Occurred()) SWIG_fail;
5730 }
5731 {
5732 #if wxUSE_UNICODE
5733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5734 #else
5735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5736 #endif
5737 }
5738 {
5739 if (temp1)
5740 delete arg1;
5741 }
5742 {
5743 if (temp2)
5744 delete arg2;
5745 }
5746 {
5747 if (temp3)
5748 delete arg3;
5749 }
5750 {
5751 if (temp4)
5752 delete arg4;
5753 }
5754 {
5755 if (temp5)
5756 delete arg5;
5757 }
5758 return resultobj;
5759 fail:
5760 {
5761 if (temp1)
5762 delete arg1;
5763 }
5764 {
5765 if (temp2)
5766 delete arg2;
5767 }
5768 {
5769 if (temp3)
5770 delete arg3;
5771 }
5772 {
5773 if (temp4)
5774 delete arg4;
5775 }
5776 {
5777 if (temp5)
5778 delete arg5;
5779 }
5780 return NULL;
5781 }
5782
5783
5784 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj = 0;
5786 wxString *arg1 = 0 ;
5787 wxString *arg2 = 0 ;
5788 wxString const &arg3_defvalue = wxPyEmptyString ;
5789 wxString *arg3 = (wxString *) &arg3_defvalue ;
5790 wxWindow *arg4 = (wxWindow *) NULL ;
5791 wxString result;
5792 bool temp1 = false ;
5793 bool temp2 = false ;
5794 bool temp3 = false ;
5795 void *argp4 = 0 ;
5796 int res4 = 0 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 PyObject * obj2 = 0 ;
5800 PyObject * obj3 = 0 ;
5801 char * kwnames[] = {
5802 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5803 };
5804
5805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5806 {
5807 arg1 = wxString_in_helper(obj0);
5808 if (arg1 == NULL) SWIG_fail;
5809 temp1 = true;
5810 }
5811 {
5812 arg2 = wxString_in_helper(obj1);
5813 if (arg2 == NULL) SWIG_fail;
5814 temp2 = true;
5815 }
5816 if (obj2) {
5817 {
5818 arg3 = wxString_in_helper(obj2);
5819 if (arg3 == NULL) SWIG_fail;
5820 temp3 = true;
5821 }
5822 }
5823 if (obj3) {
5824 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5825 if (!SWIG_IsOK(res4)) {
5826 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5827 }
5828 arg4 = reinterpret_cast< wxWindow * >(argp4);
5829 }
5830 {
5831 if (!wxPyCheckForApp()) SWIG_fail;
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 #if wxUSE_UNICODE
5839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5840 #else
5841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5842 #endif
5843 }
5844 {
5845 if (temp1)
5846 delete arg1;
5847 }
5848 {
5849 if (temp2)
5850 delete arg2;
5851 }
5852 {
5853 if (temp3)
5854 delete arg3;
5855 }
5856 return resultobj;
5857 fail:
5858 {
5859 if (temp1)
5860 delete arg1;
5861 }
5862 {
5863 if (temp2)
5864 delete arg2;
5865 }
5866 {
5867 if (temp3)
5868 delete arg3;
5869 }
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj = 0;
5876 wxString *arg1 = 0 ;
5877 wxString *arg2 = 0 ;
5878 wxString const &arg3_defvalue = wxPyEmptyString ;
5879 wxString *arg3 = (wxString *) &arg3_defvalue ;
5880 wxWindow *arg4 = (wxWindow *) NULL ;
5881 wxString result;
5882 bool temp1 = false ;
5883 bool temp2 = false ;
5884 bool temp3 = false ;
5885 void *argp4 = 0 ;
5886 int res4 = 0 ;
5887 PyObject * obj0 = 0 ;
5888 PyObject * obj1 = 0 ;
5889 PyObject * obj2 = 0 ;
5890 PyObject * obj3 = 0 ;
5891 char * kwnames[] = {
5892 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5893 };
5894
5895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5896 {
5897 arg1 = wxString_in_helper(obj0);
5898 if (arg1 == NULL) SWIG_fail;
5899 temp1 = true;
5900 }
5901 {
5902 arg2 = wxString_in_helper(obj1);
5903 if (arg2 == NULL) SWIG_fail;
5904 temp2 = true;
5905 }
5906 if (obj2) {
5907 {
5908 arg3 = wxString_in_helper(obj2);
5909 if (arg3 == NULL) SWIG_fail;
5910 temp3 = true;
5911 }
5912 }
5913 if (obj3) {
5914 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5915 if (!SWIG_IsOK(res4)) {
5916 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5917 }
5918 arg4 = reinterpret_cast< wxWindow * >(argp4);
5919 }
5920 {
5921 if (!wxPyCheckForApp()) SWIG_fail;
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5924 wxPyEndAllowThreads(__tstate);
5925 if (PyErr_Occurred()) SWIG_fail;
5926 }
5927 {
5928 #if wxUSE_UNICODE
5929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5930 #else
5931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5932 #endif
5933 }
5934 {
5935 if (temp1)
5936 delete arg1;
5937 }
5938 {
5939 if (temp2)
5940 delete arg2;
5941 }
5942 {
5943 if (temp3)
5944 delete arg3;
5945 }
5946 return resultobj;
5947 fail:
5948 {
5949 if (temp1)
5950 delete arg1;
5951 }
5952 {
5953 if (temp2)
5954 delete arg2;
5955 }
5956 {
5957 if (temp3)
5958 delete arg3;
5959 }
5960 return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = 0;
5966 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5967 wxString *arg1 = (wxString *) &arg1_defvalue ;
5968 wxString const &arg2_defvalue = wxPyEmptyString ;
5969 wxString *arg2 = (wxString *) &arg2_defvalue ;
5970 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5971 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5972 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5973 wxWindow *arg5 = (wxWindow *) NULL ;
5974 wxString result;
5975 bool temp1 = false ;
5976 bool temp2 = false ;
5977 long val3 ;
5978 int ecode3 = 0 ;
5979 wxPoint temp4 ;
5980 void *argp5 = 0 ;
5981 int res5 = 0 ;
5982 PyObject * obj0 = 0 ;
5983 PyObject * obj1 = 0 ;
5984 PyObject * obj2 = 0 ;
5985 PyObject * obj3 = 0 ;
5986 PyObject * obj4 = 0 ;
5987 char * kwnames[] = {
5988 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5989 };
5990
5991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5992 if (obj0) {
5993 {
5994 arg1 = wxString_in_helper(obj0);
5995 if (arg1 == NULL) SWIG_fail;
5996 temp1 = true;
5997 }
5998 }
5999 if (obj1) {
6000 {
6001 arg2 = wxString_in_helper(obj1);
6002 if (arg2 == NULL) SWIG_fail;
6003 temp2 = true;
6004 }
6005 }
6006 if (obj2) {
6007 ecode3 = SWIG_AsVal_long(obj2, &val3);
6008 if (!SWIG_IsOK(ecode3)) {
6009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6010 }
6011 arg3 = static_cast< long >(val3);
6012 }
6013 if (obj3) {
6014 {
6015 arg4 = &temp4;
6016 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6017 }
6018 }
6019 if (obj4) {
6020 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6021 if (!SWIG_IsOK(res5)) {
6022 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6023 }
6024 arg5 = reinterpret_cast< wxWindow * >(argp5);
6025 }
6026 {
6027 if (!wxPyCheckForApp()) SWIG_fail;
6028 PyThreadState* __tstate = wxPyBeginAllowThreads();
6029 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 #if wxUSE_UNICODE
6035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6036 #else
6037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6038 #endif
6039 }
6040 {
6041 if (temp1)
6042 delete arg1;
6043 }
6044 {
6045 if (temp2)
6046 delete arg2;
6047 }
6048 return resultobj;
6049 fail:
6050 {
6051 if (temp1)
6052 delete arg1;
6053 }
6054 {
6055 if (temp2)
6056 delete arg2;
6057 }
6058 return NULL;
6059 }
6060
6061
6062 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6063 PyObject *resultobj = 0;
6064 wxString *arg1 = 0 ;
6065 wxString const &arg2_defvalue = wxPyEmptyString ;
6066 wxString *arg2 = (wxString *) &arg2_defvalue ;
6067 wxString const &arg3_defvalue = wxPyEmptyString ;
6068 wxString *arg3 = (wxString *) &arg3_defvalue ;
6069 wxWindow *arg4 = (wxWindow *) NULL ;
6070 int arg5 = (int) -1 ;
6071 int arg6 = (int) -1 ;
6072 bool arg7 = (bool) true ;
6073 wxString result;
6074 bool temp1 = false ;
6075 bool temp2 = false ;
6076 bool temp3 = false ;
6077 void *argp4 = 0 ;
6078 int res4 = 0 ;
6079 int val5 ;
6080 int ecode5 = 0 ;
6081 int val6 ;
6082 int ecode6 = 0 ;
6083 bool val7 ;
6084 int ecode7 = 0 ;
6085 PyObject * obj0 = 0 ;
6086 PyObject * obj1 = 0 ;
6087 PyObject * obj2 = 0 ;
6088 PyObject * obj3 = 0 ;
6089 PyObject * obj4 = 0 ;
6090 PyObject * obj5 = 0 ;
6091 PyObject * obj6 = 0 ;
6092 char * kwnames[] = {
6093 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6094 };
6095
6096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6097 {
6098 arg1 = wxString_in_helper(obj0);
6099 if (arg1 == NULL) SWIG_fail;
6100 temp1 = true;
6101 }
6102 if (obj1) {
6103 {
6104 arg2 = wxString_in_helper(obj1);
6105 if (arg2 == NULL) SWIG_fail;
6106 temp2 = true;
6107 }
6108 }
6109 if (obj2) {
6110 {
6111 arg3 = wxString_in_helper(obj2);
6112 if (arg3 == NULL) SWIG_fail;
6113 temp3 = true;
6114 }
6115 }
6116 if (obj3) {
6117 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6118 if (!SWIG_IsOK(res4)) {
6119 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6120 }
6121 arg4 = reinterpret_cast< wxWindow * >(argp4);
6122 }
6123 if (obj4) {
6124 ecode5 = SWIG_AsVal_int(obj4, &val5);
6125 if (!SWIG_IsOK(ecode5)) {
6126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6127 }
6128 arg5 = static_cast< int >(val5);
6129 }
6130 if (obj5) {
6131 ecode6 = SWIG_AsVal_int(obj5, &val6);
6132 if (!SWIG_IsOK(ecode6)) {
6133 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6134 }
6135 arg6 = static_cast< int >(val6);
6136 }
6137 if (obj6) {
6138 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6139 if (!SWIG_IsOK(ecode7)) {
6140 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6141 }
6142 arg7 = static_cast< bool >(val7);
6143 }
6144 {
6145 if (!wxPyCheckForApp()) SWIG_fail;
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 {
6152 #if wxUSE_UNICODE
6153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6154 #else
6155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6156 #endif
6157 }
6158 {
6159 if (temp1)
6160 delete arg1;
6161 }
6162 {
6163 if (temp2)
6164 delete arg2;
6165 }
6166 {
6167 if (temp3)
6168 delete arg3;
6169 }
6170 return resultobj;
6171 fail:
6172 {
6173 if (temp1)
6174 delete arg1;
6175 }
6176 {
6177 if (temp2)
6178 delete arg2;
6179 }
6180 {
6181 if (temp3)
6182 delete arg3;
6183 }
6184 return NULL;
6185 }
6186
6187
6188 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6189 PyObject *resultobj = 0;
6190 wxString *arg1 = 0 ;
6191 wxString const &arg2_defvalue = wxPyEmptyString ;
6192 wxString *arg2 = (wxString *) &arg2_defvalue ;
6193 wxString const &arg3_defvalue = wxPyEmptyString ;
6194 wxString *arg3 = (wxString *) &arg3_defvalue ;
6195 wxWindow *arg4 = (wxWindow *) NULL ;
6196 wxString result;
6197 bool temp1 = false ;
6198 bool temp2 = false ;
6199 bool temp3 = false ;
6200 void *argp4 = 0 ;
6201 int res4 = 0 ;
6202 PyObject * obj0 = 0 ;
6203 PyObject * obj1 = 0 ;
6204 PyObject * obj2 = 0 ;
6205 PyObject * obj3 = 0 ;
6206 char * kwnames[] = {
6207 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6208 };
6209
6210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6211 {
6212 arg1 = wxString_in_helper(obj0);
6213 if (arg1 == NULL) SWIG_fail;
6214 temp1 = true;
6215 }
6216 if (obj1) {
6217 {
6218 arg2 = wxString_in_helper(obj1);
6219 if (arg2 == NULL) SWIG_fail;
6220 temp2 = true;
6221 }
6222 }
6223 if (obj2) {
6224 {
6225 arg3 = wxString_in_helper(obj2);
6226 if (arg3 == NULL) SWIG_fail;
6227 temp3 = true;
6228 }
6229 }
6230 if (obj3) {
6231 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6232 if (!SWIG_IsOK(res4)) {
6233 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6234 }
6235 arg4 = reinterpret_cast< wxWindow * >(argp4);
6236 }
6237 {
6238 if (!wxPyCheckForApp()) SWIG_fail;
6239 PyThreadState* __tstate = wxPyBeginAllowThreads();
6240 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6241 wxPyEndAllowThreads(__tstate);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 {
6245 #if wxUSE_UNICODE
6246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6247 #else
6248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6249 #endif
6250 }
6251 {
6252 if (temp1)
6253 delete arg1;
6254 }
6255 {
6256 if (temp2)
6257 delete arg2;
6258 }
6259 {
6260 if (temp3)
6261 delete arg3;
6262 }
6263 return resultobj;
6264 fail:
6265 {
6266 if (temp1)
6267 delete arg1;
6268 }
6269 {
6270 if (temp2)
6271 delete arg2;
6272 }
6273 {
6274 if (temp3)
6275 delete arg3;
6276 }
6277 return NULL;
6278 }
6279
6280
6281 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj = 0;
6283 wxString *arg1 = 0 ;
6284 wxString *arg2 = 0 ;
6285 int arg3 ;
6286 wxString *arg4 = (wxString *) 0 ;
6287 wxWindow *arg5 = (wxWindow *) NULL ;
6288 int arg6 = (int) -1 ;
6289 int arg7 = (int) -1 ;
6290 bool arg8 = (bool) true ;
6291 int arg9 = (int) 150 ;
6292 int arg10 = (int) 200 ;
6293 wxString result;
6294 bool temp1 = false ;
6295 bool temp2 = false ;
6296 void *argp5 = 0 ;
6297 int res5 = 0 ;
6298 int val6 ;
6299 int ecode6 = 0 ;
6300 int val7 ;
6301 int ecode7 = 0 ;
6302 bool val8 ;
6303 int ecode8 = 0 ;
6304 int val9 ;
6305 int ecode9 = 0 ;
6306 int val10 ;
6307 int ecode10 = 0 ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6310 PyObject * obj2 = 0 ;
6311 PyObject * obj3 = 0 ;
6312 PyObject * obj4 = 0 ;
6313 PyObject * obj5 = 0 ;
6314 PyObject * obj6 = 0 ;
6315 PyObject * obj7 = 0 ;
6316 PyObject * obj8 = 0 ;
6317 char * kwnames[] = {
6318 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6319 };
6320
6321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6322 {
6323 arg1 = wxString_in_helper(obj0);
6324 if (arg1 == NULL) SWIG_fail;
6325 temp1 = true;
6326 }
6327 {
6328 arg2 = wxString_in_helper(obj1);
6329 if (arg2 == NULL) SWIG_fail;
6330 temp2 = true;
6331 }
6332 {
6333 arg3 = PyList_Size(obj2);
6334 arg4 = wxString_LIST_helper(obj2);
6335 if (arg4 == NULL) SWIG_fail;
6336 }
6337 if (obj3) {
6338 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6339 if (!SWIG_IsOK(res5)) {
6340 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6341 }
6342 arg5 = reinterpret_cast< wxWindow * >(argp5);
6343 }
6344 if (obj4) {
6345 ecode6 = SWIG_AsVal_int(obj4, &val6);
6346 if (!SWIG_IsOK(ecode6)) {
6347 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6348 }
6349 arg6 = static_cast< int >(val6);
6350 }
6351 if (obj5) {
6352 ecode7 = SWIG_AsVal_int(obj5, &val7);
6353 if (!SWIG_IsOK(ecode7)) {
6354 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6355 }
6356 arg7 = static_cast< int >(val7);
6357 }
6358 if (obj6) {
6359 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6360 if (!SWIG_IsOK(ecode8)) {
6361 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6362 }
6363 arg8 = static_cast< bool >(val8);
6364 }
6365 if (obj7) {
6366 ecode9 = SWIG_AsVal_int(obj7, &val9);
6367 if (!SWIG_IsOK(ecode9)) {
6368 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6369 }
6370 arg9 = static_cast< int >(val9);
6371 }
6372 if (obj8) {
6373 ecode10 = SWIG_AsVal_int(obj8, &val10);
6374 if (!SWIG_IsOK(ecode10)) {
6375 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6376 }
6377 arg10 = static_cast< int >(val10);
6378 }
6379 {
6380 if (!wxPyCheckForApp()) SWIG_fail;
6381 PyThreadState* __tstate = wxPyBeginAllowThreads();
6382 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6383 wxPyEndAllowThreads(__tstate);
6384 if (PyErr_Occurred()) SWIG_fail;
6385 }
6386 {
6387 #if wxUSE_UNICODE
6388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6389 #else
6390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6391 #endif
6392 }
6393 {
6394 if (temp1)
6395 delete arg1;
6396 }
6397 {
6398 if (temp2)
6399 delete arg2;
6400 }
6401 {
6402 if (arg4) delete [] arg4;
6403 }
6404 return resultobj;
6405 fail:
6406 {
6407 if (temp1)
6408 delete arg1;
6409 }
6410 {
6411 if (temp2)
6412 delete arg2;
6413 }
6414 {
6415 if (arg4) delete [] arg4;
6416 }
6417 return NULL;
6418 }
6419
6420
6421 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj = 0;
6423 wxString *arg1 = 0 ;
6424 wxString *arg2 = 0 ;
6425 int arg3 ;
6426 wxString *arg4 = (wxString *) 0 ;
6427 wxWindow *arg5 = (wxWindow *) NULL ;
6428 int arg6 = (int) -1 ;
6429 int arg7 = (int) -1 ;
6430 bool arg8 = (bool) true ;
6431 int arg9 = (int) 150 ;
6432 int arg10 = (int) 200 ;
6433 int result;
6434 bool temp1 = false ;
6435 bool temp2 = false ;
6436 void *argp5 = 0 ;
6437 int res5 = 0 ;
6438 int val6 ;
6439 int ecode6 = 0 ;
6440 int val7 ;
6441 int ecode7 = 0 ;
6442 bool val8 ;
6443 int ecode8 = 0 ;
6444 int val9 ;
6445 int ecode9 = 0 ;
6446 int val10 ;
6447 int ecode10 = 0 ;
6448 PyObject * obj0 = 0 ;
6449 PyObject * obj1 = 0 ;
6450 PyObject * obj2 = 0 ;
6451 PyObject * obj3 = 0 ;
6452 PyObject * obj4 = 0 ;
6453 PyObject * obj5 = 0 ;
6454 PyObject * obj6 = 0 ;
6455 PyObject * obj7 = 0 ;
6456 PyObject * obj8 = 0 ;
6457 char * kwnames[] = {
6458 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6459 };
6460
6461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6462 {
6463 arg1 = wxString_in_helper(obj0);
6464 if (arg1 == NULL) SWIG_fail;
6465 temp1 = true;
6466 }
6467 {
6468 arg2 = wxString_in_helper(obj1);
6469 if (arg2 == NULL) SWIG_fail;
6470 temp2 = true;
6471 }
6472 {
6473 arg3 = PyList_Size(obj2);
6474 arg4 = wxString_LIST_helper(obj2);
6475 if (arg4 == NULL) SWIG_fail;
6476 }
6477 if (obj3) {
6478 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6479 if (!SWIG_IsOK(res5)) {
6480 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6481 }
6482 arg5 = reinterpret_cast< wxWindow * >(argp5);
6483 }
6484 if (obj4) {
6485 ecode6 = SWIG_AsVal_int(obj4, &val6);
6486 if (!SWIG_IsOK(ecode6)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6488 }
6489 arg6 = static_cast< int >(val6);
6490 }
6491 if (obj5) {
6492 ecode7 = SWIG_AsVal_int(obj5, &val7);
6493 if (!SWIG_IsOK(ecode7)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6495 }
6496 arg7 = static_cast< int >(val7);
6497 }
6498 if (obj6) {
6499 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6500 if (!SWIG_IsOK(ecode8)) {
6501 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6502 }
6503 arg8 = static_cast< bool >(val8);
6504 }
6505 if (obj7) {
6506 ecode9 = SWIG_AsVal_int(obj7, &val9);
6507 if (!SWIG_IsOK(ecode9)) {
6508 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6509 }
6510 arg9 = static_cast< int >(val9);
6511 }
6512 if (obj8) {
6513 ecode10 = SWIG_AsVal_int(obj8, &val10);
6514 if (!SWIG_IsOK(ecode10)) {
6515 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6516 }
6517 arg10 = static_cast< int >(val10);
6518 }
6519 {
6520 if (!wxPyCheckForApp()) SWIG_fail;
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_From_int(static_cast< int >(result));
6527 {
6528 if (temp1)
6529 delete arg1;
6530 }
6531 {
6532 if (temp2)
6533 delete arg2;
6534 }
6535 {
6536 if (arg4) delete [] arg4;
6537 }
6538 return resultobj;
6539 fail:
6540 {
6541 if (temp1)
6542 delete arg1;
6543 }
6544 {
6545 if (temp2)
6546 delete arg2;
6547 }
6548 {
6549 if (arg4) delete [] arg4;
6550 }
6551 return NULL;
6552 }
6553
6554
6555 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj = 0;
6557 wxString *arg1 = 0 ;
6558 wxString const &arg2_defvalue = wxPyEmptyString ;
6559 wxString *arg2 = (wxString *) &arg2_defvalue ;
6560 int arg3 = (int) wxOK|wxCENTRE ;
6561 wxWindow *arg4 = (wxWindow *) NULL ;
6562 int arg5 = (int) -1 ;
6563 int arg6 = (int) -1 ;
6564 int result;
6565 bool temp1 = false ;
6566 bool temp2 = false ;
6567 int val3 ;
6568 int ecode3 = 0 ;
6569 void *argp4 = 0 ;
6570 int res4 = 0 ;
6571 int val5 ;
6572 int ecode5 = 0 ;
6573 int val6 ;
6574 int ecode6 = 0 ;
6575 PyObject * obj0 = 0 ;
6576 PyObject * obj1 = 0 ;
6577 PyObject * obj2 = 0 ;
6578 PyObject * obj3 = 0 ;
6579 PyObject * obj4 = 0 ;
6580 PyObject * obj5 = 0 ;
6581 char * kwnames[] = {
6582 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6583 };
6584
6585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6586 {
6587 arg1 = wxString_in_helper(obj0);
6588 if (arg1 == NULL) SWIG_fail;
6589 temp1 = true;
6590 }
6591 if (obj1) {
6592 {
6593 arg2 = wxString_in_helper(obj1);
6594 if (arg2 == NULL) SWIG_fail;
6595 temp2 = true;
6596 }
6597 }
6598 if (obj2) {
6599 ecode3 = SWIG_AsVal_int(obj2, &val3);
6600 if (!SWIG_IsOK(ecode3)) {
6601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6602 }
6603 arg3 = static_cast< int >(val3);
6604 }
6605 if (obj3) {
6606 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6607 if (!SWIG_IsOK(res4)) {
6608 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6609 }
6610 arg4 = reinterpret_cast< wxWindow * >(argp4);
6611 }
6612 if (obj4) {
6613 ecode5 = SWIG_AsVal_int(obj4, &val5);
6614 if (!SWIG_IsOK(ecode5)) {
6615 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6616 }
6617 arg5 = static_cast< int >(val5);
6618 }
6619 if (obj5) {
6620 ecode6 = SWIG_AsVal_int(obj5, &val6);
6621 if (!SWIG_IsOK(ecode6)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6623 }
6624 arg6 = static_cast< int >(val6);
6625 }
6626 {
6627 if (!wxPyCheckForApp()) SWIG_fail;
6628 PyThreadState* __tstate = wxPyBeginAllowThreads();
6629 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6630 wxPyEndAllowThreads(__tstate);
6631 if (PyErr_Occurred()) SWIG_fail;
6632 }
6633 resultobj = SWIG_From_int(static_cast< int >(result));
6634 {
6635 if (temp1)
6636 delete arg1;
6637 }
6638 {
6639 if (temp2)
6640 delete arg2;
6641 }
6642 return resultobj;
6643 fail:
6644 {
6645 if (temp1)
6646 delete arg1;
6647 }
6648 {
6649 if (temp2)
6650 delete arg2;
6651 }
6652 return NULL;
6653 }
6654
6655
6656 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj = 0;
6658 wxString *arg1 = 0 ;
6659 wxString *arg2 = 0 ;
6660 wxString *arg3 = 0 ;
6661 long arg4 ;
6662 long arg5 = (long) 0 ;
6663 long arg6 = (long) 100 ;
6664 wxWindow *arg7 = (wxWindow *) NULL ;
6665 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6666 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6667 long result;
6668 bool temp1 = false ;
6669 bool temp2 = false ;
6670 bool temp3 = false ;
6671 long val4 ;
6672 int ecode4 = 0 ;
6673 long val5 ;
6674 int ecode5 = 0 ;
6675 long val6 ;
6676 int ecode6 = 0 ;
6677 void *argp7 = 0 ;
6678 int res7 = 0 ;
6679 wxPoint temp8 ;
6680 PyObject * obj0 = 0 ;
6681 PyObject * obj1 = 0 ;
6682 PyObject * obj2 = 0 ;
6683 PyObject * obj3 = 0 ;
6684 PyObject * obj4 = 0 ;
6685 PyObject * obj5 = 0 ;
6686 PyObject * obj6 = 0 ;
6687 PyObject * obj7 = 0 ;
6688 char * kwnames[] = {
6689 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6690 };
6691
6692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6693 {
6694 arg1 = wxString_in_helper(obj0);
6695 if (arg1 == NULL) SWIG_fail;
6696 temp1 = true;
6697 }
6698 {
6699 arg2 = wxString_in_helper(obj1);
6700 if (arg2 == NULL) SWIG_fail;
6701 temp2 = true;
6702 }
6703 {
6704 arg3 = wxString_in_helper(obj2);
6705 if (arg3 == NULL) SWIG_fail;
6706 temp3 = true;
6707 }
6708 ecode4 = SWIG_AsVal_long(obj3, &val4);
6709 if (!SWIG_IsOK(ecode4)) {
6710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6711 }
6712 arg4 = static_cast< long >(val4);
6713 if (obj4) {
6714 ecode5 = SWIG_AsVal_long(obj4, &val5);
6715 if (!SWIG_IsOK(ecode5)) {
6716 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6717 }
6718 arg5 = static_cast< long >(val5);
6719 }
6720 if (obj5) {
6721 ecode6 = SWIG_AsVal_long(obj5, &val6);
6722 if (!SWIG_IsOK(ecode6)) {
6723 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6724 }
6725 arg6 = static_cast< long >(val6);
6726 }
6727 if (obj6) {
6728 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6729 if (!SWIG_IsOK(res7)) {
6730 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6731 }
6732 arg7 = reinterpret_cast< wxWindow * >(argp7);
6733 }
6734 if (obj7) {
6735 {
6736 arg8 = &temp8;
6737 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6738 }
6739 }
6740 {
6741 if (!wxPyCheckForApp()) SWIG_fail;
6742 PyThreadState* __tstate = wxPyBeginAllowThreads();
6743 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 resultobj = SWIG_From_long(static_cast< long >(result));
6748 {
6749 if (temp1)
6750 delete arg1;
6751 }
6752 {
6753 if (temp2)
6754 delete arg2;
6755 }
6756 {
6757 if (temp3)
6758 delete arg3;
6759 }
6760 return resultobj;
6761 fail:
6762 {
6763 if (temp1)
6764 delete arg1;
6765 }
6766 {
6767 if (temp2)
6768 delete arg2;
6769 }
6770 {
6771 if (temp3)
6772 delete arg3;
6773 }
6774 return NULL;
6775 }
6776
6777
6778 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6779 PyObject *resultobj = 0;
6780 bool result;
6781
6782 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6783 {
6784 if (!wxPyCheckForApp()) SWIG_fail;
6785 PyThreadState* __tstate = wxPyBeginAllowThreads();
6786 result = (bool)wxColourDisplay();
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 {
6791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6792 }
6793 return resultobj;
6794 fail:
6795 return NULL;
6796 }
6797
6798
6799 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6800 PyObject *resultobj = 0;
6801 int result;
6802
6803 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6804 {
6805 if (!wxPyCheckForApp()) SWIG_fail;
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 result = (int)wxDisplayDepth();
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 resultobj = SWIG_From_int(static_cast< int >(result));
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6819 PyObject *resultobj = 0;
6820 int result;
6821
6822 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6823 {
6824 if (!wxPyCheckForApp()) SWIG_fail;
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (int)wxGetDisplayDepth();
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_From_int(static_cast< int >(result));
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 int *arg1 = (int *) 0 ;
6840 int *arg2 = (int *) 0 ;
6841 int temp1 ;
6842 int res1 = SWIG_TMPOBJ ;
6843 int temp2 ;
6844 int res2 = SWIG_TMPOBJ ;
6845
6846 arg1 = &temp1;
6847 arg2 = &temp2;
6848 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6849 {
6850 if (!wxPyCheckForApp()) SWIG_fail;
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 wxDisplaySize(arg1,arg2);
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_Py_Void();
6857 if (SWIG_IsTmpObj(res1)) {
6858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6859 } else {
6860 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6862 }
6863 if (SWIG_IsTmpObj(res2)) {
6864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6865 } else {
6866 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6868 }
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6876 PyObject *resultobj = 0;
6877 wxSize result;
6878
6879 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6880 {
6881 if (!wxPyCheckForApp()) SWIG_fail;
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 result = wxGetDisplaySize();
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6895 PyObject *resultobj = 0;
6896 int *arg1 = (int *) 0 ;
6897 int *arg2 = (int *) 0 ;
6898 int temp1 ;
6899 int res1 = SWIG_TMPOBJ ;
6900 int temp2 ;
6901 int res2 = SWIG_TMPOBJ ;
6902
6903 arg1 = &temp1;
6904 arg2 = &temp2;
6905 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6906 {
6907 if (!wxPyCheckForApp()) SWIG_fail;
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 wxDisplaySizeMM(arg1,arg2);
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_Py_Void();
6914 if (SWIG_IsTmpObj(res1)) {
6915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6916 } else {
6917 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6919 }
6920 if (SWIG_IsTmpObj(res2)) {
6921 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6922 } else {
6923 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6925 }
6926 return resultobj;
6927 fail:
6928 return NULL;
6929 }
6930
6931
6932 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6933 PyObject *resultobj = 0;
6934 wxSize result;
6935
6936 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6937 {
6938 if (!wxPyCheckForApp()) SWIG_fail;
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 result = wxGetDisplaySizeMM();
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6952 PyObject *resultobj = 0;
6953 int *arg1 = (int *) 0 ;
6954 int *arg2 = (int *) 0 ;
6955 int *arg3 = (int *) 0 ;
6956 int *arg4 = (int *) 0 ;
6957 int temp1 ;
6958 int res1 = SWIG_TMPOBJ ;
6959 int temp2 ;
6960 int res2 = SWIG_TMPOBJ ;
6961 int temp3 ;
6962 int res3 = SWIG_TMPOBJ ;
6963 int temp4 ;
6964 int res4 = SWIG_TMPOBJ ;
6965
6966 arg1 = &temp1;
6967 arg2 = &temp2;
6968 arg3 = &temp3;
6969 arg4 = &temp4;
6970 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6971 {
6972 if (!wxPyCheckForApp()) SWIG_fail;
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6975 wxPyEndAllowThreads(__tstate);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_Py_Void();
6979 if (SWIG_IsTmpObj(res1)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6984 }
6985 if (SWIG_IsTmpObj(res2)) {
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6987 } else {
6988 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6990 }
6991 if (SWIG_IsTmpObj(res3)) {
6992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6993 } else {
6994 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6996 }
6997 if (SWIG_IsTmpObj(res4)) {
6998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6999 } else {
7000 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7002 }
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7010 PyObject *resultobj = 0;
7011 wxRect result;
7012
7013 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7014 {
7015 if (!wxPyCheckForApp()) SWIG_fail;
7016 PyThreadState* __tstate = wxPyBeginAllowThreads();
7017 result = wxGetClientDisplayRect();
7018 wxPyEndAllowThreads(__tstate);
7019 if (PyErr_Occurred()) SWIG_fail;
7020 }
7021 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7029 PyObject *resultobj = 0;
7030 wxCursor *arg1 = 0 ;
7031 void *argp1 = 0 ;
7032 int res1 = 0 ;
7033 PyObject * obj0 = 0 ;
7034 char * kwnames[] = {
7035 (char *) "cursor", NULL
7036 };
7037
7038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7039 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7040 if (!SWIG_IsOK(res1)) {
7041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7042 }
7043 if (!argp1) {
7044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7045 }
7046 arg1 = reinterpret_cast< wxCursor * >(argp1);
7047 {
7048 if (!wxPyCheckForApp()) SWIG_fail;
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 wxSetCursor(*arg1);
7051 wxPyEndAllowThreads(__tstate);
7052 if (PyErr_Occurred()) SWIG_fail;
7053 }
7054 resultobj = SWIG_Py_Void();
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062 PyObject *resultobj = 0;
7063 void *result = 0 ;
7064
7065 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7066 {
7067 if (!wxPyCheckForApp()) SWIG_fail;
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (void *)wxGetXDisplay();
7070 wxPyEndAllowThreads(__tstate);
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7074 return resultobj;
7075 fail:
7076 return NULL;
7077 }
7078
7079
7080 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7081 PyObject *resultobj = 0;
7082 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7083 void *argp1 = 0 ;
7084 int res1 = 0 ;
7085 PyObject * obj0 = 0 ;
7086 char * kwnames[] = {
7087 (char *) "cursor", NULL
7088 };
7089
7090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7091 if (obj0) {
7092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7095 }
7096 arg1 = reinterpret_cast< wxCursor * >(argp1);
7097 }
7098 {
7099 if (!wxPyCheckForApp()) SWIG_fail;
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 wxBeginBusyCursor(arg1);
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 resultobj = SWIG_Py_Void();
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7113 PyObject *resultobj = 0;
7114 wxPoint result;
7115
7116 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7117 {
7118 if (!wxPyCheckForApp()) SWIG_fail;
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = wxGetMousePosition();
7121 wxPyEndAllowThreads(__tstate);
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7132 PyObject *resultobj = 0;
7133 wxWindow *result = 0 ;
7134
7135 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7136 {
7137 if (!wxPyCheckForApp()) SWIG_fail;
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 result = (wxWindow *)FindWindowAtPointer();
7140 wxPyEndAllowThreads(__tstate);
7141 if (PyErr_Occurred()) SWIG_fail;
7142 }
7143 {
7144 resultobj = wxPyMake_wxObject(result, 0);
7145 }
7146 return resultobj;
7147 fail:
7148 return NULL;
7149 }
7150
7151
7152 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7153 PyObject *resultobj = 0;
7154 wxWindow *result = 0 ;
7155
7156 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7157 {
7158 if (!wxPyCheckForApp()) SWIG_fail;
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (wxWindow *)wxGetActiveWindow();
7161 wxPyEndAllowThreads(__tstate);
7162 if (PyErr_Occurred()) SWIG_fail;
7163 }
7164 {
7165 resultobj = wxPyMake_wxObject(result, 0);
7166 }
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7174 PyObject *resultobj = 0;
7175 wxPoint *arg1 = 0 ;
7176 wxWindow *result = 0 ;
7177 wxPoint temp1 ;
7178 PyObject * obj0 = 0 ;
7179 char * kwnames[] = {
7180 (char *) "pt", NULL
7181 };
7182
7183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7184 {
7185 arg1 = &temp1;
7186 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7187 }
7188 {
7189 if (!wxPyCheckForApp()) SWIG_fail;
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 {
7196 resultobj = wxPyMake_wxObject(result, 0);
7197 }
7198 return resultobj;
7199 fail:
7200 return NULL;
7201 }
7202
7203
7204 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj = 0;
7206 wxPoint *arg1 = 0 ;
7207 wxWindow *result = 0 ;
7208 wxPoint temp1 ;
7209 PyObject * obj0 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "pt", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7215 {
7216 arg1 = &temp1;
7217 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7218 }
7219 {
7220 if (!wxPyCheckForApp()) SWIG_fail;
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7223 wxPyEndAllowThreads(__tstate);
7224 if (PyErr_Occurred()) SWIG_fail;
7225 }
7226 {
7227 resultobj = wxPyMake_wxObject(result, 0);
7228 }
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxWindow *arg1 = (wxWindow *) 0 ;
7238 wxWindow *result = 0 ;
7239 void *argp1 = 0 ;
7240 int res1 = 0 ;
7241 PyObject * obj0 = 0 ;
7242 char * kwnames[] = {
7243 (char *) "win", NULL
7244 };
7245
7246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7248 if (!SWIG_IsOK(res1)) {
7249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7250 }
7251 arg1 = reinterpret_cast< wxWindow * >(argp1);
7252 {
7253 if (!wxPyCheckForApp()) SWIG_fail;
7254 PyThreadState* __tstate = wxPyBeginAllowThreads();
7255 result = (wxWindow *)wxGetTopLevelParent(arg1);
7256 wxPyEndAllowThreads(__tstate);
7257 if (PyErr_Occurred()) SWIG_fail;
7258 }
7259 {
7260 resultobj = wxPyMake_wxObject(result, 0);
7261 }
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj = 0;
7270 wxString *arg1 = 0 ;
7271 bool result;
7272 bool temp1 = false ;
7273 PyObject * obj0 = 0 ;
7274 char * kwnames[] = {
7275 (char *) "url", NULL
7276 };
7277
7278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7279 {
7280 arg1 = wxString_in_helper(obj0);
7281 if (arg1 == NULL) SWIG_fail;
7282 temp1 = true;
7283 }
7284 {
7285 PyThreadState* __tstate = wxPyBeginAllowThreads();
7286 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7287 wxPyEndAllowThreads(__tstate);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 {
7291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7292 }
7293 {
7294 if (temp1)
7295 delete arg1;
7296 }
7297 return resultobj;
7298 fail:
7299 {
7300 if (temp1)
7301 delete arg1;
7302 }
7303 return NULL;
7304 }
7305
7306
7307 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj = 0;
7309 wxKeyCode arg1 ;
7310 bool result;
7311 int val1 ;
7312 int ecode1 = 0 ;
7313 PyObject * obj0 = 0 ;
7314 char * kwnames[] = {
7315 (char *) "key", NULL
7316 };
7317
7318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7319 ecode1 = SWIG_AsVal_int(obj0, &val1);
7320 if (!SWIG_IsOK(ecode1)) {
7321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7322 }
7323 arg1 = static_cast< wxKeyCode >(val1);
7324 {
7325 if (!wxPyCheckForApp()) SWIG_fail;
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (bool)wxGetKeyState(arg1);
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 {
7332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7333 }
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7341 PyObject *resultobj = 0;
7342 wxMouseState *result = 0 ;
7343
7344 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 result = (wxMouseState *)new wxMouseState();
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7359 PyObject *resultobj = 0;
7360 wxMouseState *arg1 = (wxMouseState *) 0 ;
7361 void *argp1 = 0 ;
7362 int res1 = 0 ;
7363 PyObject *swig_obj[1] ;
7364
7365 if (!args) SWIG_fail;
7366 swig_obj[0] = args;
7367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7370 }
7371 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 delete arg1;
7375
7376 wxPyEndAllowThreads(__tstate);
7377 if (PyErr_Occurred()) SWIG_fail;
7378 }
7379 resultobj = SWIG_Py_Void();
7380 return resultobj;
7381 fail:
7382 return NULL;
7383 }
7384
7385
7386 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7387 PyObject *resultobj = 0;
7388 wxMouseState *arg1 = (wxMouseState *) 0 ;
7389 int result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 PyObject *swig_obj[1] ;
7393
7394 if (!args) SWIG_fail;
7395 swig_obj[0] = args;
7396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7399 }
7400 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 result = (int)(arg1)->GetX();
7404 wxPyEndAllowThreads(__tstate);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 resultobj = SWIG_From_int(static_cast< int >(result));
7408 return resultobj;
7409 fail:
7410 return NULL;
7411 }
7412
7413
7414 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7415 PyObject *resultobj = 0;
7416 wxMouseState *arg1 = (wxMouseState *) 0 ;
7417 int result;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 PyObject *swig_obj[1] ;
7421
7422 if (!args) SWIG_fail;
7423 swig_obj[0] = args;
7424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7425 if (!SWIG_IsOK(res1)) {
7426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7427 }
7428 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7429 {
7430 PyThreadState* __tstate = wxPyBeginAllowThreads();
7431 result = (int)(arg1)->GetY();
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 resultobj = SWIG_From_int(static_cast< int >(result));
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7443 PyObject *resultobj = 0;
7444 wxMouseState *arg1 = (wxMouseState *) 0 ;
7445 bool result;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 PyObject *swig_obj[1] ;
7449
7450 if (!args) SWIG_fail;
7451 swig_obj[0] = args;
7452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7453 if (!SWIG_IsOK(res1)) {
7454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7455 }
7456 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = (bool)(arg1)->LeftDown();
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 {
7464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7465 }
7466 return resultobj;
7467 fail:
7468 return NULL;
7469 }
7470
7471
7472 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7473 PyObject *resultobj = 0;
7474 wxMouseState *arg1 = (wxMouseState *) 0 ;
7475 bool result;
7476 void *argp1 = 0 ;
7477 int res1 = 0 ;
7478 PyObject *swig_obj[1] ;
7479
7480 if (!args) SWIG_fail;
7481 swig_obj[0] = args;
7482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7485 }
7486 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (bool)(arg1)->MiddleDown();
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 {
7494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495 }
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7503 PyObject *resultobj = 0;
7504 wxMouseState *arg1 = (wxMouseState *) 0 ;
7505 bool result;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 PyObject *swig_obj[1] ;
7509
7510 if (!args) SWIG_fail;
7511 swig_obj[0] = args;
7512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7513 if (!SWIG_IsOK(res1)) {
7514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7515 }
7516 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (bool)(arg1)->RightDown();
7520 wxPyEndAllowThreads(__tstate);
7521 if (PyErr_Occurred()) SWIG_fail;
7522 }
7523 {
7524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7525 }
7526 return resultobj;
7527 fail:
7528 return NULL;
7529 }
7530
7531
7532 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7533 PyObject *resultobj = 0;
7534 wxMouseState *arg1 = (wxMouseState *) 0 ;
7535 bool result;
7536 void *argp1 = 0 ;
7537 int res1 = 0 ;
7538 PyObject *swig_obj[1] ;
7539
7540 if (!args) SWIG_fail;
7541 swig_obj[0] = args;
7542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7543 if (!SWIG_IsOK(res1)) {
7544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7545 }
7546 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7547 {
7548 PyThreadState* __tstate = wxPyBeginAllowThreads();
7549 result = (bool)(arg1)->ControlDown();
7550 wxPyEndAllowThreads(__tstate);
7551 if (PyErr_Occurred()) SWIG_fail;
7552 }
7553 {
7554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7555 }
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7563 PyObject *resultobj = 0;
7564 wxMouseState *arg1 = (wxMouseState *) 0 ;
7565 bool result;
7566 void *argp1 = 0 ;
7567 int res1 = 0 ;
7568 PyObject *swig_obj[1] ;
7569
7570 if (!args) SWIG_fail;
7571 swig_obj[0] = args;
7572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7573 if (!SWIG_IsOK(res1)) {
7574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7575 }
7576 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7577 {
7578 PyThreadState* __tstate = wxPyBeginAllowThreads();
7579 result = (bool)(arg1)->ShiftDown();
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7585 }
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7593 PyObject *resultobj = 0;
7594 wxMouseState *arg1 = (wxMouseState *) 0 ;
7595 bool result;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 PyObject *swig_obj[1] ;
7599
7600 if (!args) SWIG_fail;
7601 swig_obj[0] = args;
7602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7603 if (!SWIG_IsOK(res1)) {
7604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7605 }
7606 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)(arg1)->AltDown();
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7623 PyObject *resultobj = 0;
7624 wxMouseState *arg1 = (wxMouseState *) 0 ;
7625 bool result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 PyObject *swig_obj[1] ;
7629
7630 if (!args) SWIG_fail;
7631 swig_obj[0] = args;
7632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7633 if (!SWIG_IsOK(res1)) {
7634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7635 }
7636 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 result = (bool)(arg1)->MetaDown();
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 {
7644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7645 }
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7653 PyObject *resultobj = 0;
7654 wxMouseState *arg1 = (wxMouseState *) 0 ;
7655 bool result;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 PyObject *swig_obj[1] ;
7659
7660 if (!args) SWIG_fail;
7661 swig_obj[0] = args;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7665 }
7666 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 result = (bool)(arg1)->CmdDown();
7670 wxPyEndAllowThreads(__tstate);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 {
7674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7675 }
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj = 0;
7684 wxMouseState *arg1 = (wxMouseState *) 0 ;
7685 int arg2 ;
7686 void *argp1 = 0 ;
7687 int res1 = 0 ;
7688 int val2 ;
7689 int ecode2 = 0 ;
7690 PyObject * obj0 = 0 ;
7691 PyObject * obj1 = 0 ;
7692 char * kwnames[] = {
7693 (char *) "self",(char *) "x", NULL
7694 };
7695
7696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7698 if (!SWIG_IsOK(res1)) {
7699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7700 }
7701 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7702 ecode2 = SWIG_AsVal_int(obj1, &val2);
7703 if (!SWIG_IsOK(ecode2)) {
7704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7705 }
7706 arg2 = static_cast< int >(val2);
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 (arg1)->SetX(arg2);
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 resultobj = SWIG_Py_Void();
7714 return resultobj;
7715 fail:
7716 return NULL;
7717 }
7718
7719
7720 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7721 PyObject *resultobj = 0;
7722 wxMouseState *arg1 = (wxMouseState *) 0 ;
7723 int arg2 ;
7724 void *argp1 = 0 ;
7725 int res1 = 0 ;
7726 int val2 ;
7727 int ecode2 = 0 ;
7728 PyObject * obj0 = 0 ;
7729 PyObject * obj1 = 0 ;
7730 char * kwnames[] = {
7731 (char *) "self",(char *) "y", NULL
7732 };
7733
7734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7736 if (!SWIG_IsOK(res1)) {
7737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7738 }
7739 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7740 ecode2 = SWIG_AsVal_int(obj1, &val2);
7741 if (!SWIG_IsOK(ecode2)) {
7742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7743 }
7744 arg2 = static_cast< int >(val2);
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 (arg1)->SetY(arg2);
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 resultobj = SWIG_Py_Void();
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7759 PyObject *resultobj = 0;
7760 wxMouseState *arg1 = (wxMouseState *) 0 ;
7761 bool arg2 ;
7762 void *argp1 = 0 ;
7763 int res1 = 0 ;
7764 bool val2 ;
7765 int ecode2 = 0 ;
7766 PyObject * obj0 = 0 ;
7767 PyObject * obj1 = 0 ;
7768 char * kwnames[] = {
7769 (char *) "self",(char *) "down", NULL
7770 };
7771
7772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7776 }
7777 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7781 }
7782 arg2 = static_cast< bool >(val2);
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 (arg1)->SetLeftDown(arg2);
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_Py_Void();
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7797 PyObject *resultobj = 0;
7798 wxMouseState *arg1 = (wxMouseState *) 0 ;
7799 bool arg2 ;
7800 void *argp1 = 0 ;
7801 int res1 = 0 ;
7802 bool val2 ;
7803 int ecode2 = 0 ;
7804 PyObject * obj0 = 0 ;
7805 PyObject * obj1 = 0 ;
7806 char * kwnames[] = {
7807 (char *) "self",(char *) "down", NULL
7808 };
7809
7810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7812 if (!SWIG_IsOK(res1)) {
7813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7814 }
7815 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7816 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7817 if (!SWIG_IsOK(ecode2)) {
7818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7819 }
7820 arg2 = static_cast< bool >(val2);
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 (arg1)->SetMiddleDown(arg2);
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 resultobj = SWIG_Py_Void();
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7835 PyObject *resultobj = 0;
7836 wxMouseState *arg1 = (wxMouseState *) 0 ;
7837 bool arg2 ;
7838 void *argp1 = 0 ;
7839 int res1 = 0 ;
7840 bool val2 ;
7841 int ecode2 = 0 ;
7842 PyObject * obj0 = 0 ;
7843 PyObject * obj1 = 0 ;
7844 char * kwnames[] = {
7845 (char *) "self",(char *) "down", NULL
7846 };
7847
7848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7850 if (!SWIG_IsOK(res1)) {
7851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7852 }
7853 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7854 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7855 if (!SWIG_IsOK(ecode2)) {
7856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7857 }
7858 arg2 = static_cast< bool >(val2);
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 (arg1)->SetRightDown(arg2);
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = SWIG_Py_Void();
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj = 0;
7874 wxMouseState *arg1 = (wxMouseState *) 0 ;
7875 bool arg2 ;
7876 void *argp1 = 0 ;
7877 int res1 = 0 ;
7878 bool val2 ;
7879 int ecode2 = 0 ;
7880 PyObject * obj0 = 0 ;
7881 PyObject * obj1 = 0 ;
7882 char * kwnames[] = {
7883 (char *) "self",(char *) "down", NULL
7884 };
7885
7886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7890 }
7891 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7893 if (!SWIG_IsOK(ecode2)) {
7894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7895 }
7896 arg2 = static_cast< bool >(val2);
7897 {
7898 PyThreadState* __tstate = wxPyBeginAllowThreads();
7899 (arg1)->SetControlDown(arg2);
7900 wxPyEndAllowThreads(__tstate);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 resultobj = SWIG_Py_Void();
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7911 PyObject *resultobj = 0;
7912 wxMouseState *arg1 = (wxMouseState *) 0 ;
7913 bool arg2 ;
7914 void *argp1 = 0 ;
7915 int res1 = 0 ;
7916 bool val2 ;
7917 int ecode2 = 0 ;
7918 PyObject * obj0 = 0 ;
7919 PyObject * obj1 = 0 ;
7920 char * kwnames[] = {
7921 (char *) "self",(char *) "down", NULL
7922 };
7923
7924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7926 if (!SWIG_IsOK(res1)) {
7927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7928 }
7929 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7931 if (!SWIG_IsOK(ecode2)) {
7932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7933 }
7934 arg2 = static_cast< bool >(val2);
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 (arg1)->SetShiftDown(arg2);
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = SWIG_Py_Void();
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj = 0;
7950 wxMouseState *arg1 = (wxMouseState *) 0 ;
7951 bool arg2 ;
7952 void *argp1 = 0 ;
7953 int res1 = 0 ;
7954 bool val2 ;
7955 int ecode2 = 0 ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char * kwnames[] = {
7959 (char *) "self",(char *) "down", NULL
7960 };
7961
7962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7964 if (!SWIG_IsOK(res1)) {
7965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7966 }
7967 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7969 if (!SWIG_IsOK(ecode2)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7971 }
7972 arg2 = static_cast< bool >(val2);
7973 {
7974 PyThreadState* __tstate = wxPyBeginAllowThreads();
7975 (arg1)->SetAltDown(arg2);
7976 wxPyEndAllowThreads(__tstate);
7977 if (PyErr_Occurred()) SWIG_fail;
7978 }
7979 resultobj = SWIG_Py_Void();
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj = 0;
7988 wxMouseState *arg1 = (wxMouseState *) 0 ;
7989 bool arg2 ;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 bool val2 ;
7993 int ecode2 = 0 ;
7994 PyObject * obj0 = 0 ;
7995 PyObject * obj1 = 0 ;
7996 char * kwnames[] = {
7997 (char *) "self",(char *) "down", NULL
7998 };
7999
8000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
8001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
8002 if (!SWIG_IsOK(res1)) {
8003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
8004 }
8005 arg1 = reinterpret_cast< wxMouseState * >(argp1);
8006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
8007 if (!SWIG_IsOK(ecode2)) {
8008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8009 }
8010 arg2 = static_cast< bool >(val2);
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 (arg1)->SetMetaDown(arg2);
8014 wxPyEndAllowThreads(__tstate);
8015 if (PyErr_Occurred()) SWIG_fail;
8016 }
8017 resultobj = SWIG_Py_Void();
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 PyObject *obj;
8026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8027 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8028 return SWIG_Py_Void();
8029 }
8030
8031 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8032 return SWIG_Python_InitShadowInstance(args);
8033 }
8034
8035 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8036 PyObject *resultobj = 0;
8037 wxMouseState result;
8038
8039 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8040 {
8041 PyThreadState* __tstate = wxPyBeginAllowThreads();
8042 result = wxGetMouseState();
8043 wxPyEndAllowThreads(__tstate);
8044 if (PyErr_Occurred()) SWIG_fail;
8045 }
8046 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055
8056 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8057 {
8058 if (!wxPyCheckForApp()) SWIG_fail;
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 wxWakeUpMainThread();
8061 wxPyEndAllowThreads(__tstate);
8062 if (PyErr_Occurred()) SWIG_fail;
8063 }
8064 resultobj = SWIG_Py_Void();
8065 return resultobj;
8066 fail:
8067 return NULL;
8068 }
8069
8070
8071 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8072 PyObject *resultobj = 0;
8073
8074 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8075 {
8076 if (!wxPyCheckForApp()) SWIG_fail;
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 wxMutexGuiEnter();
8079 wxPyEndAllowThreads(__tstate);
8080 if (PyErr_Occurred()) SWIG_fail;
8081 }
8082 resultobj = SWIG_Py_Void();
8083 return resultobj;
8084 fail:
8085 return NULL;
8086 }
8087
8088
8089 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8090 PyObject *resultobj = 0;
8091
8092 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8093 {
8094 if (!wxPyCheckForApp()) SWIG_fail;
8095 PyThreadState* __tstate = wxPyBeginAllowThreads();
8096 wxMutexGuiLeave();
8097 wxPyEndAllowThreads(__tstate);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 resultobj = SWIG_Py_Void();
8101 return resultobj;
8102 fail:
8103 return NULL;
8104 }
8105
8106
8107 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8108 PyObject *resultobj = 0;
8109 wxMutexGuiLocker *result = 0 ;
8110
8111 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8112 {
8113 if (!wxPyCheckForApp()) SWIG_fail;
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8127 PyObject *resultobj = 0;
8128 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8129 void *argp1 = 0 ;
8130 int res1 = 0 ;
8131 PyObject *swig_obj[1] ;
8132
8133 if (!args) SWIG_fail;
8134 swig_obj[0] = args;
8135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8136 if (!SWIG_IsOK(res1)) {
8137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8138 }
8139 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 delete arg1;
8143
8144 wxPyEndAllowThreads(__tstate);
8145 if (PyErr_Occurred()) SWIG_fail;
8146 }
8147 resultobj = SWIG_Py_Void();
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8155 PyObject *obj;
8156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8157 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8158 return SWIG_Py_Void();
8159 }
8160
8161 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8162 return SWIG_Python_InitShadowInstance(args);
8163 }
8164
8165 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8166 PyObject *resultobj = 0;
8167 bool result;
8168
8169 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 result = (bool)wxThread_IsMain();
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8178 }
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj = 0;
8187 wxString *arg1 = 0 ;
8188 wxToolTip *result = 0 ;
8189 bool temp1 = false ;
8190 PyObject * obj0 = 0 ;
8191 char * kwnames[] = {
8192 (char *) "tip", NULL
8193 };
8194
8195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8196 {
8197 arg1 = wxString_in_helper(obj0);
8198 if (arg1 == NULL) SWIG_fail;
8199 temp1 = true;
8200 }
8201 {
8202 if (!wxPyCheckForApp()) SWIG_fail;
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8209 {
8210 if (temp1)
8211 delete arg1;
8212 }
8213 return resultobj;
8214 fail:
8215 {
8216 if (temp1)
8217 delete arg1;
8218 }
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8224 PyObject *resultobj = 0;
8225 wxToolTip *arg1 = (wxToolTip *) 0 ;
8226 void *argp1 = 0 ;
8227 int res1 = 0 ;
8228 PyObject *swig_obj[1] ;
8229
8230 if (!args) SWIG_fail;
8231 swig_obj[0] = args;
8232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8233 if (!SWIG_IsOK(res1)) {
8234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8235 }
8236 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8237 {
8238 PyThreadState* __tstate = wxPyBeginAllowThreads();
8239 delete arg1;
8240
8241 wxPyEndAllowThreads(__tstate);
8242 if (PyErr_Occurred()) SWIG_fail;
8243 }
8244 resultobj = SWIG_Py_Void();
8245 return resultobj;
8246 fail:
8247 return NULL;
8248 }
8249
8250
8251 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8252 PyObject *resultobj = 0;
8253 wxToolTip *arg1 = (wxToolTip *) 0 ;
8254 wxString *arg2 = 0 ;
8255 void *argp1 = 0 ;
8256 int res1 = 0 ;
8257 bool temp2 = false ;
8258 PyObject * obj0 = 0 ;
8259 PyObject * obj1 = 0 ;
8260 char * kwnames[] = {
8261 (char *) "self",(char *) "tip", NULL
8262 };
8263
8264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8266 if (!SWIG_IsOK(res1)) {
8267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8268 }
8269 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8270 {
8271 arg2 = wxString_in_helper(obj1);
8272 if (arg2 == NULL) SWIG_fail;
8273 temp2 = true;
8274 }
8275 {
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 (arg1)->SetTip((wxString const &)*arg2);
8278 wxPyEndAllowThreads(__tstate);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 resultobj = SWIG_Py_Void();
8282 {
8283 if (temp2)
8284 delete arg2;
8285 }
8286 return resultobj;
8287 fail:
8288 {
8289 if (temp2)
8290 delete arg2;
8291 }
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8297 PyObject *resultobj = 0;
8298 wxToolTip *arg1 = (wxToolTip *) 0 ;
8299 wxString result;
8300 void *argp1 = 0 ;
8301 int res1 = 0 ;
8302 PyObject *swig_obj[1] ;
8303
8304 if (!args) SWIG_fail;
8305 swig_obj[0] = args;
8306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8307 if (!SWIG_IsOK(res1)) {
8308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8309 }
8310 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (arg1)->GetTip();
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 {
8318 #if wxUSE_UNICODE
8319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8320 #else
8321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8322 #endif
8323 }
8324 return resultobj;
8325 fail:
8326 return NULL;
8327 }
8328
8329
8330 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8331 PyObject *resultobj = 0;
8332 wxToolTip *arg1 = (wxToolTip *) 0 ;
8333 wxWindow *result = 0 ;
8334 void *argp1 = 0 ;
8335 int res1 = 0 ;
8336 PyObject *swig_obj[1] ;
8337
8338 if (!args) SWIG_fail;
8339 swig_obj[0] = args;
8340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8343 }
8344 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8345 {
8346 PyThreadState* __tstate = wxPyBeginAllowThreads();
8347 result = (wxWindow *)(arg1)->GetWindow();
8348 wxPyEndAllowThreads(__tstate);
8349 if (PyErr_Occurred()) SWIG_fail;
8350 }
8351 {
8352 resultobj = wxPyMake_wxObject(result, 0);
8353 }
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 bool arg1 ;
8363 bool val1 ;
8364 int ecode1 = 0 ;
8365 PyObject * obj0 = 0 ;
8366 char * kwnames[] = {
8367 (char *) "flag", NULL
8368 };
8369
8370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8371 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8372 if (!SWIG_IsOK(ecode1)) {
8373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8374 }
8375 arg1 = static_cast< bool >(val1);
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 wxToolTip::Enable(arg1);
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 resultobj = SWIG_Py_Void();
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj = 0;
8391 long arg1 ;
8392 long val1 ;
8393 int ecode1 = 0 ;
8394 PyObject * obj0 = 0 ;
8395 char * kwnames[] = {
8396 (char *) "milliseconds", NULL
8397 };
8398
8399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8400 ecode1 = SWIG_AsVal_long(obj0, &val1);
8401 if (!SWIG_IsOK(ecode1)) {
8402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8403 }
8404 arg1 = static_cast< long >(val1);
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 wxToolTip::SetDelay(arg1);
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_Py_Void();
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8419 PyObject *obj;
8420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8421 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8422 return SWIG_Py_Void();
8423 }
8424
8425 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8426 return SWIG_Python_InitShadowInstance(args);
8427 }
8428
8429 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8430 PyObject *resultobj = 0;
8431 wxWindow *arg1 = (wxWindow *) 0 ;
8432 wxSize *arg2 = 0 ;
8433 wxCaret *result = 0 ;
8434 void *argp1 = 0 ;
8435 int res1 = 0 ;
8436 wxSize temp2 ;
8437 PyObject * obj0 = 0 ;
8438 PyObject * obj1 = 0 ;
8439 char * kwnames[] = {
8440 (char *) "window",(char *) "size", NULL
8441 };
8442
8443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8445 if (!SWIG_IsOK(res1)) {
8446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8447 }
8448 arg1 = reinterpret_cast< wxWindow * >(argp1);
8449 {
8450 arg2 = &temp2;
8451 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8452 }
8453 {
8454 if (!wxPyCheckForApp()) SWIG_fail;
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8457 wxPyEndAllowThreads(__tstate);
8458 if (PyErr_Occurred()) SWIG_fail;
8459 }
8460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8468 PyObject *resultobj = 0;
8469 wxCaret *arg1 = (wxCaret *) 0 ;
8470 void *argp1 = 0 ;
8471 int res1 = 0 ;
8472 PyObject *swig_obj[1] ;
8473
8474 if (!args) SWIG_fail;
8475 swig_obj[0] = args;
8476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8477 if (!SWIG_IsOK(res1)) {
8478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8479 }
8480 arg1 = reinterpret_cast< wxCaret * >(argp1);
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 delete arg1;
8484
8485 wxPyEndAllowThreads(__tstate);
8486 if (PyErr_Occurred()) SWIG_fail;
8487 }
8488 resultobj = SWIG_Py_Void();
8489 return resultobj;
8490 fail:
8491 return NULL;
8492 }
8493
8494
8495 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8496 PyObject *resultobj = 0;
8497 wxCaret *arg1 = (wxCaret *) 0 ;
8498 void *argp1 = 0 ;
8499 int res1 = 0 ;
8500 PyObject *swig_obj[1] ;
8501
8502 if (!args) SWIG_fail;
8503 swig_obj[0] = args;
8504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8505 if (!SWIG_IsOK(res1)) {
8506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8507 }
8508 arg1 = reinterpret_cast< wxCaret * >(argp1);
8509 {
8510 PyThreadState* __tstate = wxPyBeginAllowThreads();
8511 wxCaret_Destroy(arg1);
8512 wxPyEndAllowThreads(__tstate);
8513 if (PyErr_Occurred()) SWIG_fail;
8514 }
8515 resultobj = SWIG_Py_Void();
8516 return resultobj;
8517 fail:
8518 return NULL;
8519 }
8520
8521
8522 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8523 PyObject *resultobj = 0;
8524 wxCaret *arg1 = (wxCaret *) 0 ;
8525 bool result;
8526 void *argp1 = 0 ;
8527 int res1 = 0 ;
8528 PyObject *swig_obj[1] ;
8529
8530 if (!args) SWIG_fail;
8531 swig_obj[0] = args;
8532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8533 if (!SWIG_IsOK(res1)) {
8534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8535 }
8536 arg1 = reinterpret_cast< wxCaret * >(argp1);
8537 {
8538 PyThreadState* __tstate = wxPyBeginAllowThreads();
8539 result = (bool)(arg1)->IsOk();
8540 wxPyEndAllowThreads(__tstate);
8541 if (PyErr_Occurred()) SWIG_fail;
8542 }
8543 {
8544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8545 }
8546 return resultobj;
8547 fail:
8548 return NULL;
8549 }
8550
8551
8552 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8553 PyObject *resultobj = 0;
8554 wxCaret *arg1 = (wxCaret *) 0 ;
8555 bool result;
8556 void *argp1 = 0 ;
8557 int res1 = 0 ;
8558 PyObject *swig_obj[1] ;
8559
8560 if (!args) SWIG_fail;
8561 swig_obj[0] = args;
8562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8565 }
8566 arg1 = reinterpret_cast< wxCaret * >(argp1);
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 result = (bool)(arg1)->IsVisible();
8570 wxPyEndAllowThreads(__tstate);
8571 if (PyErr_Occurred()) SWIG_fail;
8572 }
8573 {
8574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8575 }
8576 return resultobj;
8577 fail:
8578 return NULL;
8579 }
8580
8581
8582 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8583 PyObject *resultobj = 0;
8584 wxCaret *arg1 = (wxCaret *) 0 ;
8585 wxPoint result;
8586 void *argp1 = 0 ;
8587 int res1 = 0 ;
8588 PyObject *swig_obj[1] ;
8589
8590 if (!args) SWIG_fail;
8591 swig_obj[0] = args;
8592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8595 }
8596 arg1 = reinterpret_cast< wxCaret * >(argp1);
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 result = (arg1)->GetPosition();
8600 wxPyEndAllowThreads(__tstate);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8611 PyObject *resultobj = 0;
8612 wxCaret *arg1 = (wxCaret *) 0 ;
8613 int *arg2 = (int *) 0 ;
8614 int *arg3 = (int *) 0 ;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 int temp2 ;
8618 int res2 = SWIG_TMPOBJ ;
8619 int temp3 ;
8620 int res3 = SWIG_TMPOBJ ;
8621 PyObject *swig_obj[1] ;
8622
8623 arg2 = &temp2;
8624 arg3 = &temp3;
8625 if (!args) SWIG_fail;
8626 swig_obj[0] = args;
8627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8630 }
8631 arg1 = reinterpret_cast< wxCaret * >(argp1);
8632 {
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 (arg1)->GetPosition(arg2,arg3);
8635 wxPyEndAllowThreads(__tstate);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 resultobj = SWIG_Py_Void();
8639 if (SWIG_IsTmpObj(res2)) {
8640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8641 } else {
8642 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8644 }
8645 if (SWIG_IsTmpObj(res3)) {
8646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8647 } else {
8648 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8650 }
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8658 PyObject *resultobj = 0;
8659 wxCaret *arg1 = (wxCaret *) 0 ;
8660 wxSize result;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 PyObject *swig_obj[1] ;
8664
8665 if (!args) SWIG_fail;
8666 swig_obj[0] = args;
8667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8668 if (!SWIG_IsOK(res1)) {
8669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8670 }
8671 arg1 = reinterpret_cast< wxCaret * >(argp1);
8672 {
8673 PyThreadState* __tstate = wxPyBeginAllowThreads();
8674 result = (arg1)->GetSize();
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8679 return resultobj;
8680 fail:
8681 return NULL;
8682 }
8683
8684
8685 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8686 PyObject *resultobj = 0;
8687 wxCaret *arg1 = (wxCaret *) 0 ;
8688 int *arg2 = (int *) 0 ;
8689 int *arg3 = (int *) 0 ;
8690 void *argp1 = 0 ;
8691 int res1 = 0 ;
8692 int temp2 ;
8693 int res2 = SWIG_TMPOBJ ;
8694 int temp3 ;
8695 int res3 = SWIG_TMPOBJ ;
8696 PyObject *swig_obj[1] ;
8697
8698 arg2 = &temp2;
8699 arg3 = &temp3;
8700 if (!args) SWIG_fail;
8701 swig_obj[0] = args;
8702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8703 if (!SWIG_IsOK(res1)) {
8704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8705 }
8706 arg1 = reinterpret_cast< wxCaret * >(argp1);
8707 {
8708 PyThreadState* __tstate = wxPyBeginAllowThreads();
8709 (arg1)->GetSize(arg2,arg3);
8710 wxPyEndAllowThreads(__tstate);
8711 if (PyErr_Occurred()) SWIG_fail;
8712 }
8713 resultobj = SWIG_Py_Void();
8714 if (SWIG_IsTmpObj(res2)) {
8715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8716 } else {
8717 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8719 }
8720 if (SWIG_IsTmpObj(res3)) {
8721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8722 } else {
8723 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8725 }
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8733 PyObject *resultobj = 0;
8734 wxCaret *arg1 = (wxCaret *) 0 ;
8735 wxWindow *result = 0 ;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 PyObject *swig_obj[1] ;
8739
8740 if (!args) SWIG_fail;
8741 swig_obj[0] = args;
8742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8743 if (!SWIG_IsOK(res1)) {
8744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8745 }
8746 arg1 = reinterpret_cast< wxCaret * >(argp1);
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 result = (wxWindow *)(arg1)->GetWindow();
8750 wxPyEndAllowThreads(__tstate);
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 {
8754 resultobj = wxPyMake_wxObject(result, 0);
8755 }
8756 return resultobj;
8757 fail:
8758 return NULL;
8759 }
8760
8761
8762 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8763 PyObject *resultobj = 0;
8764 wxCaret *arg1 = (wxCaret *) 0 ;
8765 int arg2 ;
8766 int arg3 ;
8767 void *argp1 = 0 ;
8768 int res1 = 0 ;
8769 int val2 ;
8770 int ecode2 = 0 ;
8771 int val3 ;
8772 int ecode3 = 0 ;
8773 PyObject * obj0 = 0 ;
8774 PyObject * obj1 = 0 ;
8775 PyObject * obj2 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "x",(char *) "y", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8784 }
8785 arg1 = reinterpret_cast< wxCaret * >(argp1);
8786 ecode2 = SWIG_AsVal_int(obj1, &val2);
8787 if (!SWIG_IsOK(ecode2)) {
8788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8789 }
8790 arg2 = static_cast< int >(val2);
8791 ecode3 = SWIG_AsVal_int(obj2, &val3);
8792 if (!SWIG_IsOK(ecode3)) {
8793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8794 }
8795 arg3 = static_cast< int >(val3);
8796 {
8797 PyThreadState* __tstate = wxPyBeginAllowThreads();
8798 (arg1)->Move(arg2,arg3);
8799 wxPyEndAllowThreads(__tstate);
8800 if (PyErr_Occurred()) SWIG_fail;
8801 }
8802 resultobj = SWIG_Py_Void();
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
8809 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8810 PyObject *resultobj = 0;
8811 wxCaret *arg1 = (wxCaret *) 0 ;
8812 wxPoint *arg2 = 0 ;
8813 void *argp1 = 0 ;
8814 int res1 = 0 ;
8815 wxPoint temp2 ;
8816 PyObject * obj0 = 0 ;
8817 PyObject * obj1 = 0 ;
8818 char * kwnames[] = {
8819 (char *) "self",(char *) "pt", NULL
8820 };
8821
8822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8824 if (!SWIG_IsOK(res1)) {
8825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8826 }
8827 arg1 = reinterpret_cast< wxCaret * >(argp1);
8828 {
8829 arg2 = &temp2;
8830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8831 }
8832 {
8833 PyThreadState* __tstate = wxPyBeginAllowThreads();
8834 (arg1)->Move((wxPoint const &)*arg2);
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 resultobj = SWIG_Py_Void();
8839 return resultobj;
8840 fail:
8841 return NULL;
8842 }
8843
8844
8845 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8846 PyObject *resultobj = 0;
8847 wxCaret *arg1 = (wxCaret *) 0 ;
8848 int arg2 ;
8849 int arg3 ;
8850 void *argp1 = 0 ;
8851 int res1 = 0 ;
8852 int val2 ;
8853 int ecode2 = 0 ;
8854 int val3 ;
8855 int ecode3 = 0 ;
8856 PyObject * obj0 = 0 ;
8857 PyObject * obj1 = 0 ;
8858 PyObject * obj2 = 0 ;
8859 char * kwnames[] = {
8860 (char *) "self",(char *) "width",(char *) "height", NULL
8861 };
8862
8863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8867 }
8868 arg1 = reinterpret_cast< wxCaret * >(argp1);
8869 ecode2 = SWIG_AsVal_int(obj1, &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8872 }
8873 arg2 = static_cast< int >(val2);
8874 ecode3 = SWIG_AsVal_int(obj2, &val3);
8875 if (!SWIG_IsOK(ecode3)) {
8876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8877 }
8878 arg3 = static_cast< int >(val3);
8879 {
8880 PyThreadState* __tstate = wxPyBeginAllowThreads();
8881 (arg1)->SetSize(arg2,arg3);
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_Py_Void();
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj = 0;
8894 wxCaret *arg1 = (wxCaret *) 0 ;
8895 wxSize *arg2 = 0 ;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 wxSize temp2 ;
8899 PyObject * obj0 = 0 ;
8900 PyObject * obj1 = 0 ;
8901 char * kwnames[] = {
8902 (char *) "self",(char *) "size", NULL
8903 };
8904
8905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8907 if (!SWIG_IsOK(res1)) {
8908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8909 }
8910 arg1 = reinterpret_cast< wxCaret * >(argp1);
8911 {
8912 arg2 = &temp2;
8913 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8914 }
8915 {
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 (arg1)->SetSize((wxSize const &)*arg2);
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 resultobj = SWIG_Py_Void();
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj = 0;
8930 wxCaret *arg1 = (wxCaret *) 0 ;
8931 int arg2 = (int) true ;
8932 void *argp1 = 0 ;
8933 int res1 = 0 ;
8934 int val2 ;
8935 int ecode2 = 0 ;
8936 PyObject * obj0 = 0 ;
8937 PyObject * obj1 = 0 ;
8938 char * kwnames[] = {
8939 (char *) "self",(char *) "show", NULL
8940 };
8941
8942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8944 if (!SWIG_IsOK(res1)) {
8945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8946 }
8947 arg1 = reinterpret_cast< wxCaret * >(argp1);
8948 if (obj1) {
8949 ecode2 = SWIG_AsVal_int(obj1, &val2);
8950 if (!SWIG_IsOK(ecode2)) {
8951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8952 }
8953 arg2 = static_cast< int >(val2);
8954 }
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 (arg1)->Show(arg2);
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 resultobj = SWIG_Py_Void();
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8969 PyObject *resultobj = 0;
8970 wxCaret *arg1 = (wxCaret *) 0 ;
8971 void *argp1 = 0 ;
8972 int res1 = 0 ;
8973 PyObject *swig_obj[1] ;
8974
8975 if (!args) SWIG_fail;
8976 swig_obj[0] = args;
8977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8978 if (!SWIG_IsOK(res1)) {
8979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8980 }
8981 arg1 = reinterpret_cast< wxCaret * >(argp1);
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 (arg1)->Hide();
8985 wxPyEndAllowThreads(__tstate);
8986 if (PyErr_Occurred()) SWIG_fail;
8987 }
8988 resultobj = SWIG_Py_Void();
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 int result;
8998
8999 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
9000 {
9001 PyThreadState* __tstate = wxPyBeginAllowThreads();
9002 result = (int)wxCaret::GetBlinkTime();
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 resultobj = SWIG_From_int(static_cast< int >(result));
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj = 0;
9015 int arg1 ;
9016 int val1 ;
9017 int ecode1 = 0 ;
9018 PyObject * obj0 = 0 ;
9019 char * kwnames[] = {
9020 (char *) "milliseconds", NULL
9021 };
9022
9023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9024 ecode1 = SWIG_AsVal_int(obj0, &val1);
9025 if (!SWIG_IsOK(ecode1)) {
9026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9027 }
9028 arg1 = static_cast< int >(val1);
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 wxCaret::SetBlinkTime(arg1);
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 resultobj = SWIG_Py_Void();
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9043 PyObject *obj;
9044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9045 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9046 return SWIG_Py_Void();
9047 }
9048
9049 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9050 return SWIG_Python_InitShadowInstance(args);
9051 }
9052
9053 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9054 PyObject *resultobj = 0;
9055 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9056 wxBusyCursor *result = 0 ;
9057 void *argp1 = 0 ;
9058 int res1 = 0 ;
9059 PyObject * obj0 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "cursor", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9065 if (obj0) {
9066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9067 if (!SWIG_IsOK(res1)) {
9068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9069 }
9070 arg1 = reinterpret_cast< wxCursor * >(argp1);
9071 }
9072 {
9073 if (!wxPyCheckForApp()) SWIG_fail;
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9076 wxPyEndAllowThreads(__tstate);
9077 if (PyErr_Occurred()) SWIG_fail;
9078 }
9079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9087 PyObject *resultobj = 0;
9088 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9089 void *argp1 = 0 ;
9090 int res1 = 0 ;
9091 PyObject *swig_obj[1] ;
9092
9093 if (!args) SWIG_fail;
9094 swig_obj[0] = args;
9095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9096 if (!SWIG_IsOK(res1)) {
9097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9098 }
9099 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 delete arg1;
9103
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_Py_Void();
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 PyObject *obj;
9116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9117 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9118 return SWIG_Py_Void();
9119 }
9120
9121 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 return SWIG_Python_InitShadowInstance(args);
9123 }
9124
9125 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj = 0;
9127 wxWindow *arg1 = (wxWindow *) NULL ;
9128 wxWindowDisabler *result = 0 ;
9129 void *argp1 = 0 ;
9130 int res1 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 char * kwnames[] = {
9133 (char *) "winToSkip", NULL
9134 };
9135
9136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9137 if (obj0) {
9138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9139 if (!SWIG_IsOK(res1)) {
9140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9141 }
9142 arg1 = reinterpret_cast< wxWindow * >(argp1);
9143 }
9144 {
9145 if (!wxPyCheckForApp()) SWIG_fail;
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9159 PyObject *resultobj = 0;
9160 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9161 void *argp1 = 0 ;
9162 int res1 = 0 ;
9163 PyObject *swig_obj[1] ;
9164
9165 if (!args) SWIG_fail;
9166 swig_obj[0] = args;
9167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9168 if (!SWIG_IsOK(res1)) {
9169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9170 }
9171 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 delete arg1;
9175
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 resultobj = SWIG_Py_Void();
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9187 PyObject *obj;
9188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9189 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9190 return SWIG_Py_Void();
9191 }
9192
9193 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9194 return SWIG_Python_InitShadowInstance(args);
9195 }
9196
9197 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj = 0;
9199 wxString *arg1 = 0 ;
9200 wxBusyInfo *result = 0 ;
9201 bool temp1 = false ;
9202 PyObject * obj0 = 0 ;
9203 char * kwnames[] = {
9204 (char *) "message", NULL
9205 };
9206
9207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9208 {
9209 arg1 = wxString_in_helper(obj0);
9210 if (arg1 == NULL) SWIG_fail;
9211 temp1 = true;
9212 }
9213 {
9214 if (!wxPyCheckForApp()) SWIG_fail;
9215 PyThreadState* __tstate = wxPyBeginAllowThreads();
9216 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9217 wxPyEndAllowThreads(__tstate);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9221 {
9222 if (temp1)
9223 delete arg1;
9224 }
9225 return resultobj;
9226 fail:
9227 {
9228 if (temp1)
9229 delete arg1;
9230 }
9231 return NULL;
9232 }
9233
9234
9235 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9236 PyObject *resultobj = 0;
9237 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9238 void *argp1 = 0 ;
9239 int res1 = 0 ;
9240 PyObject *swig_obj[1] ;
9241
9242 if (!args) SWIG_fail;
9243 swig_obj[0] = args;
9244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9245 if (!SWIG_IsOK(res1)) {
9246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9247 }
9248 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9249 {
9250 PyThreadState* __tstate = wxPyBeginAllowThreads();
9251 delete arg1;
9252
9253 wxPyEndAllowThreads(__tstate);
9254 if (PyErr_Occurred()) SWIG_fail;
9255 }
9256 resultobj = SWIG_Py_Void();
9257 return resultobj;
9258 fail:
9259 return NULL;
9260 }
9261
9262
9263 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9264 PyObject *obj;
9265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9266 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9267 return SWIG_Py_Void();
9268 }
9269
9270 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9271 return SWIG_Python_InitShadowInstance(args);
9272 }
9273
9274 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 PyObject *resultobj = 0;
9276 wxStopWatch *result = 0 ;
9277
9278 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9279 {
9280 PyThreadState* __tstate = wxPyBeginAllowThreads();
9281 result = (wxStopWatch *)new wxStopWatch();
9282 wxPyEndAllowThreads(__tstate);
9283 if (PyErr_Occurred()) SWIG_fail;
9284 }
9285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9286 return resultobj;
9287 fail:
9288 return NULL;
9289 }
9290
9291
9292 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9293 PyObject *resultobj = 0;
9294 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9295 void *argp1 = 0 ;
9296 int res1 = 0 ;
9297 PyObject *swig_obj[1] ;
9298
9299 if (!args) SWIG_fail;
9300 swig_obj[0] = args;
9301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9302 if (!SWIG_IsOK(res1)) {
9303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9304 }
9305 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9306 {
9307 PyThreadState* __tstate = wxPyBeginAllowThreads();
9308 delete arg1;
9309
9310 wxPyEndAllowThreads(__tstate);
9311 if (PyErr_Occurred()) SWIG_fail;
9312 }
9313 resultobj = SWIG_Py_Void();
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9321 PyObject *resultobj = 0;
9322 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9323 long arg2 = (long) 0 ;
9324 void *argp1 = 0 ;
9325 int res1 = 0 ;
9326 long val2 ;
9327 int ecode2 = 0 ;
9328 PyObject * obj0 = 0 ;
9329 PyObject * obj1 = 0 ;
9330 char * kwnames[] = {
9331 (char *) "self",(char *) "t0", NULL
9332 };
9333
9334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9336 if (!SWIG_IsOK(res1)) {
9337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9338 }
9339 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9340 if (obj1) {
9341 ecode2 = SWIG_AsVal_long(obj1, &val2);
9342 if (!SWIG_IsOK(ecode2)) {
9343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9344 }
9345 arg2 = static_cast< long >(val2);
9346 }
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 (arg1)->Start(arg2);
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_Py_Void();
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9363 void *argp1 = 0 ;
9364 int res1 = 0 ;
9365 PyObject *swig_obj[1] ;
9366
9367 if (!args) SWIG_fail;
9368 swig_obj[0] = args;
9369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9370 if (!SWIG_IsOK(res1)) {
9371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9372 }
9373 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9374 {
9375 PyThreadState* __tstate = wxPyBeginAllowThreads();
9376 (arg1)->Pause();
9377 wxPyEndAllowThreads(__tstate);
9378 if (PyErr_Occurred()) SWIG_fail;
9379 }
9380 resultobj = SWIG_Py_Void();
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9388 PyObject *resultobj = 0;
9389 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9390 void *argp1 = 0 ;
9391 int res1 = 0 ;
9392 PyObject *swig_obj[1] ;
9393
9394 if (!args) SWIG_fail;
9395 swig_obj[0] = args;
9396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9397 if (!SWIG_IsOK(res1)) {
9398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9399 }
9400 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 (arg1)->Resume();
9404 wxPyEndAllowThreads(__tstate);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 resultobj = SWIG_Py_Void();
9408 return resultobj;
9409 fail:
9410 return NULL;
9411 }
9412
9413
9414 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9415 PyObject *resultobj = 0;
9416 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9417 long result;
9418 void *argp1 = 0 ;
9419 int res1 = 0 ;
9420 PyObject *swig_obj[1] ;
9421
9422 if (!args) SWIG_fail;
9423 swig_obj[0] = args;
9424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9425 if (!SWIG_IsOK(res1)) {
9426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9427 }
9428 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9429 {
9430 PyThreadState* __tstate = wxPyBeginAllowThreads();
9431 result = (long)((wxStopWatch const *)arg1)->Time();
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 resultobj = SWIG_From_long(static_cast< long >(result));
9436 return resultobj;
9437 fail:
9438 return NULL;
9439 }
9440
9441
9442 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9443 PyObject *obj;
9444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9445 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9446 return SWIG_Py_Void();
9447 }
9448
9449 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9450 return SWIG_Python_InitShadowInstance(args);
9451 }
9452
9453 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj = 0;
9455 int arg1 = (int) 9 ;
9456 int arg2 = (int) wxID_FILE1 ;
9457 wxFileHistory *result = 0 ;
9458 int val1 ;
9459 int ecode1 = 0 ;
9460 int val2 ;
9461 int ecode2 = 0 ;
9462 PyObject * obj0 = 0 ;
9463 PyObject * obj1 = 0 ;
9464 char * kwnames[] = {
9465 (char *) "maxFiles",(char *) "idBase", NULL
9466 };
9467
9468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9469 if (obj0) {
9470 ecode1 = SWIG_AsVal_int(obj0, &val1);
9471 if (!SWIG_IsOK(ecode1)) {
9472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9473 }
9474 arg1 = static_cast< int >(val1);
9475 }
9476 if (obj1) {
9477 ecode2 = SWIG_AsVal_int(obj1, &val2);
9478 if (!SWIG_IsOK(ecode2)) {
9479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9480 }
9481 arg2 = static_cast< int >(val2);
9482 }
9483 {
9484 PyThreadState* __tstate = wxPyBeginAllowThreads();
9485 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9486 wxPyEndAllowThreads(__tstate);
9487 if (PyErr_Occurred()) SWIG_fail;
9488 }
9489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9490 return resultobj;
9491 fail:
9492 return NULL;
9493 }
9494
9495
9496 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9497 PyObject *resultobj = 0;
9498 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9499 void *argp1 = 0 ;
9500 int res1 = 0 ;
9501 PyObject *swig_obj[1] ;
9502
9503 if (!args) SWIG_fail;
9504 swig_obj[0] = args;
9505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9506 if (!SWIG_IsOK(res1)) {
9507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9508 }
9509 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 delete arg1;
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 resultobj = SWIG_Py_Void();
9518 return resultobj;
9519 fail:
9520 return NULL;
9521 }
9522
9523
9524 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9525 PyObject *resultobj = 0;
9526 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9527 wxString *arg2 = 0 ;
9528 void *argp1 = 0 ;
9529 int res1 = 0 ;
9530 bool temp2 = false ;
9531 PyObject * obj0 = 0 ;
9532 PyObject * obj1 = 0 ;
9533 char * kwnames[] = {
9534 (char *) "self",(char *) "file", NULL
9535 };
9536
9537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9541 }
9542 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9543 {
9544 arg2 = wxString_in_helper(obj1);
9545 if (arg2 == NULL) SWIG_fail;
9546 temp2 = true;
9547 }
9548 {
9549 PyThreadState* __tstate = wxPyBeginAllowThreads();
9550 (arg1)->AddFileToHistory((wxString const &)*arg2);
9551 wxPyEndAllowThreads(__tstate);
9552 if (PyErr_Occurred()) SWIG_fail;
9553 }
9554 resultobj = SWIG_Py_Void();
9555 {
9556 if (temp2)
9557 delete arg2;
9558 }
9559 return resultobj;
9560 fail:
9561 {
9562 if (temp2)
9563 delete arg2;
9564 }
9565 return NULL;
9566 }
9567
9568
9569 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9570 PyObject *resultobj = 0;
9571 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9572 int arg2 ;
9573 void *argp1 = 0 ;
9574 int res1 = 0 ;
9575 int val2 ;
9576 int ecode2 = 0 ;
9577 PyObject * obj0 = 0 ;
9578 PyObject * obj1 = 0 ;
9579 char * kwnames[] = {
9580 (char *) "self",(char *) "i", NULL
9581 };
9582
9583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9585 if (!SWIG_IsOK(res1)) {
9586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9587 }
9588 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9589 ecode2 = SWIG_AsVal_int(obj1, &val2);
9590 if (!SWIG_IsOK(ecode2)) {
9591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9592 }
9593 arg2 = static_cast< int >(val2);
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 (arg1)->RemoveFileFromHistory(arg2);
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_Py_Void();
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *resultobj = 0;
9609 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9610 int result;
9611 void *argp1 = 0 ;
9612 int res1 = 0 ;
9613 PyObject *swig_obj[1] ;
9614
9615 if (!args) SWIG_fail;
9616 swig_obj[0] = args;
9617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9618 if (!SWIG_IsOK(res1)) {
9619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9620 }
9621 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9622 {
9623 PyThreadState* __tstate = wxPyBeginAllowThreads();
9624 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 resultobj = SWIG_From_int(static_cast< int >(result));
9629 return resultobj;
9630 fail:
9631 return NULL;
9632 }
9633
9634
9635 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj = 0;
9637 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9638 wxMenu *arg2 = (wxMenu *) 0 ;
9639 void *argp1 = 0 ;
9640 int res1 = 0 ;
9641 void *argp2 = 0 ;
9642 int res2 = 0 ;
9643 PyObject * obj0 = 0 ;
9644 PyObject * obj1 = 0 ;
9645 char * kwnames[] = {
9646 (char *) "self",(char *) "menu", NULL
9647 };
9648
9649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9651 if (!SWIG_IsOK(res1)) {
9652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9653 }
9654 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9656 if (!SWIG_IsOK(res2)) {
9657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9658 }
9659 arg2 = reinterpret_cast< wxMenu * >(argp2);
9660 {
9661 PyThreadState* __tstate = wxPyBeginAllowThreads();
9662 (arg1)->UseMenu(arg2);
9663 wxPyEndAllowThreads(__tstate);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_Py_Void();
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj = 0;
9675 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9676 wxMenu *arg2 = (wxMenu *) 0 ;
9677 void *argp1 = 0 ;
9678 int res1 = 0 ;
9679 void *argp2 = 0 ;
9680 int res2 = 0 ;
9681 PyObject * obj0 = 0 ;
9682 PyObject * obj1 = 0 ;
9683 char * kwnames[] = {
9684 (char *) "self",(char *) "menu", NULL
9685 };
9686
9687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9689 if (!SWIG_IsOK(res1)) {
9690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9691 }
9692 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9693 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9694 if (!SWIG_IsOK(res2)) {
9695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9696 }
9697 arg2 = reinterpret_cast< wxMenu * >(argp2);
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 (arg1)->RemoveMenu(arg2);
9701 wxPyEndAllowThreads(__tstate);
9702 if (PyErr_Occurred()) SWIG_fail;
9703 }
9704 resultobj = SWIG_Py_Void();
9705 return resultobj;
9706 fail:
9707 return NULL;
9708 }
9709
9710
9711 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9712 PyObject *resultobj = 0;
9713 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9714 wxConfigBase *arg2 = 0 ;
9715 void *argp1 = 0 ;
9716 int res1 = 0 ;
9717 void *argp2 = 0 ;
9718 int res2 = 0 ;
9719 PyObject * obj0 = 0 ;
9720 PyObject * obj1 = 0 ;
9721 char * kwnames[] = {
9722 (char *) "self",(char *) "config", NULL
9723 };
9724
9725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9727 if (!SWIG_IsOK(res1)) {
9728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9729 }
9730 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9731 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9732 if (!SWIG_IsOK(res2)) {
9733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9734 }
9735 if (!argp2) {
9736 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9737 }
9738 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9739 {
9740 PyThreadState* __tstate = wxPyBeginAllowThreads();
9741 (arg1)->Load(*arg2);
9742 wxPyEndAllowThreads(__tstate);
9743 if (PyErr_Occurred()) SWIG_fail;
9744 }
9745 resultobj = SWIG_Py_Void();
9746 return resultobj;
9747 fail:
9748 return NULL;
9749 }
9750
9751
9752 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9753 PyObject *resultobj = 0;
9754 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9755 wxConfigBase *arg2 = 0 ;
9756 void *argp1 = 0 ;
9757 int res1 = 0 ;
9758 void *argp2 = 0 ;
9759 int res2 = 0 ;
9760 PyObject * obj0 = 0 ;
9761 PyObject * obj1 = 0 ;
9762 char * kwnames[] = {
9763 (char *) "self",(char *) "config", NULL
9764 };
9765
9766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9768 if (!SWIG_IsOK(res1)) {
9769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9770 }
9771 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9773 if (!SWIG_IsOK(res2)) {
9774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9775 }
9776 if (!argp2) {
9777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9778 }
9779 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9780 {
9781 PyThreadState* __tstate = wxPyBeginAllowThreads();
9782 (arg1)->Save(*arg2);
9783 wxPyEndAllowThreads(__tstate);
9784 if (PyErr_Occurred()) SWIG_fail;
9785 }
9786 resultobj = SWIG_Py_Void();
9787 return resultobj;
9788 fail:
9789 return NULL;
9790 }
9791
9792
9793 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9794 PyObject *resultobj = 0;
9795 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9796 void *argp1 = 0 ;
9797 int res1 = 0 ;
9798 PyObject *swig_obj[1] ;
9799
9800 if (!args) SWIG_fail;
9801 swig_obj[0] = args;
9802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9803 if (!SWIG_IsOK(res1)) {
9804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9805 }
9806 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 (arg1)->AddFilesToMenu();
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 resultobj = SWIG_Py_Void();
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9821 PyObject *resultobj = 0;
9822 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9823 wxMenu *arg2 = (wxMenu *) 0 ;
9824 void *argp1 = 0 ;
9825 int res1 = 0 ;
9826 void *argp2 = 0 ;
9827 int res2 = 0 ;
9828 PyObject * obj0 = 0 ;
9829 PyObject * obj1 = 0 ;
9830 char * kwnames[] = {
9831 (char *) "self",(char *) "menu", NULL
9832 };
9833
9834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9836 if (!SWIG_IsOK(res1)) {
9837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9838 }
9839 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9840 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9841 if (!SWIG_IsOK(res2)) {
9842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9843 }
9844 arg2 = reinterpret_cast< wxMenu * >(argp2);
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 (arg1)->AddFilesToMenu(arg2);
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 resultobj = SWIG_Py_Void();
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj = 0;
9860 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9861 int arg2 ;
9862 wxString result;
9863 void *argp1 = 0 ;
9864 int res1 = 0 ;
9865 int val2 ;
9866 int ecode2 = 0 ;
9867 PyObject * obj0 = 0 ;
9868 PyObject * obj1 = 0 ;
9869 char * kwnames[] = {
9870 (char *) "self",(char *) "i", NULL
9871 };
9872
9873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9877 }
9878 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9879 ecode2 = SWIG_AsVal_int(obj1, &val2);
9880 if (!SWIG_IsOK(ecode2)) {
9881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9882 }
9883 arg2 = static_cast< int >(val2);
9884 {
9885 PyThreadState* __tstate = wxPyBeginAllowThreads();
9886 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 {
9891 #if wxUSE_UNICODE
9892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9893 #else
9894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9895 #endif
9896 }
9897 return resultobj;
9898 fail:
9899 return NULL;
9900 }
9901
9902
9903 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9904 PyObject *resultobj = 0;
9905 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9906 int result;
9907 void *argp1 = 0 ;
9908 int res1 = 0 ;
9909 PyObject *swig_obj[1] ;
9910
9911 if (!args) SWIG_fail;
9912 swig_obj[0] = args;
9913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9914 if (!SWIG_IsOK(res1)) {
9915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9916 }
9917 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 result = (int)((wxFileHistory const *)arg1)->GetCount();
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 resultobj = SWIG_From_int(static_cast< int >(result));
9925 return resultobj;
9926 fail:
9927 return NULL;
9928 }
9929
9930
9931 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9932 PyObject *obj;
9933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9934 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9935 return SWIG_Py_Void();
9936 }
9937
9938 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9939 return SWIG_Python_InitShadowInstance(args);
9940 }
9941
9942 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9943 PyObject *resultobj = 0;
9944 wxString *arg1 = 0 ;
9945 wxString const &arg2_defvalue = wxPyEmptyString ;
9946 wxString *arg2 = (wxString *) &arg2_defvalue ;
9947 wxSingleInstanceChecker *result = 0 ;
9948 bool temp1 = false ;
9949 bool temp2 = false ;
9950 PyObject * obj0 = 0 ;
9951 PyObject * obj1 = 0 ;
9952 char * kwnames[] = {
9953 (char *) "name",(char *) "path", NULL
9954 };
9955
9956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9957 {
9958 arg1 = wxString_in_helper(obj0);
9959 if (arg1 == NULL) SWIG_fail;
9960 temp1 = true;
9961 }
9962 if (obj1) {
9963 {
9964 arg2 = wxString_in_helper(obj1);
9965 if (arg2 == NULL) SWIG_fail;
9966 temp2 = true;
9967 }
9968 }
9969 {
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9976 {
9977 if (temp1)
9978 delete arg1;
9979 }
9980 {
9981 if (temp2)
9982 delete arg2;
9983 }
9984 return resultobj;
9985 fail:
9986 {
9987 if (temp1)
9988 delete arg1;
9989 }
9990 {
9991 if (temp2)
9992 delete arg2;
9993 }
9994 return NULL;
9995 }
9996
9997
9998 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9999 PyObject *resultobj = 0;
10000 wxSingleInstanceChecker *result = 0 ;
10001
10002 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10010 return resultobj;
10011 fail:
10012 return NULL;
10013 }
10014
10015
10016 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10017 PyObject *resultobj = 0;
10018 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10019 void *argp1 = 0 ;
10020 int res1 = 0 ;
10021 PyObject *swig_obj[1] ;
10022
10023 if (!args) SWIG_fail;
10024 swig_obj[0] = args;
10025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10026 if (!SWIG_IsOK(res1)) {
10027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10028 }
10029 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10030 {
10031 PyThreadState* __tstate = wxPyBeginAllowThreads();
10032 delete arg1;
10033
10034 wxPyEndAllowThreads(__tstate);
10035 if (PyErr_Occurred()) SWIG_fail;
10036 }
10037 resultobj = SWIG_Py_Void();
10038 return resultobj;
10039 fail:
10040 return NULL;
10041 }
10042
10043
10044 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj = 0;
10046 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10047 wxString *arg2 = 0 ;
10048 wxString const &arg3_defvalue = wxPyEmptyString ;
10049 wxString *arg3 = (wxString *) &arg3_defvalue ;
10050 bool result;
10051 void *argp1 = 0 ;
10052 int res1 = 0 ;
10053 bool temp2 = false ;
10054 bool temp3 = false ;
10055 PyObject * obj0 = 0 ;
10056 PyObject * obj1 = 0 ;
10057 PyObject * obj2 = 0 ;
10058 char * kwnames[] = {
10059 (char *) "self",(char *) "name",(char *) "path", NULL
10060 };
10061
10062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10066 }
10067 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10068 {
10069 arg2 = wxString_in_helper(obj1);
10070 if (arg2 == NULL) SWIG_fail;
10071 temp2 = true;
10072 }
10073 if (obj2) {
10074 {
10075 arg3 = wxString_in_helper(obj2);
10076 if (arg3 == NULL) SWIG_fail;
10077 temp3 = true;
10078 }
10079 }
10080 {
10081 PyThreadState* __tstate = wxPyBeginAllowThreads();
10082 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10083 wxPyEndAllowThreads(__tstate);
10084 if (PyErr_Occurred()) SWIG_fail;
10085 }
10086 {
10087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10088 }
10089 {
10090 if (temp2)
10091 delete arg2;
10092 }
10093 {
10094 if (temp3)
10095 delete arg3;
10096 }
10097 return resultobj;
10098 fail:
10099 {
10100 if (temp2)
10101 delete arg2;
10102 }
10103 {
10104 if (temp3)
10105 delete arg3;
10106 }
10107 return NULL;
10108 }
10109
10110
10111 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10112 PyObject *resultobj = 0;
10113 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10114 bool result;
10115 void *argp1 = 0 ;
10116 int res1 = 0 ;
10117 PyObject *swig_obj[1] ;
10118
10119 if (!args) SWIG_fail;
10120 swig_obj[0] = args;
10121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10122 if (!SWIG_IsOK(res1)) {
10123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10124 }
10125 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10126 {
10127 PyThreadState* __tstate = wxPyBeginAllowThreads();
10128 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10129 wxPyEndAllowThreads(__tstate);
10130 if (PyErr_Occurred()) SWIG_fail;
10131 }
10132 {
10133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10134 }
10135 return resultobj;
10136 fail:
10137 return NULL;
10138 }
10139
10140
10141 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10142 PyObject *obj;
10143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10144 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10145 return SWIG_Py_Void();
10146 }
10147
10148 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10149 return SWIG_Python_InitShadowInstance(args);
10150 }
10151
10152 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10153 PyObject *resultobj = 0;
10154 wxPlatformInfo *result = 0 ;
10155
10156 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10157 {
10158 PyThreadState* __tstate = wxPyBeginAllowThreads();
10159 result = (wxPlatformInfo *)new wxPlatformInfo();
10160 wxPyEndAllowThreads(__tstate);
10161 if (PyErr_Occurred()) SWIG_fail;
10162 }
10163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10164 return resultobj;
10165 fail:
10166 return NULL;
10167 }
10168
10169
10170 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10171 PyObject *resultobj = 0;
10172 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10173 wxPlatformInfo *arg2 = 0 ;
10174 bool result;
10175 void *argp1 = 0 ;
10176 int res1 = 0 ;
10177 void *argp2 = 0 ;
10178 int res2 = 0 ;
10179 PyObject * obj0 = 0 ;
10180 PyObject * obj1 = 0 ;
10181 char * kwnames[] = {
10182 (char *) "self",(char *) "t", NULL
10183 };
10184
10185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10187 if (!SWIG_IsOK(res1)) {
10188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10189 }
10190 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10191 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10192 if (!SWIG_IsOK(res2)) {
10193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10194 }
10195 if (!argp2) {
10196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10197 }
10198 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10199 {
10200 PyThreadState* __tstate = wxPyBeginAllowThreads();
10201 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10202 wxPyEndAllowThreads(__tstate);
10203 if (PyErr_Occurred()) SWIG_fail;
10204 }
10205 {
10206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10207 }
10208 return resultobj;
10209 fail:
10210 return NULL;
10211 }
10212
10213
10214 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10215 PyObject *resultobj = 0;
10216 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10217 wxPlatformInfo *arg2 = 0 ;
10218 bool result;
10219 void *argp1 = 0 ;
10220 int res1 = 0 ;
10221 void *argp2 = 0 ;
10222 int res2 = 0 ;
10223 PyObject * obj0 = 0 ;
10224 PyObject * obj1 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "self",(char *) "t", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10231 if (!SWIG_IsOK(res1)) {
10232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10233 }
10234 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10236 if (!SWIG_IsOK(res2)) {
10237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10238 }
10239 if (!argp2) {
10240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10241 }
10242 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10243 {
10244 PyThreadState* __tstate = wxPyBeginAllowThreads();
10245 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10246 wxPyEndAllowThreads(__tstate);
10247 if (PyErr_Occurred()) SWIG_fail;
10248 }
10249 {
10250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10251 }
10252 return resultobj;
10253 fail:
10254 return NULL;
10255 }
10256
10257
10258 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10259 PyObject *resultobj = 0;
10260 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10261 int result;
10262 void *argp1 = 0 ;
10263 int res1 = 0 ;
10264 PyObject *swig_obj[1] ;
10265
10266 if (!args) SWIG_fail;
10267 swig_obj[0] = args;
10268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10269 if (!SWIG_IsOK(res1)) {
10270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10271 }
10272 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10273 {
10274 PyThreadState* __tstate = wxPyBeginAllowThreads();
10275 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10276 wxPyEndAllowThreads(__tstate);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 resultobj = SWIG_From_int(static_cast< int >(result));
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10287 PyObject *resultobj = 0;
10288 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10289 int result;
10290 void *argp1 = 0 ;
10291 int res1 = 0 ;
10292 PyObject *swig_obj[1] ;
10293
10294 if (!args) SWIG_fail;
10295 swig_obj[0] = args;
10296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10297 if (!SWIG_IsOK(res1)) {
10298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10299 }
10300 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10301 {
10302 PyThreadState* __tstate = wxPyBeginAllowThreads();
10303 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10304 wxPyEndAllowThreads(__tstate);
10305 if (PyErr_Occurred()) SWIG_fail;
10306 }
10307 resultobj = SWIG_From_int(static_cast< int >(result));
10308 return resultobj;
10309 fail:
10310 return NULL;
10311 }
10312
10313
10314 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10315 PyObject *resultobj = 0;
10316 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10317 int arg2 ;
10318 int arg3 ;
10319 bool result;
10320 void *argp1 = 0 ;
10321 int res1 = 0 ;
10322 int val2 ;
10323 int ecode2 = 0 ;
10324 int val3 ;
10325 int ecode3 = 0 ;
10326 PyObject * obj0 = 0 ;
10327 PyObject * obj1 = 0 ;
10328 PyObject * obj2 = 0 ;
10329 char * kwnames[] = {
10330 (char *) "self",(char *) "major",(char *) "minor", NULL
10331 };
10332
10333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10335 if (!SWIG_IsOK(res1)) {
10336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10337 }
10338 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10339 ecode2 = SWIG_AsVal_int(obj1, &val2);
10340 if (!SWIG_IsOK(ecode2)) {
10341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10342 }
10343 arg2 = static_cast< int >(val2);
10344 ecode3 = SWIG_AsVal_int(obj2, &val3);
10345 if (!SWIG_IsOK(ecode3)) {
10346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10347 }
10348 arg3 = static_cast< int >(val3);
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10352 wxPyEndAllowThreads(__tstate);
10353 if (PyErr_Occurred()) SWIG_fail;
10354 }
10355 {
10356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10357 }
10358 return resultobj;
10359 fail:
10360 return NULL;
10361 }
10362
10363
10364 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10365 PyObject *resultobj = 0;
10366 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10367 int result;
10368 void *argp1 = 0 ;
10369 int res1 = 0 ;
10370 PyObject *swig_obj[1] ;
10371
10372 if (!args) SWIG_fail;
10373 swig_obj[0] = args;
10374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10375 if (!SWIG_IsOK(res1)) {
10376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10377 }
10378 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 resultobj = SWIG_From_int(static_cast< int >(result));
10386 return resultobj;
10387 fail:
10388 return NULL;
10389 }
10390
10391
10392 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10393 PyObject *resultobj = 0;
10394 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10395 int result;
10396 void *argp1 = 0 ;
10397 int res1 = 0 ;
10398 PyObject *swig_obj[1] ;
10399
10400 if (!args) SWIG_fail;
10401 swig_obj[0] = args;
10402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10403 if (!SWIG_IsOK(res1)) {
10404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10405 }
10406 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10410 wxPyEndAllowThreads(__tstate);
10411 if (PyErr_Occurred()) SWIG_fail;
10412 }
10413 resultobj = SWIG_From_int(static_cast< int >(result));
10414 return resultobj;
10415 fail:
10416 return NULL;
10417 }
10418
10419
10420 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10421 PyObject *resultobj = 0;
10422 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10423 int arg2 ;
10424 int arg3 ;
10425 bool result;
10426 void *argp1 = 0 ;
10427 int res1 = 0 ;
10428 int val2 ;
10429 int ecode2 = 0 ;
10430 int val3 ;
10431 int ecode3 = 0 ;
10432 PyObject * obj0 = 0 ;
10433 PyObject * obj1 = 0 ;
10434 PyObject * obj2 = 0 ;
10435 char * kwnames[] = {
10436 (char *) "self",(char *) "major",(char *) "minor", NULL
10437 };
10438
10439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10441 if (!SWIG_IsOK(res1)) {
10442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10443 }
10444 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10445 ecode2 = SWIG_AsVal_int(obj1, &val2);
10446 if (!SWIG_IsOK(ecode2)) {
10447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10448 }
10449 arg2 = static_cast< int >(val2);
10450 ecode3 = SWIG_AsVal_int(obj2, &val3);
10451 if (!SWIG_IsOK(ecode3)) {
10452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10453 }
10454 arg3 = static_cast< int >(val3);
10455 {
10456 PyThreadState* __tstate = wxPyBeginAllowThreads();
10457 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10458 wxPyEndAllowThreads(__tstate);
10459 if (PyErr_Occurred()) SWIG_fail;
10460 }
10461 {
10462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10463 }
10464 return resultobj;
10465 fail:
10466 return NULL;
10467 }
10468
10469
10470 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10471 PyObject *resultobj = 0;
10472 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10473 bool result;
10474 void *argp1 = 0 ;
10475 int res1 = 0 ;
10476 PyObject *swig_obj[1] ;
10477
10478 if (!args) SWIG_fail;
10479 swig_obj[0] = args;
10480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10481 if (!SWIG_IsOK(res1)) {
10482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10483 }
10484 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10485 {
10486 PyThreadState* __tstate = wxPyBeginAllowThreads();
10487 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10488 wxPyEndAllowThreads(__tstate);
10489 if (PyErr_Occurred()) SWIG_fail;
10490 }
10491 {
10492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10493 }
10494 return resultobj;
10495 fail:
10496 return NULL;
10497 }
10498
10499
10500 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10501 PyObject *resultobj = 0;
10502 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10503 wxOperatingSystemId result;
10504 void *argp1 = 0 ;
10505 int res1 = 0 ;
10506 PyObject *swig_obj[1] ;
10507
10508 if (!args) SWIG_fail;
10509 swig_obj[0] = args;
10510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10511 if (!SWIG_IsOK(res1)) {
10512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10513 }
10514 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10515 {
10516 PyThreadState* __tstate = wxPyBeginAllowThreads();
10517 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 resultobj = SWIG_From_int(static_cast< int >(result));
10522 return resultobj;
10523 fail:
10524 return NULL;
10525 }
10526
10527
10528 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10529 PyObject *resultobj = 0;
10530 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10531 wxPortId result;
10532 void *argp1 = 0 ;
10533 int res1 = 0 ;
10534 PyObject *swig_obj[1] ;
10535
10536 if (!args) SWIG_fail;
10537 swig_obj[0] = args;
10538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10539 if (!SWIG_IsOK(res1)) {
10540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10541 }
10542 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 resultobj = SWIG_From_int(static_cast< int >(result));
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10557 PyObject *resultobj = 0;
10558 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10559 wxArchitecture result;
10560 void *argp1 = 0 ;
10561 int res1 = 0 ;
10562 PyObject *swig_obj[1] ;
10563
10564 if (!args) SWIG_fail;
10565 swig_obj[0] = args;
10566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10567 if (!SWIG_IsOK(res1)) {
10568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10569 }
10570 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10571 {
10572 PyThreadState* __tstate = wxPyBeginAllowThreads();
10573 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_From_int(static_cast< int >(result));
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10585 PyObject *resultobj = 0;
10586 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10587 wxEndianness result;
10588 void *argp1 = 0 ;
10589 int res1 = 0 ;
10590 PyObject *swig_obj[1] ;
10591
10592 if (!args) SWIG_fail;
10593 swig_obj[0] = args;
10594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10595 if (!SWIG_IsOK(res1)) {
10596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10597 }
10598 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10599 {
10600 PyThreadState* __tstate = wxPyBeginAllowThreads();
10601 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10602 wxPyEndAllowThreads(__tstate);
10603 if (PyErr_Occurred()) SWIG_fail;
10604 }
10605 resultobj = SWIG_From_int(static_cast< int >(result));
10606 return resultobj;
10607 fail:
10608 return NULL;
10609 }
10610
10611
10612 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10613 PyObject *resultobj = 0;
10614 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10615 wxString result;
10616 void *argp1 = 0 ;
10617 int res1 = 0 ;
10618 PyObject *swig_obj[1] ;
10619
10620 if (!args) SWIG_fail;
10621 swig_obj[0] = args;
10622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10623 if (!SWIG_IsOK(res1)) {
10624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10625 }
10626 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10627 {
10628 PyThreadState* __tstate = wxPyBeginAllowThreads();
10629 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10630 wxPyEndAllowThreads(__tstate);
10631 if (PyErr_Occurred()) SWIG_fail;
10632 }
10633 {
10634 #if wxUSE_UNICODE
10635 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10636 #else
10637 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10638 #endif
10639 }
10640 return resultobj;
10641 fail:
10642 return NULL;
10643 }
10644
10645
10646 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10647 PyObject *resultobj = 0;
10648 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10649 wxString result;
10650 void *argp1 = 0 ;
10651 int res1 = 0 ;
10652 PyObject *swig_obj[1] ;
10653
10654 if (!args) SWIG_fail;
10655 swig_obj[0] = args;
10656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10657 if (!SWIG_IsOK(res1)) {
10658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10659 }
10660 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10661 {
10662 PyThreadState* __tstate = wxPyBeginAllowThreads();
10663 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 {
10668 #if wxUSE_UNICODE
10669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10670 #else
10671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10672 #endif
10673 }
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10681 PyObject *resultobj = 0;
10682 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10683 wxString result;
10684 void *argp1 = 0 ;
10685 int res1 = 0 ;
10686 PyObject *swig_obj[1] ;
10687
10688 if (!args) SWIG_fail;
10689 swig_obj[0] = args;
10690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10691 if (!SWIG_IsOK(res1)) {
10692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10693 }
10694 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10695 {
10696 PyThreadState* __tstate = wxPyBeginAllowThreads();
10697 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10698 wxPyEndAllowThreads(__tstate);
10699 if (PyErr_Occurred()) SWIG_fail;
10700 }
10701 {
10702 #if wxUSE_UNICODE
10703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10704 #else
10705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10706 #endif
10707 }
10708 return resultobj;
10709 fail:
10710 return NULL;
10711 }
10712
10713
10714 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10715 PyObject *resultobj = 0;
10716 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10717 wxString result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 PyObject *swig_obj[1] ;
10721
10722 if (!args) SWIG_fail;
10723 swig_obj[0] = args;
10724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10725 if (!SWIG_IsOK(res1)) {
10726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10727 }
10728 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10732 wxPyEndAllowThreads(__tstate);
10733 if (PyErr_Occurred()) SWIG_fail;
10734 }
10735 {
10736 #if wxUSE_UNICODE
10737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10738 #else
10739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10740 #endif
10741 }
10742 return resultobj;
10743 fail:
10744 return NULL;
10745 }
10746
10747
10748 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10749 PyObject *resultobj = 0;
10750 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10751 wxString result;
10752 void *argp1 = 0 ;
10753 int res1 = 0 ;
10754 PyObject *swig_obj[1] ;
10755
10756 if (!args) SWIG_fail;
10757 swig_obj[0] = args;
10758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10759 if (!SWIG_IsOK(res1)) {
10760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10761 }
10762 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10763 {
10764 PyThreadState* __tstate = wxPyBeginAllowThreads();
10765 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10766 wxPyEndAllowThreads(__tstate);
10767 if (PyErr_Occurred()) SWIG_fail;
10768 }
10769 {
10770 #if wxUSE_UNICODE
10771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10772 #else
10773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10774 #endif
10775 }
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10783 PyObject *resultobj = 0;
10784 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10785 wxString result;
10786 void *argp1 = 0 ;
10787 int res1 = 0 ;
10788 PyObject *swig_obj[1] ;
10789
10790 if (!args) SWIG_fail;
10791 swig_obj[0] = args;
10792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10793 if (!SWIG_IsOK(res1)) {
10794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10795 }
10796 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10797 {
10798 PyThreadState* __tstate = wxPyBeginAllowThreads();
10799 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10800 wxPyEndAllowThreads(__tstate);
10801 if (PyErr_Occurred()) SWIG_fail;
10802 }
10803 {
10804 #if wxUSE_UNICODE
10805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10806 #else
10807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10808 #endif
10809 }
10810 return resultobj;
10811 fail:
10812 return NULL;
10813 }
10814
10815
10816 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10817 PyObject *resultobj = 0;
10818 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10819 int arg2 ;
10820 int arg3 ;
10821 void *argp1 = 0 ;
10822 int res1 = 0 ;
10823 int val2 ;
10824 int ecode2 = 0 ;
10825 int val3 ;
10826 int ecode3 = 0 ;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 PyObject * obj2 = 0 ;
10830 char * kwnames[] = {
10831 (char *) "self",(char *) "major",(char *) "minor", NULL
10832 };
10833
10834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10836 if (!SWIG_IsOK(res1)) {
10837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10838 }
10839 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10840 ecode2 = SWIG_AsVal_int(obj1, &val2);
10841 if (!SWIG_IsOK(ecode2)) {
10842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10843 }
10844 arg2 = static_cast< int >(val2);
10845 ecode3 = SWIG_AsVal_int(obj2, &val3);
10846 if (!SWIG_IsOK(ecode3)) {
10847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10848 }
10849 arg3 = static_cast< int >(val3);
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 (arg1)->SetOSVersion(arg2,arg3);
10853 wxPyEndAllowThreads(__tstate);
10854 if (PyErr_Occurred()) SWIG_fail;
10855 }
10856 resultobj = SWIG_Py_Void();
10857 return resultobj;
10858 fail:
10859 return NULL;
10860 }
10861
10862
10863 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10864 PyObject *resultobj = 0;
10865 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10866 int arg2 ;
10867 int arg3 ;
10868 void *argp1 = 0 ;
10869 int res1 = 0 ;
10870 int val2 ;
10871 int ecode2 = 0 ;
10872 int val3 ;
10873 int ecode3 = 0 ;
10874 PyObject * obj0 = 0 ;
10875 PyObject * obj1 = 0 ;
10876 PyObject * obj2 = 0 ;
10877 char * kwnames[] = {
10878 (char *) "self",(char *) "major",(char *) "minor", NULL
10879 };
10880
10881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10883 if (!SWIG_IsOK(res1)) {
10884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10885 }
10886 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10887 ecode2 = SWIG_AsVal_int(obj1, &val2);
10888 if (!SWIG_IsOK(ecode2)) {
10889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10890 }
10891 arg2 = static_cast< int >(val2);
10892 ecode3 = SWIG_AsVal_int(obj2, &val3);
10893 if (!SWIG_IsOK(ecode3)) {
10894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10895 }
10896 arg3 = static_cast< int >(val3);
10897 {
10898 PyThreadState* __tstate = wxPyBeginAllowThreads();
10899 (arg1)->SetToolkitVersion(arg2,arg3);
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_Py_Void();
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj = 0;
10912 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10913 wxOperatingSystemId arg2 ;
10914 void *argp1 = 0 ;
10915 int res1 = 0 ;
10916 int val2 ;
10917 int ecode2 = 0 ;
10918 PyObject * obj0 = 0 ;
10919 PyObject * obj1 = 0 ;
10920 char * kwnames[] = {
10921 (char *) "self",(char *) "n", NULL
10922 };
10923
10924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10926 if (!SWIG_IsOK(res1)) {
10927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10928 }
10929 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10930 ecode2 = SWIG_AsVal_int(obj1, &val2);
10931 if (!SWIG_IsOK(ecode2)) {
10932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10933 }
10934 arg2 = static_cast< wxOperatingSystemId >(val2);
10935 {
10936 PyThreadState* __tstate = wxPyBeginAllowThreads();
10937 (arg1)->SetOperatingSystemId(arg2);
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 resultobj = SWIG_Py_Void();
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10951 wxPortId arg2 ;
10952 void *argp1 = 0 ;
10953 int res1 = 0 ;
10954 int val2 ;
10955 int ecode2 = 0 ;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 char * kwnames[] = {
10959 (char *) "self",(char *) "n", NULL
10960 };
10961
10962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10964 if (!SWIG_IsOK(res1)) {
10965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10966 }
10967 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10968 ecode2 = SWIG_AsVal_int(obj1, &val2);
10969 if (!SWIG_IsOK(ecode2)) {
10970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10971 }
10972 arg2 = static_cast< wxPortId >(val2);
10973 {
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 (arg1)->SetPortId(arg2);
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 resultobj = SWIG_Py_Void();
10980 return resultobj;
10981 fail:
10982 return NULL;
10983 }
10984
10985
10986 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10987 PyObject *resultobj = 0;
10988 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10989 wxArchitecture arg2 ;
10990 void *argp1 = 0 ;
10991 int res1 = 0 ;
10992 int val2 ;
10993 int ecode2 = 0 ;
10994 PyObject * obj0 = 0 ;
10995 PyObject * obj1 = 0 ;
10996 char * kwnames[] = {
10997 (char *) "self",(char *) "n", NULL
10998 };
10999
11000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
11001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11002 if (!SWIG_IsOK(res1)) {
11003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11004 }
11005 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11006 ecode2 = SWIG_AsVal_int(obj1, &val2);
11007 if (!SWIG_IsOK(ecode2)) {
11008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11009 }
11010 arg2 = static_cast< wxArchitecture >(val2);
11011 {
11012 PyThreadState* __tstate = wxPyBeginAllowThreads();
11013 (arg1)->SetArchitecture(arg2);
11014 wxPyEndAllowThreads(__tstate);
11015 if (PyErr_Occurred()) SWIG_fail;
11016 }
11017 resultobj = SWIG_Py_Void();
11018 return resultobj;
11019 fail:
11020 return NULL;
11021 }
11022
11023
11024 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11025 PyObject *resultobj = 0;
11026 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11027 wxEndianness arg2 ;
11028 void *argp1 = 0 ;
11029 int res1 = 0 ;
11030 int val2 ;
11031 int ecode2 = 0 ;
11032 PyObject * obj0 = 0 ;
11033 PyObject * obj1 = 0 ;
11034 char * kwnames[] = {
11035 (char *) "self",(char *) "n", NULL
11036 };
11037
11038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11040 if (!SWIG_IsOK(res1)) {
11041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11042 }
11043 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11044 ecode2 = SWIG_AsVal_int(obj1, &val2);
11045 if (!SWIG_IsOK(ecode2)) {
11046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11047 }
11048 arg2 = static_cast< wxEndianness >(val2);
11049 {
11050 PyThreadState* __tstate = wxPyBeginAllowThreads();
11051 (arg1)->SetEndianness(arg2);
11052 wxPyEndAllowThreads(__tstate);
11053 if (PyErr_Occurred()) SWIG_fail;
11054 }
11055 resultobj = SWIG_Py_Void();
11056 return resultobj;
11057 fail:
11058 return NULL;
11059 }
11060
11061
11062 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11063 PyObject *resultobj = 0;
11064 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11065 bool result;
11066 void *argp1 = 0 ;
11067 int res1 = 0 ;
11068 PyObject *swig_obj[1] ;
11069
11070 if (!args) SWIG_fail;
11071 swig_obj[0] = args;
11072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11073 if (!SWIG_IsOK(res1)) {
11074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11075 }
11076 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11085 }
11086 return resultobj;
11087 fail:
11088 return NULL;
11089 }
11090
11091
11092 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11093 PyObject *obj;
11094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11095 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11096 return SWIG_Py_Void();
11097 }
11098
11099 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11100 return SWIG_Python_InitShadowInstance(args);
11101 }
11102
11103 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11104 PyObject *resultobj = 0;
11105 wxWindow *arg1 = (wxWindow *) 0 ;
11106 wxDC *arg2 = 0 ;
11107 bool result;
11108 void *argp1 = 0 ;
11109 int res1 = 0 ;
11110 void *argp2 = 0 ;
11111 int res2 = 0 ;
11112 PyObject * obj0 = 0 ;
11113 PyObject * obj1 = 0 ;
11114 char * kwnames[] = {
11115 (char *) "window",(char *) "dc", NULL
11116 };
11117
11118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11120 if (!SWIG_IsOK(res1)) {
11121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11122 }
11123 arg1 = reinterpret_cast< wxWindow * >(argp1);
11124 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11125 if (!SWIG_IsOK(res2)) {
11126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11127 }
11128 if (!argp2) {
11129 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11130 }
11131 arg2 = reinterpret_cast< wxDC * >(argp2);
11132 {
11133 PyThreadState* __tstate = wxPyBeginAllowThreads();
11134 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11135 wxPyEndAllowThreads(__tstate);
11136 if (PyErr_Occurred()) SWIG_fail;
11137 }
11138 {
11139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11140 }
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11148 PyObject *resultobj = 0;
11149 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11150 void *argp1 = 0 ;
11151 int res1 = 0 ;
11152 PyObject *swig_obj[1] ;
11153
11154 if (!args) SWIG_fail;
11155 swig_obj[0] = args;
11156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11157 if (!SWIG_IsOK(res1)) {
11158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11159 }
11160 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11161 {
11162 PyThreadState* __tstate = wxPyBeginAllowThreads();
11163 delete arg1;
11164
11165 wxPyEndAllowThreads(__tstate);
11166 if (PyErr_Occurred()) SWIG_fail;
11167 }
11168 resultobj = SWIG_Py_Void();
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11176 PyObject *resultobj = 0;
11177 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11178 wxString result;
11179 void *argp1 = 0 ;
11180 int res1 = 0 ;
11181 PyObject *swig_obj[1] ;
11182
11183 if (!args) SWIG_fail;
11184 swig_obj[0] = args;
11185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11186 if (!SWIG_IsOK(res1)) {
11187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11188 }
11189 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11190 {
11191 PyThreadState* __tstate = wxPyBeginAllowThreads();
11192 result = (arg1)->GetTip();
11193 wxPyEndAllowThreads(__tstate);
11194 if (PyErr_Occurred()) SWIG_fail;
11195 }
11196 {
11197 #if wxUSE_UNICODE
11198 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11199 #else
11200 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11201 #endif
11202 }
11203 return resultobj;
11204 fail:
11205 return NULL;
11206 }
11207
11208
11209 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11210 PyObject *resultobj = 0;
11211 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11212 size_t result;
11213 void *argp1 = 0 ;
11214 int res1 = 0 ;
11215 PyObject *swig_obj[1] ;
11216
11217 if (!args) SWIG_fail;
11218 swig_obj[0] = args;
11219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11220 if (!SWIG_IsOK(res1)) {
11221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11222 }
11223 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11224 {
11225 PyThreadState* __tstate = wxPyBeginAllowThreads();
11226 result = (size_t)(arg1)->GetCurrentTip();
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj = 0;
11239 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11240 wxString *arg2 = 0 ;
11241 wxString result;
11242 void *argp1 = 0 ;
11243 int res1 = 0 ;
11244 bool temp2 = false ;
11245 PyObject * obj0 = 0 ;
11246 PyObject * obj1 = 0 ;
11247 char * kwnames[] = {
11248 (char *) "self",(char *) "tip", NULL
11249 };
11250
11251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11253 if (!SWIG_IsOK(res1)) {
11254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11255 }
11256 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11257 {
11258 arg2 = wxString_in_helper(obj1);
11259 if (arg2 == NULL) SWIG_fail;
11260 temp2 = true;
11261 }
11262 {
11263 PyThreadState* __tstate = wxPyBeginAllowThreads();
11264 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 {
11269 #if wxUSE_UNICODE
11270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11271 #else
11272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11273 #endif
11274 }
11275 {
11276 if (temp2)
11277 delete arg2;
11278 }
11279 return resultobj;
11280 fail:
11281 {
11282 if (temp2)
11283 delete arg2;
11284 }
11285 return NULL;
11286 }
11287
11288
11289 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11290 PyObject *obj;
11291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11292 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11293 return SWIG_Py_Void();
11294 }
11295
11296 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11297 PyObject *resultobj = 0;
11298 size_t arg1 ;
11299 wxPyTipProvider *result = 0 ;
11300 size_t val1 ;
11301 int ecode1 = 0 ;
11302 PyObject * obj0 = 0 ;
11303 char * kwnames[] = {
11304 (char *) "currentTip", NULL
11305 };
11306
11307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11308 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11309 if (!SWIG_IsOK(ecode1)) {
11310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11311 }
11312 arg1 = static_cast< size_t >(val1);
11313 {
11314 PyThreadState* __tstate = wxPyBeginAllowThreads();
11315 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11316 wxPyEndAllowThreads(__tstate);
11317 if (PyErr_Occurred()) SWIG_fail;
11318 }
11319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11320 return resultobj;
11321 fail:
11322 return NULL;
11323 }
11324
11325
11326 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11327 PyObject *resultobj = 0;
11328 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11329 PyObject *arg2 = (PyObject *) 0 ;
11330 PyObject *arg3 = (PyObject *) 0 ;
11331 void *argp1 = 0 ;
11332 int res1 = 0 ;
11333 PyObject * obj0 = 0 ;
11334 PyObject * obj1 = 0 ;
11335 PyObject * obj2 = 0 ;
11336 char * kwnames[] = {
11337 (char *) "self",(char *) "self",(char *) "_class", NULL
11338 };
11339
11340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11342 if (!SWIG_IsOK(res1)) {
11343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11344 }
11345 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11346 arg2 = obj1;
11347 arg3 = obj2;
11348 {
11349 PyThreadState* __tstate = wxPyBeginAllowThreads();
11350 (arg1)->_setCallbackInfo(arg2,arg3);
11351 wxPyEndAllowThreads(__tstate);
11352 if (PyErr_Occurred()) SWIG_fail;
11353 }
11354 resultobj = SWIG_Py_Void();
11355 return resultobj;
11356 fail:
11357 return NULL;
11358 }
11359
11360
11361 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11362 PyObject *obj;
11363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11364 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11365 return SWIG_Py_Void();
11366 }
11367
11368 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11369 return SWIG_Python_InitShadowInstance(args);
11370 }
11371
11372 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj = 0;
11374 wxWindow *arg1 = (wxWindow *) 0 ;
11375 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11376 bool arg3 = (bool) true ;
11377 bool result;
11378 void *argp1 = 0 ;
11379 int res1 = 0 ;
11380 void *argp2 = 0 ;
11381 int res2 = 0 ;
11382 bool val3 ;
11383 int ecode3 = 0 ;
11384 PyObject * obj0 = 0 ;
11385 PyObject * obj1 = 0 ;
11386 PyObject * obj2 = 0 ;
11387 char * kwnames[] = {
11388 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11389 };
11390
11391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11393 if (!SWIG_IsOK(res1)) {
11394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11395 }
11396 arg1 = reinterpret_cast< wxWindow * >(argp1);
11397 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11398 if (!SWIG_IsOK(res2)) {
11399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11400 }
11401 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11402 if (obj2) {
11403 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11404 if (!SWIG_IsOK(ecode3)) {
11405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11406 }
11407 arg3 = static_cast< bool >(val3);
11408 }
11409 {
11410 if (!wxPyCheckForApp()) SWIG_fail;
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 result = (bool)wxShowTip(arg1,arg2,arg3);
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 {
11417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11418 }
11419 return resultobj;
11420 fail:
11421 return NULL;
11422 }
11423
11424
11425 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11426 PyObject *resultobj = 0;
11427 wxString *arg1 = 0 ;
11428 size_t arg2 ;
11429 wxTipProvider *result = 0 ;
11430 bool temp1 = false ;
11431 size_t val2 ;
11432 int ecode2 = 0 ;
11433 PyObject * obj0 = 0 ;
11434 PyObject * obj1 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "filename",(char *) "currentTip", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11440 {
11441 arg1 = wxString_in_helper(obj0);
11442 if (arg1 == NULL) SWIG_fail;
11443 temp1 = true;
11444 }
11445 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11446 if (!SWIG_IsOK(ecode2)) {
11447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11448 }
11449 arg2 = static_cast< size_t >(val2);
11450 {
11451 if (!wxPyCheckForApp()) SWIG_fail;
11452 PyThreadState* __tstate = wxPyBeginAllowThreads();
11453 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11458 {
11459 if (temp1)
11460 delete arg1;
11461 }
11462 return resultobj;
11463 fail:
11464 {
11465 if (temp1)
11466 delete arg1;
11467 }
11468 return NULL;
11469 }
11470
11471
11472 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj = 0;
11474 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11475 int arg2 = (int) wxID_ANY ;
11476 wxPyTimer *result = 0 ;
11477 void *argp1 = 0 ;
11478 int res1 = 0 ;
11479 int val2 ;
11480 int ecode2 = 0 ;
11481 PyObject * obj0 = 0 ;
11482 PyObject * obj1 = 0 ;
11483 char * kwnames[] = {
11484 (char *) "owner",(char *) "id", NULL
11485 };
11486
11487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11488 if (obj0) {
11489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11490 if (!SWIG_IsOK(res1)) {
11491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11492 }
11493 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11494 }
11495 if (obj1) {
11496 ecode2 = SWIG_AsVal_int(obj1, &val2);
11497 if (!SWIG_IsOK(ecode2)) {
11498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11499 }
11500 arg2 = static_cast< int >(val2);
11501 }
11502 {
11503 if (!wxPyCheckForApp()) SWIG_fail;
11504 PyThreadState* __tstate = wxPyBeginAllowThreads();
11505 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11510 return resultobj;
11511 fail:
11512 return NULL;
11513 }
11514
11515
11516 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11517 PyObject *resultobj = 0;
11518 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11519 void *argp1 = 0 ;
11520 int res1 = 0 ;
11521 PyObject *swig_obj[1] ;
11522
11523 if (!args) SWIG_fail;
11524 swig_obj[0] = args;
11525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11526 if (!SWIG_IsOK(res1)) {
11527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11528 }
11529 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11530 {
11531 PyThreadState* __tstate = wxPyBeginAllowThreads();
11532 delete arg1;
11533
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 resultobj = SWIG_Py_Void();
11538 return resultobj;
11539 fail:
11540 return NULL;
11541 }
11542
11543
11544 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11545 PyObject *resultobj = 0;
11546 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11547 PyObject *arg2 = (PyObject *) 0 ;
11548 PyObject *arg3 = (PyObject *) 0 ;
11549 int arg4 = (int) 0 ;
11550 void *argp1 = 0 ;
11551 int res1 = 0 ;
11552 int val4 ;
11553 int ecode4 = 0 ;
11554 PyObject * obj0 = 0 ;
11555 PyObject * obj1 = 0 ;
11556 PyObject * obj2 = 0 ;
11557 PyObject * obj3 = 0 ;
11558 char * kwnames[] = {
11559 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11560 };
11561
11562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11564 if (!SWIG_IsOK(res1)) {
11565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11566 }
11567 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11568 arg2 = obj1;
11569 arg3 = obj2;
11570 if (obj3) {
11571 ecode4 = SWIG_AsVal_int(obj3, &val4);
11572 if (!SWIG_IsOK(ecode4)) {
11573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11574 }
11575 arg4 = static_cast< int >(val4);
11576 }
11577 {
11578 PyThreadState* __tstate = wxPyBeginAllowThreads();
11579 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11580 wxPyEndAllowThreads(__tstate);
11581 if (PyErr_Occurred()) SWIG_fail;
11582 }
11583 resultobj = SWIG_Py_Void();
11584 return resultobj;
11585 fail:
11586 return NULL;
11587 }
11588
11589
11590 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11591 PyObject *resultobj = 0;
11592 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11593 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11594 int arg3 = (int) wxID_ANY ;
11595 void *argp1 = 0 ;
11596 int res1 = 0 ;
11597 void *argp2 = 0 ;
11598 int res2 = 0 ;
11599 int val3 ;
11600 int ecode3 = 0 ;
11601 PyObject * obj0 = 0 ;
11602 PyObject * obj1 = 0 ;
11603 PyObject * obj2 = 0 ;
11604 char * kwnames[] = {
11605 (char *) "self",(char *) "owner",(char *) "id", NULL
11606 };
11607
11608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11610 if (!SWIG_IsOK(res1)) {
11611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11612 }
11613 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11615 if (!SWIG_IsOK(res2)) {
11616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11617 }
11618 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11619 if (obj2) {
11620 ecode3 = SWIG_AsVal_int(obj2, &val3);
11621 if (!SWIG_IsOK(ecode3)) {
11622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11623 }
11624 arg3 = static_cast< int >(val3);
11625 }
11626 {
11627 PyThreadState* __tstate = wxPyBeginAllowThreads();
11628 (arg1)->SetOwner(arg2,arg3);
11629 wxPyEndAllowThreads(__tstate);
11630 if (PyErr_Occurred()) SWIG_fail;
11631 }
11632 resultobj = SWIG_Py_Void();
11633 return resultobj;
11634 fail:
11635 return NULL;
11636 }
11637
11638
11639 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11640 PyObject *resultobj = 0;
11641 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11642 wxEvtHandler *result = 0 ;
11643 void *argp1 = 0 ;
11644 int res1 = 0 ;
11645 PyObject *swig_obj[1] ;
11646
11647 if (!args) SWIG_fail;
11648 swig_obj[0] = args;
11649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11652 }
11653 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11654 {
11655 PyThreadState* __tstate = wxPyBeginAllowThreads();
11656 result = (wxEvtHandler *)(arg1)->GetOwner();
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = wxPyMake_wxObject(result, 0);
11662 }
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11670 PyObject *resultobj = 0;
11671 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11672 int arg2 = (int) -1 ;
11673 bool arg3 = (bool) false ;
11674 bool result;
11675 void *argp1 = 0 ;
11676 int res1 = 0 ;
11677 int val2 ;
11678 int ecode2 = 0 ;
11679 bool val3 ;
11680 int ecode3 = 0 ;
11681 PyObject * obj0 = 0 ;
11682 PyObject * obj1 = 0 ;
11683 PyObject * obj2 = 0 ;
11684 char * kwnames[] = {
11685 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11686 };
11687
11688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11690 if (!SWIG_IsOK(res1)) {
11691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11692 }
11693 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11694 if (obj1) {
11695 ecode2 = SWIG_AsVal_int(obj1, &val2);
11696 if (!SWIG_IsOK(ecode2)) {
11697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11698 }
11699 arg2 = static_cast< int >(val2);
11700 }
11701 if (obj2) {
11702 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11703 if (!SWIG_IsOK(ecode3)) {
11704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11705 }
11706 arg3 = static_cast< bool >(val3);
11707 }
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (bool)(arg1)->Start(arg2,arg3);
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11716 }
11717 return resultobj;
11718 fail:
11719 return NULL;
11720 }
11721
11722
11723 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 PyObject *resultobj = 0;
11725 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 if (!args) SWIG_fail;
11731 swig_obj[0] = args;
11732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11735 }
11736 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 (arg1)->Stop();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 resultobj = SWIG_Py_Void();
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11753 void *argp1 = 0 ;
11754 int res1 = 0 ;
11755 PyObject *swig_obj[1] ;
11756
11757 if (!args) SWIG_fail;
11758 swig_obj[0] = args;
11759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11760 if (!SWIG_IsOK(res1)) {
11761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11762 }
11763 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11764 {
11765 PyThreadState* __tstate = wxPyBeginAllowThreads();
11766 (arg1)->Notify();
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 resultobj = SWIG_Py_Void();
11771 return resultobj;
11772 fail:
11773 return NULL;
11774 }
11775
11776
11777 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11778 PyObject *resultobj = 0;
11779 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11780 bool result;
11781 void *argp1 = 0 ;
11782 int res1 = 0 ;
11783 PyObject *swig_obj[1] ;
11784
11785 if (!args) SWIG_fail;
11786 swig_obj[0] = args;
11787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11788 if (!SWIG_IsOK(res1)) {
11789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11790 }
11791 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11792 {
11793 PyThreadState* __tstate = wxPyBeginAllowThreads();
11794 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11795 wxPyEndAllowThreads(__tstate);
11796 if (PyErr_Occurred()) SWIG_fail;
11797 }
11798 {
11799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11800 }
11801 return resultobj;
11802 fail:
11803 return NULL;
11804 }
11805
11806
11807 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11808 PyObject *resultobj = 0;
11809 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11810 int result;
11811 void *argp1 = 0 ;
11812 int res1 = 0 ;
11813 PyObject *swig_obj[1] ;
11814
11815 if (!args) SWIG_fail;
11816 swig_obj[0] = args;
11817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11820 }
11821 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 resultobj = SWIG_From_int(static_cast< int >(result));
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 PyObject *resultobj = 0;
11837 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11838 int result;
11839 void *argp1 = 0 ;
11840 int res1 = 0 ;
11841 PyObject *swig_obj[1] ;
11842
11843 if (!args) SWIG_fail;
11844 swig_obj[0] = args;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11848 }
11849 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (int)((wxPyTimer const *)arg1)->GetId();
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 resultobj = SWIG_From_int(static_cast< int >(result));
11857 return resultobj;
11858 fail:
11859 return NULL;
11860 }
11861
11862
11863 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11864 PyObject *resultobj = 0;
11865 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11866 bool result;
11867 void *argp1 = 0 ;
11868 int res1 = 0 ;
11869 PyObject *swig_obj[1] ;
11870
11871 if (!args) SWIG_fail;
11872 swig_obj[0] = args;
11873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11874 if (!SWIG_IsOK(res1)) {
11875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11876 }
11877 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11881 wxPyEndAllowThreads(__tstate);
11882 if (PyErr_Occurred()) SWIG_fail;
11883 }
11884 {
11885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11886 }
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 PyObject *obj;
11895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11896 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11897 return SWIG_Py_Void();
11898 }
11899
11900 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11901 return SWIG_Python_InitShadowInstance(args);
11902 }
11903
11904 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj = 0;
11906 int arg1 = (int) 0 ;
11907 int arg2 = (int) 0 ;
11908 wxTimerEvent *result = 0 ;
11909 int val1 ;
11910 int ecode1 = 0 ;
11911 int val2 ;
11912 int ecode2 = 0 ;
11913 PyObject * obj0 = 0 ;
11914 PyObject * obj1 = 0 ;
11915 char * kwnames[] = {
11916 (char *) "timerid",(char *) "interval", NULL
11917 };
11918
11919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11920 if (obj0) {
11921 ecode1 = SWIG_AsVal_int(obj0, &val1);
11922 if (!SWIG_IsOK(ecode1)) {
11923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11924 }
11925 arg1 = static_cast< int >(val1);
11926 }
11927 if (obj1) {
11928 ecode2 = SWIG_AsVal_int(obj1, &val2);
11929 if (!SWIG_IsOK(ecode2)) {
11930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11931 }
11932 arg2 = static_cast< int >(val2);
11933 }
11934 {
11935 PyThreadState* __tstate = wxPyBeginAllowThreads();
11936 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11948 PyObject *resultobj = 0;
11949 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11950 int result;
11951 void *argp1 = 0 ;
11952 int res1 = 0 ;
11953 PyObject *swig_obj[1] ;
11954
11955 if (!args) SWIG_fail;
11956 swig_obj[0] = args;
11957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11958 if (!SWIG_IsOK(res1)) {
11959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11960 }
11961 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11962 {
11963 PyThreadState* __tstate = wxPyBeginAllowThreads();
11964 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11965 wxPyEndAllowThreads(__tstate);
11966 if (PyErr_Occurred()) SWIG_fail;
11967 }
11968 resultobj = SWIG_From_int(static_cast< int >(result));
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11976 PyObject *obj;
11977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11978 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11979 return SWIG_Py_Void();
11980 }
11981
11982 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11983 return SWIG_Python_InitShadowInstance(args);
11984 }
11985
11986 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11987 PyObject *resultobj = 0;
11988 wxTimer *arg1 = 0 ;
11989 wxTimerRunner *result = 0 ;
11990 void *argp1 = 0 ;
11991 int res1 = 0 ;
11992
11993 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11995 if (!SWIG_IsOK(res1)) {
11996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11997 }
11998 if (!argp1) {
11999 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12000 }
12001 arg1 = reinterpret_cast< wxTimer * >(argp1);
12002 {
12003 if (!wxPyCheckForApp()) SWIG_fail;
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12006 wxPyEndAllowThreads(__tstate);
12007 if (PyErr_Occurred()) SWIG_fail;
12008 }
12009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12010 return resultobj;
12011 fail:
12012 return NULL;
12013 }
12014
12015
12016 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12017 PyObject *resultobj = 0;
12018 wxTimer *arg1 = 0 ;
12019 int arg2 ;
12020 bool arg3 = (bool) false ;
12021 wxTimerRunner *result = 0 ;
12022 void *argp1 = 0 ;
12023 int res1 = 0 ;
12024 int val2 ;
12025 int ecode2 = 0 ;
12026 bool val3 ;
12027 int ecode3 = 0 ;
12028
12029 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12031 if (!SWIG_IsOK(res1)) {
12032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12033 }
12034 if (!argp1) {
12035 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12036 }
12037 arg1 = reinterpret_cast< wxTimer * >(argp1);
12038 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12039 if (!SWIG_IsOK(ecode2)) {
12040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12041 }
12042 arg2 = static_cast< int >(val2);
12043 if (swig_obj[2]) {
12044 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12045 if (!SWIG_IsOK(ecode3)) {
12046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12047 }
12048 arg3 = static_cast< bool >(val3);
12049 }
12050 {
12051 if (!wxPyCheckForApp()) SWIG_fail;
12052 PyThreadState* __tstate = wxPyBeginAllowThreads();
12053 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12054 wxPyEndAllowThreads(__tstate);
12055 if (PyErr_Occurred()) SWIG_fail;
12056 }
12057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12058 return resultobj;
12059 fail:
12060 return NULL;
12061 }
12062
12063
12064 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12065 int argc;
12066 PyObject *argv[4];
12067
12068 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12069 --argc;
12070 if (argc == 1) {
12071 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12072 }
12073 if ((argc >= 2) && (argc <= 3)) {
12074 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12075 }
12076
12077 fail:
12078 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12079 return NULL;
12080 }
12081
12082
12083 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12084 PyObject *resultobj = 0;
12085 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12086 void *argp1 = 0 ;
12087 int res1 = 0 ;
12088 PyObject *swig_obj[1] ;
12089
12090 if (!args) SWIG_fail;
12091 swig_obj[0] = args;
12092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12093 if (!SWIG_IsOK(res1)) {
12094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12095 }
12096 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 delete arg1;
12100
12101 wxPyEndAllowThreads(__tstate);
12102 if (PyErr_Occurred()) SWIG_fail;
12103 }
12104 resultobj = SWIG_Py_Void();
12105 return resultobj;
12106 fail:
12107 return NULL;
12108 }
12109
12110
12111 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12112 PyObject *resultobj = 0;
12113 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12114 int arg2 ;
12115 bool arg3 = (bool) false ;
12116 void *argp1 = 0 ;
12117 int res1 = 0 ;
12118 int val2 ;
12119 int ecode2 = 0 ;
12120 bool val3 ;
12121 int ecode3 = 0 ;
12122 PyObject * obj0 = 0 ;
12123 PyObject * obj1 = 0 ;
12124 PyObject * obj2 = 0 ;
12125 char * kwnames[] = {
12126 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12127 };
12128
12129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12131 if (!SWIG_IsOK(res1)) {
12132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12133 }
12134 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12135 ecode2 = SWIG_AsVal_int(obj1, &val2);
12136 if (!SWIG_IsOK(ecode2)) {
12137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12138 }
12139 arg2 = static_cast< int >(val2);
12140 if (obj2) {
12141 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12142 if (!SWIG_IsOK(ecode3)) {
12143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12144 }
12145 arg3 = static_cast< bool >(val3);
12146 }
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 (arg1)->Start(arg2,arg3);
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 resultobj = SWIG_Py_Void();
12154 return resultobj;
12155 fail:
12156 return NULL;
12157 }
12158
12159
12160 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12161 PyObject *obj;
12162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12163 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12164 return SWIG_Py_Void();
12165 }
12166
12167 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12168 return SWIG_Python_InitShadowInstance(args);
12169 }
12170
12171 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *resultobj = 0;
12173 wxLog *result = 0 ;
12174
12175 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12176 {
12177 PyThreadState* __tstate = wxPyBeginAllowThreads();
12178 result = (wxLog *)new wxLog();
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12190 PyObject *resultobj = 0;
12191 wxLog *arg1 = (wxLog *) 0 ;
12192 void *argp1 = 0 ;
12193 int res1 = 0 ;
12194 PyObject *swig_obj[1] ;
12195
12196 if (!args) SWIG_fail;
12197 swig_obj[0] = args;
12198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12199 if (!SWIG_IsOK(res1)) {
12200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12201 }
12202 arg1 = reinterpret_cast< wxLog * >(argp1);
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 delete arg1;
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 resultobj = SWIG_Py_Void();
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12218 PyObject *resultobj = 0;
12219 bool result;
12220
12221 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12222 {
12223 PyThreadState* __tstate = wxPyBeginAllowThreads();
12224 result = (bool)wxLog::IsEnabled();
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 {
12229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12230 }
12231 return resultobj;
12232 fail:
12233 return NULL;
12234 }
12235
12236
12237 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12238 PyObject *resultobj = 0;
12239 bool arg1 = (bool) true ;
12240 bool result;
12241 bool val1 ;
12242 int ecode1 = 0 ;
12243 PyObject * obj0 = 0 ;
12244 char * kwnames[] = {
12245 (char *) "doIt", NULL
12246 };
12247
12248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12249 if (obj0) {
12250 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12251 if (!SWIG_IsOK(ecode1)) {
12252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12253 }
12254 arg1 = static_cast< bool >(val1);
12255 }
12256 {
12257 PyThreadState* __tstate = wxPyBeginAllowThreads();
12258 result = (bool)wxLog::EnableLogging(arg1);
12259 wxPyEndAllowThreads(__tstate);
12260 if (PyErr_Occurred()) SWIG_fail;
12261 }
12262 {
12263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12264 }
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj = 0;
12273 wxLogLevel arg1 ;
12274 wxChar *arg2 = (wxChar *) 0 ;
12275 time_t arg3 ;
12276 unsigned long val1 ;
12277 int ecode1 = 0 ;
12278 void *argp2 = 0 ;
12279 int res2 = 0 ;
12280 unsigned int val3 ;
12281 int ecode3 = 0 ;
12282 PyObject * obj0 = 0 ;
12283 PyObject * obj1 = 0 ;
12284 PyObject * obj2 = 0 ;
12285 char * kwnames[] = {
12286 (char *) "level",(char *) "szString",(char *) "t", NULL
12287 };
12288
12289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12290 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12291 if (!SWIG_IsOK(ecode1)) {
12292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12293 }
12294 arg1 = static_cast< wxLogLevel >(val1);
12295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12296 if (!SWIG_IsOK(res2)) {
12297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12298 }
12299 arg2 = reinterpret_cast< wxChar * >(argp2);
12300 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12301 if (!SWIG_IsOK(ecode3)) {
12302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12303 }
12304 arg3 = static_cast< time_t >(val3);
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 resultobj = SWIG_Py_Void();
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12319 PyObject *resultobj = 0;
12320 wxLog *arg1 = (wxLog *) 0 ;
12321 void *argp1 = 0 ;
12322 int res1 = 0 ;
12323 PyObject *swig_obj[1] ;
12324
12325 if (!args) SWIG_fail;
12326 swig_obj[0] = args;
12327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12328 if (!SWIG_IsOK(res1)) {
12329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12330 }
12331 arg1 = reinterpret_cast< wxLog * >(argp1);
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 (arg1)->Flush();
12335 wxPyEndAllowThreads(__tstate);
12336 if (PyErr_Occurred()) SWIG_fail;
12337 }
12338 resultobj = SWIG_Py_Void();
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12346 PyObject *resultobj = 0;
12347
12348 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 wxLog::FlushActive();
12352 wxPyEndAllowThreads(__tstate);
12353 if (PyErr_Occurred()) SWIG_fail;
12354 }
12355 resultobj = SWIG_Py_Void();
12356 return resultobj;
12357 fail:
12358 return NULL;
12359 }
12360
12361
12362 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12363 PyObject *resultobj = 0;
12364 wxLog *result = 0 ;
12365
12366 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 result = (wxLog *)wxLog::GetActiveTarget();
12370 wxPyEndAllowThreads(__tstate);
12371 if (PyErr_Occurred()) SWIG_fail;
12372 }
12373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12381 PyObject *resultobj = 0;
12382 wxLog *arg1 = (wxLog *) 0 ;
12383 wxLog *result = 0 ;
12384 int res1 = 0 ;
12385 PyObject * obj0 = 0 ;
12386 char * kwnames[] = {
12387 (char *) "pLogger", NULL
12388 };
12389
12390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12391 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12392 if (!SWIG_IsOK(res1)) {
12393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12394 }
12395 {
12396 PyThreadState* __tstate = wxPyBeginAllowThreads();
12397 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12398 wxPyEndAllowThreads(__tstate);
12399 if (PyErr_Occurred()) SWIG_fail;
12400 }
12401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12402 return resultobj;
12403 fail:
12404 return NULL;
12405 }
12406
12407
12408 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12409 PyObject *resultobj = 0;
12410
12411 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12412 {
12413 PyThreadState* __tstate = wxPyBeginAllowThreads();
12414 wxLog::Suspend();
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 resultobj = SWIG_Py_Void();
12419 return resultobj;
12420 fail:
12421 return NULL;
12422 }
12423
12424
12425 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12426 PyObject *resultobj = 0;
12427
12428 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 wxLog::Resume();
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_Py_Void();
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12443 PyObject *resultobj = 0;
12444 bool arg1 = (bool) true ;
12445 bool val1 ;
12446 int ecode1 = 0 ;
12447 PyObject * obj0 = 0 ;
12448 char * kwnames[] = {
12449 (char *) "bVerbose", NULL
12450 };
12451
12452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12453 if (obj0) {
12454 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12455 if (!SWIG_IsOK(ecode1)) {
12456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12457 }
12458 arg1 = static_cast< bool >(val1);
12459 }
12460 {
12461 PyThreadState* __tstate = wxPyBeginAllowThreads();
12462 wxLog::SetVerbose(arg1);
12463 wxPyEndAllowThreads(__tstate);
12464 if (PyErr_Occurred()) SWIG_fail;
12465 }
12466 resultobj = SWIG_Py_Void();
12467 return resultobj;
12468 fail:
12469 return NULL;
12470 }
12471
12472
12473 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12474 PyObject *resultobj = 0;
12475 wxLogLevel arg1 ;
12476 unsigned long val1 ;
12477 int ecode1 = 0 ;
12478 PyObject * obj0 = 0 ;
12479 char * kwnames[] = {
12480 (char *) "logLevel", NULL
12481 };
12482
12483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12484 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12485 if (!SWIG_IsOK(ecode1)) {
12486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12487 }
12488 arg1 = static_cast< wxLogLevel >(val1);
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 wxLog::SetLogLevel(arg1);
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 resultobj = SWIG_Py_Void();
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12503 PyObject *resultobj = 0;
12504
12505 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12506 {
12507 PyThreadState* __tstate = wxPyBeginAllowThreads();
12508 wxLog::DontCreateOnDemand();
12509 wxPyEndAllowThreads(__tstate);
12510 if (PyErr_Occurred()) SWIG_fail;
12511 }
12512 resultobj = SWIG_Py_Void();
12513 return resultobj;
12514 fail:
12515 return NULL;
12516 }
12517
12518
12519 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj = 0;
12521 bool arg1 = (bool) true ;
12522 bool val1 ;
12523 int ecode1 = 0 ;
12524 PyObject * obj0 = 0 ;
12525 char * kwnames[] = {
12526 (char *) "bRepetCounting", NULL
12527 };
12528
12529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12530 if (obj0) {
12531 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12532 if (!SWIG_IsOK(ecode1)) {
12533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12534 }
12535 arg1 = static_cast< bool >(val1);
12536 }
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 wxLog::SetRepetitionCounting(arg1);
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 resultobj = SWIG_Py_Void();
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12551 PyObject *resultobj = 0;
12552 bool result;
12553
12554 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12555 {
12556 PyThreadState* __tstate = wxPyBeginAllowThreads();
12557 result = (bool)wxLog::GetRepetitionCounting();
12558 wxPyEndAllowThreads(__tstate);
12559 if (PyErr_Occurred()) SWIG_fail;
12560 }
12561 {
12562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12563 }
12564 return resultobj;
12565 fail:
12566 return NULL;
12567 }
12568
12569
12570 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12571 PyObject *resultobj = 0;
12572 wxTraceMask arg1 ;
12573 unsigned long val1 ;
12574 int ecode1 = 0 ;
12575 PyObject * obj0 = 0 ;
12576 char * kwnames[] = {
12577 (char *) "ulMask", NULL
12578 };
12579
12580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12581 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12582 if (!SWIG_IsOK(ecode1)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12584 }
12585 arg1 = static_cast< wxTraceMask >(val1);
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 wxLog::SetTraceMask(arg1);
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 resultobj = SWIG_Py_Void();
12593 return resultobj;
12594 fail:
12595 return NULL;
12596 }
12597
12598
12599 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12600 PyObject *resultobj = 0;
12601 wxString *arg1 = 0 ;
12602 bool temp1 = false ;
12603 PyObject * obj0 = 0 ;
12604 char * kwnames[] = {
12605 (char *) "str", NULL
12606 };
12607
12608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12609 {
12610 arg1 = wxString_in_helper(obj0);
12611 if (arg1 == NULL) SWIG_fail;
12612 temp1 = true;
12613 }
12614 {
12615 PyThreadState* __tstate = wxPyBeginAllowThreads();
12616 wxLog::AddTraceMask((wxString const &)*arg1);
12617 wxPyEndAllowThreads(__tstate);
12618 if (PyErr_Occurred()) SWIG_fail;
12619 }
12620 resultobj = SWIG_Py_Void();
12621 {
12622 if (temp1)
12623 delete arg1;
12624 }
12625 return resultobj;
12626 fail:
12627 {
12628 if (temp1)
12629 delete arg1;
12630 }
12631 return NULL;
12632 }
12633
12634
12635 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12636 PyObject *resultobj = 0;
12637 wxString *arg1 = 0 ;
12638 bool temp1 = false ;
12639 PyObject * obj0 = 0 ;
12640 char * kwnames[] = {
12641 (char *) "str", NULL
12642 };
12643
12644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12645 {
12646 arg1 = wxString_in_helper(obj0);
12647 if (arg1 == NULL) SWIG_fail;
12648 temp1 = true;
12649 }
12650 {
12651 PyThreadState* __tstate = wxPyBeginAllowThreads();
12652 wxLog::RemoveTraceMask((wxString const &)*arg1);
12653 wxPyEndAllowThreads(__tstate);
12654 if (PyErr_Occurred()) SWIG_fail;
12655 }
12656 resultobj = SWIG_Py_Void();
12657 {
12658 if (temp1)
12659 delete arg1;
12660 }
12661 return resultobj;
12662 fail:
12663 {
12664 if (temp1)
12665 delete arg1;
12666 }
12667 return NULL;
12668 }
12669
12670
12671 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12672 PyObject *resultobj = 0;
12673
12674 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 wxLog::ClearTraceMasks();
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 resultobj = SWIG_Py_Void();
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12689 PyObject *resultobj = 0;
12690 wxArrayString *result = 0 ;
12691
12692 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12693 {
12694 PyThreadState* __tstate = wxPyBeginAllowThreads();
12695 {
12696 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12697 result = (wxArrayString *) &_result_ref;
12698 }
12699 wxPyEndAllowThreads(__tstate);
12700 if (PyErr_Occurred()) SWIG_fail;
12701 }
12702 {
12703 resultobj = wxArrayString2PyList_helper(*result);
12704 }
12705 return resultobj;
12706 fail:
12707 return NULL;
12708 }
12709
12710
12711 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12712 PyObject *resultobj = 0;
12713 wxChar *arg1 = (wxChar *) 0 ;
12714 void *argp1 = 0 ;
12715 int res1 = 0 ;
12716 PyObject * obj0 = 0 ;
12717 char * kwnames[] = {
12718 (char *) "ts", NULL
12719 };
12720
12721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12723 if (!SWIG_IsOK(res1)) {
12724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12725 }
12726 arg1 = reinterpret_cast< wxChar * >(argp1);
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 wxLog::SetTimestamp((wxChar const *)arg1);
12730 wxPyEndAllowThreads(__tstate);
12731 if (PyErr_Occurred()) SWIG_fail;
12732 }
12733 resultobj = SWIG_Py_Void();
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12741 PyObject *resultobj = 0;
12742 bool result;
12743
12744 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12745 {
12746 PyThreadState* __tstate = wxPyBeginAllowThreads();
12747 result = (bool)wxLog::GetVerbose();
12748 wxPyEndAllowThreads(__tstate);
12749 if (PyErr_Occurred()) SWIG_fail;
12750 }
12751 {
12752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12753 }
12754 return resultobj;
12755 fail:
12756 return NULL;
12757 }
12758
12759
12760 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12761 PyObject *resultobj = 0;
12762 wxTraceMask result;
12763
12764 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 result = (wxTraceMask)wxLog::GetTraceMask();
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12779 PyObject *resultobj = 0;
12780 wxChar *arg1 = (wxChar *) 0 ;
12781 bool result;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 PyObject * obj0 = 0 ;
12785 char * kwnames[] = {
12786 (char *) "mask", NULL
12787 };
12788
12789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12791 if (!SWIG_IsOK(res1)) {
12792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12793 }
12794 arg1 = reinterpret_cast< wxChar * >(argp1);
12795 {
12796 PyThreadState* __tstate = wxPyBeginAllowThreads();
12797 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12798 wxPyEndAllowThreads(__tstate);
12799 if (PyErr_Occurred()) SWIG_fail;
12800 }
12801 {
12802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12803 }
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12811 PyObject *resultobj = 0;
12812 wxLogLevel result;
12813
12814 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 result = (wxLogLevel)wxLog::GetLogLevel();
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12829 PyObject *resultobj = 0;
12830 wxChar *result = 0 ;
12831
12832 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12833 {
12834 PyThreadState* __tstate = wxPyBeginAllowThreads();
12835 result = (wxChar *)wxLog::GetTimestamp();
12836 wxPyEndAllowThreads(__tstate);
12837 if (PyErr_Occurred()) SWIG_fail;
12838 }
12839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12840 return resultobj;
12841 fail:
12842 return NULL;
12843 }
12844
12845
12846 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12847 PyObject *resultobj = 0;
12848 wxString result;
12849
12850 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12851 {
12852 PyThreadState* __tstate = wxPyBeginAllowThreads();
12853 result = wxLog_TimeStamp();
12854 wxPyEndAllowThreads(__tstate);
12855 if (PyErr_Occurred()) SWIG_fail;
12856 }
12857 {
12858 #if wxUSE_UNICODE
12859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12860 #else
12861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12862 #endif
12863 }
12864 return resultobj;
12865 fail:
12866 return NULL;
12867 }
12868
12869
12870 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12871 PyObject *resultobj = 0;
12872 wxLog *arg1 = (wxLog *) 0 ;
12873 void *argp1 = 0 ;
12874 int res1 = 0 ;
12875 PyObject *swig_obj[1] ;
12876
12877 if (!args) SWIG_fail;
12878 swig_obj[0] = args;
12879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12880 if (!SWIG_IsOK(res1)) {
12881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12882 }
12883 arg1 = reinterpret_cast< wxLog * >(argp1);
12884 {
12885 PyThreadState* __tstate = wxPyBeginAllowThreads();
12886 wxLog_Destroy(arg1);
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 resultobj = SWIG_Py_Void();
12891 return resultobj;
12892 fail:
12893 return NULL;
12894 }
12895
12896
12897 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12898 PyObject *obj;
12899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12900 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12901 return SWIG_Py_Void();
12902 }
12903
12904 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12905 return SWIG_Python_InitShadowInstance(args);
12906 }
12907
12908 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *resultobj = 0;
12910 wxLogStderr *result = 0 ;
12911
12912 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12913 {
12914 PyThreadState* __tstate = wxPyBeginAllowThreads();
12915 result = (wxLogStderr *)new wxLogStderr();
12916 wxPyEndAllowThreads(__tstate);
12917 if (PyErr_Occurred()) SWIG_fail;
12918 }
12919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12927 PyObject *obj;
12928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12929 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12930 return SWIG_Py_Void();
12931 }
12932
12933 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12934 return SWIG_Python_InitShadowInstance(args);
12935 }
12936
12937 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12938 PyObject *resultobj = 0;
12939 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12940 wxLogTextCtrl *result = 0 ;
12941 void *argp1 = 0 ;
12942 int res1 = 0 ;
12943 PyObject * obj0 = 0 ;
12944 char * kwnames[] = {
12945 (char *) "pTextCtrl", NULL
12946 };
12947
12948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12950 if (!SWIG_IsOK(res1)) {
12951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12952 }
12953 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12954 {
12955 PyThreadState* __tstate = wxPyBeginAllowThreads();
12956 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12957 wxPyEndAllowThreads(__tstate);
12958 if (PyErr_Occurred()) SWIG_fail;
12959 }
12960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12961 return resultobj;
12962 fail:
12963 return NULL;
12964 }
12965
12966
12967 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 PyObject *obj;
12969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12970 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12971 return SWIG_Py_Void();
12972 }
12973
12974 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12975 return SWIG_Python_InitShadowInstance(args);
12976 }
12977
12978 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12979 PyObject *resultobj = 0;
12980 wxLogGui *result = 0 ;
12981
12982 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12983 {
12984 PyThreadState* __tstate = wxPyBeginAllowThreads();
12985 result = (wxLogGui *)new wxLogGui();
12986 wxPyEndAllowThreads(__tstate);
12987 if (PyErr_Occurred()) SWIG_fail;
12988 }
12989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12990 return resultobj;
12991 fail:
12992 return NULL;
12993 }
12994
12995
12996 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 PyObject *obj;
12998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12999 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
13000 return SWIG_Py_Void();
13001 }
13002
13003 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13004 return SWIG_Python_InitShadowInstance(args);
13005 }
13006
13007 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13008 PyObject *resultobj = 0;
13009 wxFrame *arg1 = (wxFrame *) 0 ;
13010 wxString *arg2 = 0 ;
13011 bool arg3 = (bool) true ;
13012 bool arg4 = (bool) true ;
13013 wxLogWindow *result = 0 ;
13014 void *argp1 = 0 ;
13015 int res1 = 0 ;
13016 bool temp2 = false ;
13017 bool val3 ;
13018 int ecode3 = 0 ;
13019 bool val4 ;
13020 int ecode4 = 0 ;
13021 PyObject * obj0 = 0 ;
13022 PyObject * obj1 = 0 ;
13023 PyObject * obj2 = 0 ;
13024 PyObject * obj3 = 0 ;
13025 char * kwnames[] = {
13026 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13027 };
13028
13029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13031 if (!SWIG_IsOK(res1)) {
13032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13033 }
13034 arg1 = reinterpret_cast< wxFrame * >(argp1);
13035 {
13036 arg2 = wxString_in_helper(obj1);
13037 if (arg2 == NULL) SWIG_fail;
13038 temp2 = true;
13039 }
13040 if (obj2) {
13041 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13042 if (!SWIG_IsOK(ecode3)) {
13043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13044 }
13045 arg3 = static_cast< bool >(val3);
13046 }
13047 if (obj3) {
13048 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13049 if (!SWIG_IsOK(ecode4)) {
13050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13051 }
13052 arg4 = static_cast< bool >(val4);
13053 }
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13061 {
13062 if (temp2)
13063 delete arg2;
13064 }
13065 return resultobj;
13066 fail:
13067 {
13068 if (temp2)
13069 delete arg2;
13070 }
13071 return NULL;
13072 }
13073
13074
13075 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13076 PyObject *resultobj = 0;
13077 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13078 bool arg2 = (bool) true ;
13079 void *argp1 = 0 ;
13080 int res1 = 0 ;
13081 bool val2 ;
13082 int ecode2 = 0 ;
13083 PyObject * obj0 = 0 ;
13084 PyObject * obj1 = 0 ;
13085 char * kwnames[] = {
13086 (char *) "self",(char *) "bShow", NULL
13087 };
13088
13089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13091 if (!SWIG_IsOK(res1)) {
13092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13093 }
13094 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13095 if (obj1) {
13096 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13097 if (!SWIG_IsOK(ecode2)) {
13098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13099 }
13100 arg2 = static_cast< bool >(val2);
13101 }
13102 {
13103 PyThreadState* __tstate = wxPyBeginAllowThreads();
13104 (arg1)->Show(arg2);
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 resultobj = SWIG_Py_Void();
13109 return resultobj;
13110 fail:
13111 return NULL;
13112 }
13113
13114
13115 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13116 PyObject *resultobj = 0;
13117 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13118 wxFrame *result = 0 ;
13119 void *argp1 = 0 ;
13120 int res1 = 0 ;
13121 PyObject *swig_obj[1] ;
13122
13123 if (!args) SWIG_fail;
13124 swig_obj[0] = args;
13125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13126 if (!SWIG_IsOK(res1)) {
13127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13128 }
13129 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13130 {
13131 PyThreadState* __tstate = wxPyBeginAllowThreads();
13132 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 {
13137 resultobj = wxPyMake_wxObject(result, (bool)0);
13138 }
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13146 PyObject *resultobj = 0;
13147 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13148 wxLog *result = 0 ;
13149 void *argp1 = 0 ;
13150 int res1 = 0 ;
13151 PyObject *swig_obj[1] ;
13152
13153 if (!args) SWIG_fail;
13154 swig_obj[0] = args;
13155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13156 if (!SWIG_IsOK(res1)) {
13157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13158 }
13159 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13160 {
13161 PyThreadState* __tstate = wxPyBeginAllowThreads();
13162 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13174 PyObject *resultobj = 0;
13175 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13176 bool result;
13177 void *argp1 = 0 ;
13178 int res1 = 0 ;
13179 PyObject *swig_obj[1] ;
13180
13181 if (!args) SWIG_fail;
13182 swig_obj[0] = args;
13183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13184 if (!SWIG_IsOK(res1)) {
13185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13186 }
13187 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 {
13195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13196 }
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj = 0;
13205 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13206 bool arg2 ;
13207 void *argp1 = 0 ;
13208 int res1 = 0 ;
13209 bool val2 ;
13210 int ecode2 = 0 ;
13211 PyObject * obj0 = 0 ;
13212 PyObject * obj1 = 0 ;
13213 char * kwnames[] = {
13214 (char *) "self",(char *) "bDoPass", NULL
13215 };
13216
13217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13219 if (!SWIG_IsOK(res1)) {
13220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13221 }
13222 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13224 if (!SWIG_IsOK(ecode2)) {
13225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13226 }
13227 arg2 = static_cast< bool >(val2);
13228 {
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 (arg1)->PassMessages(arg2);
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 resultobj = SWIG_Py_Void();
13235 return resultobj;
13236 fail:
13237 return NULL;
13238 }
13239
13240
13241 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13242 PyObject *obj;
13243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13244 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13245 return SWIG_Py_Void();
13246 }
13247
13248 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13249 return SWIG_Python_InitShadowInstance(args);
13250 }
13251
13252 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13253 PyObject *resultobj = 0;
13254 wxLog *arg1 = (wxLog *) 0 ;
13255 wxLogChain *result = 0 ;
13256 void *argp1 = 0 ;
13257 int res1 = 0 ;
13258 PyObject * obj0 = 0 ;
13259 char * kwnames[] = {
13260 (char *) "logger", NULL
13261 };
13262
13263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13265 if (!SWIG_IsOK(res1)) {
13266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13267 }
13268 arg1 = reinterpret_cast< wxLog * >(argp1);
13269 {
13270 PyThreadState* __tstate = wxPyBeginAllowThreads();
13271 result = (wxLogChain *)new wxLogChain(arg1);
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj = 0;
13284 wxLogChain *arg1 = (wxLogChain *) 0 ;
13285 wxLog *arg2 = (wxLog *) 0 ;
13286 void *argp1 = 0 ;
13287 int res1 = 0 ;
13288 void *argp2 = 0 ;
13289 int res2 = 0 ;
13290 PyObject * obj0 = 0 ;
13291 PyObject * obj1 = 0 ;
13292 char * kwnames[] = {
13293 (char *) "self",(char *) "logger", NULL
13294 };
13295
13296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13298 if (!SWIG_IsOK(res1)) {
13299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13300 }
13301 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13303 if (!SWIG_IsOK(res2)) {
13304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13305 }
13306 arg2 = reinterpret_cast< wxLog * >(argp2);
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 (arg1)->SetLog(arg2);
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 resultobj = SWIG_Py_Void();
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj = 0;
13322 wxLogChain *arg1 = (wxLogChain *) 0 ;
13323 bool arg2 ;
13324 void *argp1 = 0 ;
13325 int res1 = 0 ;
13326 bool val2 ;
13327 int ecode2 = 0 ;
13328 PyObject * obj0 = 0 ;
13329 PyObject * obj1 = 0 ;
13330 char * kwnames[] = {
13331 (char *) "self",(char *) "bDoPass", NULL
13332 };
13333
13334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13336 if (!SWIG_IsOK(res1)) {
13337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13338 }
13339 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13340 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13341 if (!SWIG_IsOK(ecode2)) {
13342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13343 }
13344 arg2 = static_cast< bool >(val2);
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 (arg1)->PassMessages(arg2);
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 resultobj = SWIG_Py_Void();
13352 return resultobj;
13353 fail:
13354 return NULL;
13355 }
13356
13357
13358 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13359 PyObject *resultobj = 0;
13360 wxLogChain *arg1 = (wxLogChain *) 0 ;
13361 bool result;
13362 void *argp1 = 0 ;
13363 int res1 = 0 ;
13364 PyObject *swig_obj[1] ;
13365
13366 if (!args) SWIG_fail;
13367 swig_obj[0] = args;
13368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13369 if (!SWIG_IsOK(res1)) {
13370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13371 }
13372 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13373 {
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 result = (bool)(arg1)->IsPassingMessages();
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 {
13380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13381 }
13382 return resultobj;
13383 fail:
13384 return NULL;
13385 }
13386
13387
13388 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13389 PyObject *resultobj = 0;
13390 wxLogChain *arg1 = (wxLogChain *) 0 ;
13391 wxLog *result = 0 ;
13392 void *argp1 = 0 ;
13393 int res1 = 0 ;
13394 PyObject *swig_obj[1] ;
13395
13396 if (!args) SWIG_fail;
13397 swig_obj[0] = args;
13398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13399 if (!SWIG_IsOK(res1)) {
13400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13401 }
13402 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13403 {
13404 PyThreadState* __tstate = wxPyBeginAllowThreads();
13405 result = (wxLog *)(arg1)->GetOldLog();
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13410 return resultobj;
13411 fail:
13412 return NULL;
13413 }
13414
13415
13416 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13417 PyObject *obj;
13418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13419 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13420 return SWIG_Py_Void();
13421 }
13422
13423 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13424 return SWIG_Python_InitShadowInstance(args);
13425 }
13426
13427 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13428 PyObject *resultobj = 0;
13429 wxLogBuffer *result = 0 ;
13430
13431 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13432 {
13433 PyThreadState* __tstate = wxPyBeginAllowThreads();
13434 result = (wxLogBuffer *)new wxLogBuffer();
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13446 PyObject *resultobj = 0;
13447 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13448 wxString *result = 0 ;
13449 void *argp1 = 0 ;
13450 int res1 = 0 ;
13451 PyObject *swig_obj[1] ;
13452
13453 if (!args) SWIG_fail;
13454 swig_obj[0] = args;
13455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13456 if (!SWIG_IsOK(res1)) {
13457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13458 }
13459 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 {
13463 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13464 result = (wxString *) &_result_ref;
13465 }
13466 wxPyEndAllowThreads(__tstate);
13467 if (PyErr_Occurred()) SWIG_fail;
13468 }
13469 {
13470 #if wxUSE_UNICODE
13471 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13472 #else
13473 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13474 #endif
13475 }
13476 return resultobj;
13477 fail:
13478 return NULL;
13479 }
13480
13481
13482 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13483 PyObject *obj;
13484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13485 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13486 return SWIG_Py_Void();
13487 }
13488
13489 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13490 return SWIG_Python_InitShadowInstance(args);
13491 }
13492
13493 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13494 PyObject *resultobj = 0;
13495 unsigned long result;
13496
13497 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13498 {
13499 PyThreadState* __tstate = wxPyBeginAllowThreads();
13500 result = (unsigned long)wxSysErrorCode();
13501 wxPyEndAllowThreads(__tstate);
13502 if (PyErr_Occurred()) SWIG_fail;
13503 }
13504 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13505 return resultobj;
13506 fail:
13507 return NULL;
13508 }
13509
13510
13511 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13512 PyObject *resultobj = 0;
13513 unsigned long arg1 = (unsigned long) 0 ;
13514 wxString result;
13515 unsigned long val1 ;
13516 int ecode1 = 0 ;
13517 PyObject * obj0 = 0 ;
13518 char * kwnames[] = {
13519 (char *) "nErrCode", NULL
13520 };
13521
13522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13523 if (obj0) {
13524 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13525 if (!SWIG_IsOK(ecode1)) {
13526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13527 }
13528 arg1 = static_cast< unsigned long >(val1);
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = wxSysErrorMsg(arg1);
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 {
13537 #if wxUSE_UNICODE
13538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13539 #else
13540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13541 #endif
13542 }
13543 return resultobj;
13544 fail:
13545 return NULL;
13546 }
13547
13548
13549 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13550 PyObject *resultobj = 0;
13551 wxString *arg1 = 0 ;
13552 bool temp1 = false ;
13553 PyObject * obj0 = 0 ;
13554 char * kwnames[] = {
13555 (char *) "msg", NULL
13556 };
13557
13558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13559 {
13560 arg1 = wxString_in_helper(obj0);
13561 if (arg1 == NULL) SWIG_fail;
13562 temp1 = true;
13563 }
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 wxPyLogFatalError((wxString const &)*arg1);
13567 wxPyEndAllowThreads(__tstate);
13568 if (PyErr_Occurred()) SWIG_fail;
13569 }
13570 resultobj = SWIG_Py_Void();
13571 {
13572 if (temp1)
13573 delete arg1;
13574 }
13575 return resultobj;
13576 fail:
13577 {
13578 if (temp1)
13579 delete arg1;
13580 }
13581 return NULL;
13582 }
13583
13584
13585 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj = 0;
13587 wxString *arg1 = 0 ;
13588 bool temp1 = false ;
13589 PyObject * obj0 = 0 ;
13590 char * kwnames[] = {
13591 (char *) "msg", NULL
13592 };
13593
13594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13595 {
13596 arg1 = wxString_in_helper(obj0);
13597 if (arg1 == NULL) SWIG_fail;
13598 temp1 = true;
13599 }
13600 {
13601 PyThreadState* __tstate = wxPyBeginAllowThreads();
13602 wxPyLogError((wxString const &)*arg1);
13603 wxPyEndAllowThreads(__tstate);
13604 if (PyErr_Occurred()) SWIG_fail;
13605 }
13606 resultobj = SWIG_Py_Void();
13607 {
13608 if (temp1)
13609 delete arg1;
13610 }
13611 return resultobj;
13612 fail:
13613 {
13614 if (temp1)
13615 delete arg1;
13616 }
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxString *arg1 = 0 ;
13624 bool temp1 = false ;
13625 PyObject * obj0 = 0 ;
13626 char * kwnames[] = {
13627 (char *) "msg", NULL
13628 };
13629
13630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13631 {
13632 arg1 = wxString_in_helper(obj0);
13633 if (arg1 == NULL) SWIG_fail;
13634 temp1 = true;
13635 }
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 wxPyLogWarning((wxString const &)*arg1);
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 resultobj = SWIG_Py_Void();
13643 {
13644 if (temp1)
13645 delete arg1;
13646 }
13647 return resultobj;
13648 fail:
13649 {
13650 if (temp1)
13651 delete arg1;
13652 }
13653 return NULL;
13654 }
13655
13656
13657 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj = 0;
13659 wxString *arg1 = 0 ;
13660 bool temp1 = false ;
13661 PyObject * obj0 = 0 ;
13662 char * kwnames[] = {
13663 (char *) "msg", NULL
13664 };
13665
13666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13667 {
13668 arg1 = wxString_in_helper(obj0);
13669 if (arg1 == NULL) SWIG_fail;
13670 temp1 = true;
13671 }
13672 {
13673 PyThreadState* __tstate = wxPyBeginAllowThreads();
13674 wxPyLogMessage((wxString const &)*arg1);
13675 wxPyEndAllowThreads(__tstate);
13676 if (PyErr_Occurred()) SWIG_fail;
13677 }
13678 resultobj = SWIG_Py_Void();
13679 {
13680 if (temp1)
13681 delete arg1;
13682 }
13683 return resultobj;
13684 fail:
13685 {
13686 if (temp1)
13687 delete arg1;
13688 }
13689 return NULL;
13690 }
13691
13692
13693 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13694 PyObject *resultobj = 0;
13695 wxString *arg1 = 0 ;
13696 bool temp1 = false ;
13697 PyObject * obj0 = 0 ;
13698 char * kwnames[] = {
13699 (char *) "msg", NULL
13700 };
13701
13702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13703 {
13704 arg1 = wxString_in_helper(obj0);
13705 if (arg1 == NULL) SWIG_fail;
13706 temp1 = true;
13707 }
13708 {
13709 PyThreadState* __tstate = wxPyBeginAllowThreads();
13710 wxPyLogInfo((wxString const &)*arg1);
13711 wxPyEndAllowThreads(__tstate);
13712 if (PyErr_Occurred()) SWIG_fail;
13713 }
13714 resultobj = SWIG_Py_Void();
13715 {
13716 if (temp1)
13717 delete arg1;
13718 }
13719 return resultobj;
13720 fail:
13721 {
13722 if (temp1)
13723 delete arg1;
13724 }
13725 return NULL;
13726 }
13727
13728
13729 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13730 PyObject *resultobj = 0;
13731 wxString *arg1 = 0 ;
13732 bool temp1 = false ;
13733 PyObject * obj0 = 0 ;
13734 char * kwnames[] = {
13735 (char *) "msg", NULL
13736 };
13737
13738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13739 {
13740 arg1 = wxString_in_helper(obj0);
13741 if (arg1 == NULL) SWIG_fail;
13742 temp1 = true;
13743 }
13744 {
13745 PyThreadState* __tstate = wxPyBeginAllowThreads();
13746 wxPyLogDebug((wxString const &)*arg1);
13747 wxPyEndAllowThreads(__tstate);
13748 if (PyErr_Occurred()) SWIG_fail;
13749 }
13750 resultobj = SWIG_Py_Void();
13751 {
13752 if (temp1)
13753 delete arg1;
13754 }
13755 return resultobj;
13756 fail:
13757 {
13758 if (temp1)
13759 delete arg1;
13760 }
13761 return NULL;
13762 }
13763
13764
13765 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13766 PyObject *resultobj = 0;
13767 wxString *arg1 = 0 ;
13768 bool temp1 = false ;
13769 PyObject * obj0 = 0 ;
13770 char * kwnames[] = {
13771 (char *) "msg", NULL
13772 };
13773
13774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13775 {
13776 arg1 = wxString_in_helper(obj0);
13777 if (arg1 == NULL) SWIG_fail;
13778 temp1 = true;
13779 }
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 wxPyLogVerbose((wxString const &)*arg1);
13783 wxPyEndAllowThreads(__tstate);
13784 if (PyErr_Occurred()) SWIG_fail;
13785 }
13786 resultobj = SWIG_Py_Void();
13787 {
13788 if (temp1)
13789 delete arg1;
13790 }
13791 return resultobj;
13792 fail:
13793 {
13794 if (temp1)
13795 delete arg1;
13796 }
13797 return NULL;
13798 }
13799
13800
13801 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13802 PyObject *resultobj = 0;
13803 wxString *arg1 = 0 ;
13804 bool temp1 = false ;
13805 PyObject * obj0 = 0 ;
13806 char * kwnames[] = {
13807 (char *) "msg", NULL
13808 };
13809
13810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13811 {
13812 arg1 = wxString_in_helper(obj0);
13813 if (arg1 == NULL) SWIG_fail;
13814 temp1 = true;
13815 }
13816 {
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 wxPyLogStatus((wxString const &)*arg1);
13819 wxPyEndAllowThreads(__tstate);
13820 if (PyErr_Occurred()) SWIG_fail;
13821 }
13822 resultobj = SWIG_Py_Void();
13823 {
13824 if (temp1)
13825 delete arg1;
13826 }
13827 return resultobj;
13828 fail:
13829 {
13830 if (temp1)
13831 delete arg1;
13832 }
13833 return NULL;
13834 }
13835
13836
13837 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13838 PyObject *resultobj = 0;
13839 wxFrame *arg1 = (wxFrame *) 0 ;
13840 wxString *arg2 = 0 ;
13841 void *argp1 = 0 ;
13842 int res1 = 0 ;
13843 bool temp2 = false ;
13844 PyObject * obj0 = 0 ;
13845 PyObject * obj1 = 0 ;
13846 char * kwnames[] = {
13847 (char *) "pFrame",(char *) "msg", NULL
13848 };
13849
13850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13852 if (!SWIG_IsOK(res1)) {
13853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13854 }
13855 arg1 = reinterpret_cast< wxFrame * >(argp1);
13856 {
13857 arg2 = wxString_in_helper(obj1);
13858 if (arg2 == NULL) SWIG_fail;
13859 temp2 = true;
13860 }
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_Py_Void();
13868 {
13869 if (temp2)
13870 delete arg2;
13871 }
13872 return resultobj;
13873 fail:
13874 {
13875 if (temp2)
13876 delete arg2;
13877 }
13878 return NULL;
13879 }
13880
13881
13882 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13883 PyObject *resultobj = 0;
13884 wxString *arg1 = 0 ;
13885 bool temp1 = false ;
13886 PyObject * obj0 = 0 ;
13887 char * kwnames[] = {
13888 (char *) "msg", NULL
13889 };
13890
13891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13892 {
13893 arg1 = wxString_in_helper(obj0);
13894 if (arg1 == NULL) SWIG_fail;
13895 temp1 = true;
13896 }
13897 {
13898 PyThreadState* __tstate = wxPyBeginAllowThreads();
13899 wxPyLogSysError((wxString const &)*arg1);
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 resultobj = SWIG_Py_Void();
13904 {
13905 if (temp1)
13906 delete arg1;
13907 }
13908 return resultobj;
13909 fail:
13910 {
13911 if (temp1)
13912 delete arg1;
13913 }
13914 return NULL;
13915 }
13916
13917
13918 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj = 0;
13920 unsigned long arg1 ;
13921 wxString *arg2 = 0 ;
13922 unsigned long val1 ;
13923 int ecode1 = 0 ;
13924 bool temp2 = false ;
13925 PyObject * obj0 = 0 ;
13926 PyObject * obj1 = 0 ;
13927 char * kwnames[] = {
13928 (char *) "level",(char *) "msg", NULL
13929 };
13930
13931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13932 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13933 if (!SWIG_IsOK(ecode1)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13935 }
13936 arg1 = static_cast< unsigned long >(val1);
13937 {
13938 arg2 = wxString_in_helper(obj1);
13939 if (arg2 == NULL) SWIG_fail;
13940 temp2 = true;
13941 }
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13945 wxPyEndAllowThreads(__tstate);
13946 if (PyErr_Occurred()) SWIG_fail;
13947 }
13948 resultobj = SWIG_Py_Void();
13949 {
13950 if (temp2)
13951 delete arg2;
13952 }
13953 return resultobj;
13954 fail:
13955 {
13956 if (temp2)
13957 delete arg2;
13958 }
13959 return NULL;
13960 }
13961
13962
13963 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13964 PyObject *resultobj = 0;
13965 unsigned long arg1 ;
13966 wxString *arg2 = 0 ;
13967 unsigned long val1 ;
13968 int ecode1 = 0 ;
13969 bool temp2 = false ;
13970
13971 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13972 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13973 if (!SWIG_IsOK(ecode1)) {
13974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13975 }
13976 arg1 = static_cast< unsigned long >(val1);
13977 {
13978 arg2 = wxString_in_helper(swig_obj[1]);
13979 if (arg2 == NULL) SWIG_fail;
13980 temp2 = true;
13981 }
13982 {
13983 PyThreadState* __tstate = wxPyBeginAllowThreads();
13984 wxPyLogTrace(arg1,(wxString const &)*arg2);
13985 wxPyEndAllowThreads(__tstate);
13986 if (PyErr_Occurred()) SWIG_fail;
13987 }
13988 resultobj = SWIG_Py_Void();
13989 {
13990 if (temp2)
13991 delete arg2;
13992 }
13993 return resultobj;
13994 fail:
13995 {
13996 if (temp2)
13997 delete arg2;
13998 }
13999 return NULL;
14000 }
14001
14002
14003 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14004 PyObject *resultobj = 0;
14005 wxString *arg1 = 0 ;
14006 wxString *arg2 = 0 ;
14007 bool temp1 = false ;
14008 bool temp2 = false ;
14009
14010 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14011 {
14012 arg1 = wxString_in_helper(swig_obj[0]);
14013 if (arg1 == NULL) SWIG_fail;
14014 temp1 = true;
14015 }
14016 {
14017 arg2 = wxString_in_helper(swig_obj[1]);
14018 if (arg2 == NULL) SWIG_fail;
14019 temp2 = true;
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_Py_Void();
14028 {
14029 if (temp1)
14030 delete arg1;
14031 }
14032 {
14033 if (temp2)
14034 delete arg2;
14035 }
14036 return resultobj;
14037 fail:
14038 {
14039 if (temp1)
14040 delete arg1;
14041 }
14042 {
14043 if (temp2)
14044 delete arg2;
14045 }
14046 return NULL;
14047 }
14048
14049
14050 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14051 int argc;
14052 PyObject *argv[3];
14053
14054 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14055 --argc;
14056 if (argc == 2) {
14057 int _v = 0;
14058 {
14059 {
14060 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14061 }
14062 }
14063 if (!_v) goto check_1;
14064 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14065 }
14066 check_1:
14067
14068 if (argc == 2) {
14069 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14070 }
14071
14072 fail:
14073 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14074 return NULL;
14075 }
14076
14077
14078 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14079 PyObject *resultobj = 0;
14080 wxString *arg1 = 0 ;
14081 wxString *arg2 = 0 ;
14082 bool temp1 = false ;
14083 bool temp2 = false ;
14084 PyObject * obj0 = 0 ;
14085 PyObject * obj1 = 0 ;
14086 char * kwnames[] = {
14087 (char *) "title",(char *) "text", NULL
14088 };
14089
14090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14091 {
14092 arg1 = wxString_in_helper(obj0);
14093 if (arg1 == NULL) SWIG_fail;
14094 temp1 = true;
14095 }
14096 {
14097 arg2 = wxString_in_helper(obj1);
14098 if (arg2 == NULL) SWIG_fail;
14099 temp2 = true;
14100 }
14101 {
14102 PyThreadState* __tstate = wxPyBeginAllowThreads();
14103 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14104 wxPyEndAllowThreads(__tstate);
14105 if (PyErr_Occurred()) SWIG_fail;
14106 }
14107 resultobj = SWIG_Py_Void();
14108 {
14109 if (temp1)
14110 delete arg1;
14111 }
14112 {
14113 if (temp2)
14114 delete arg2;
14115 }
14116 return resultobj;
14117 fail:
14118 {
14119 if (temp1)
14120 delete arg1;
14121 }
14122 {
14123 if (temp2)
14124 delete arg2;
14125 }
14126 return NULL;
14127 }
14128
14129
14130 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14131 PyObject *resultobj = 0;
14132 wxLogNull *result = 0 ;
14133
14134 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (wxLogNull *)new wxLogNull();
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14149 PyObject *resultobj = 0;
14150 wxLogNull *arg1 = (wxLogNull *) 0 ;
14151 void *argp1 = 0 ;
14152 int res1 = 0 ;
14153 PyObject *swig_obj[1] ;
14154
14155 if (!args) SWIG_fail;
14156 swig_obj[0] = args;
14157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14158 if (!SWIG_IsOK(res1)) {
14159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14160 }
14161 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 delete arg1;
14165
14166 wxPyEndAllowThreads(__tstate);
14167 if (PyErr_Occurred()) SWIG_fail;
14168 }
14169 resultobj = SWIG_Py_Void();
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14177 PyObject *obj;
14178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14179 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14180 return SWIG_Py_Void();
14181 }
14182
14183 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14184 return SWIG_Python_InitShadowInstance(args);
14185 }
14186
14187 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14188 PyObject *resultobj = 0;
14189 wxPyLog *result = 0 ;
14190
14191 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (wxPyLog *)new wxPyLog();
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14199 return resultobj;
14200 fail:
14201 return NULL;
14202 }
14203
14204
14205 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj = 0;
14207 wxPyLog *arg1 = (wxPyLog *) 0 ;
14208 PyObject *arg2 = (PyObject *) 0 ;
14209 PyObject *arg3 = (PyObject *) 0 ;
14210 void *argp1 = 0 ;
14211 int res1 = 0 ;
14212 PyObject * obj0 = 0 ;
14213 PyObject * obj1 = 0 ;
14214 PyObject * obj2 = 0 ;
14215 char * kwnames[] = {
14216 (char *) "self",(char *) "self",(char *) "_class", NULL
14217 };
14218
14219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14221 if (!SWIG_IsOK(res1)) {
14222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14223 }
14224 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14225 arg2 = obj1;
14226 arg3 = obj2;
14227 {
14228 PyThreadState* __tstate = wxPyBeginAllowThreads();
14229 (arg1)->_setCallbackInfo(arg2,arg3);
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 resultobj = SWIG_Py_Void();
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14241 PyObject *obj;
14242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14243 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14244 return SWIG_Py_Void();
14245 }
14246
14247 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14248 return SWIG_Python_InitShadowInstance(args);
14249 }
14250
14251 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14252 PyObject *resultobj = 0;
14253 int arg1 ;
14254 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14255 int arg3 = (int) wxKILL_NOCHILDREN ;
14256 wxKillError result;
14257 int val1 ;
14258 int ecode1 = 0 ;
14259 int val2 ;
14260 int ecode2 = 0 ;
14261 int val3 ;
14262 int ecode3 = 0 ;
14263 PyObject * obj0 = 0 ;
14264 PyObject * obj1 = 0 ;
14265 PyObject * obj2 = 0 ;
14266 char * kwnames[] = {
14267 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14268 };
14269
14270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14271 ecode1 = SWIG_AsVal_int(obj0, &val1);
14272 if (!SWIG_IsOK(ecode1)) {
14273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14274 }
14275 arg1 = static_cast< int >(val1);
14276 if (obj1) {
14277 ecode2 = SWIG_AsVal_int(obj1, &val2);
14278 if (!SWIG_IsOK(ecode2)) {
14279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14280 }
14281 arg2 = static_cast< wxSignal >(val2);
14282 }
14283 if (obj2) {
14284 ecode3 = SWIG_AsVal_int(obj2, &val3);
14285 if (!SWIG_IsOK(ecode3)) {
14286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14287 }
14288 arg3 = static_cast< int >(val3);
14289 }
14290 {
14291 PyThreadState* __tstate = wxPyBeginAllowThreads();
14292 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14293 wxPyEndAllowThreads(__tstate);
14294 if (PyErr_Occurred()) SWIG_fail;
14295 }
14296 resultobj = SWIG_From_int(static_cast< int >(result));
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj = 0;
14305 int arg1 ;
14306 bool result;
14307 int val1 ;
14308 int ecode1 = 0 ;
14309 PyObject * obj0 = 0 ;
14310 char * kwnames[] = {
14311 (char *) "pid", NULL
14312 };
14313
14314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14315 ecode1 = SWIG_AsVal_int(obj0, &val1);
14316 if (!SWIG_IsOK(ecode1)) {
14317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14318 }
14319 arg1 = static_cast< int >(val1);
14320 {
14321 PyThreadState* __tstate = wxPyBeginAllowThreads();
14322 result = (bool)wxPyProcess::Exists(arg1);
14323 wxPyEndAllowThreads(__tstate);
14324 if (PyErr_Occurred()) SWIG_fail;
14325 }
14326 {
14327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14328 }
14329 return resultobj;
14330 fail:
14331 return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj = 0;
14337 wxString *arg1 = 0 ;
14338 int arg2 = (int) wxEXEC_ASYNC ;
14339 wxPyProcess *result = 0 ;
14340 bool temp1 = false ;
14341 int val2 ;
14342 int ecode2 = 0 ;
14343 PyObject * obj0 = 0 ;
14344 PyObject * obj1 = 0 ;
14345 char * kwnames[] = {
14346 (char *) "cmd",(char *) "flags", NULL
14347 };
14348
14349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14350 {
14351 arg1 = wxString_in_helper(obj0);
14352 if (arg1 == NULL) SWIG_fail;
14353 temp1 = true;
14354 }
14355 if (obj1) {
14356 ecode2 = SWIG_AsVal_int(obj1, &val2);
14357 if (!SWIG_IsOK(ecode2)) {
14358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14359 }
14360 arg2 = static_cast< int >(val2);
14361 }
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14369 {
14370 if (temp1)
14371 delete arg1;
14372 }
14373 return resultobj;
14374 fail:
14375 {
14376 if (temp1)
14377 delete arg1;
14378 }
14379 return NULL;
14380 }
14381
14382
14383 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj = 0;
14385 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14386 int arg2 = (int) -1 ;
14387 wxPyProcess *result = 0 ;
14388 void *argp1 = 0 ;
14389 int res1 = 0 ;
14390 int val2 ;
14391 int ecode2 = 0 ;
14392 PyObject * obj0 = 0 ;
14393 PyObject * obj1 = 0 ;
14394 char * kwnames[] = {
14395 (char *) "parent",(char *) "id", NULL
14396 };
14397
14398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14399 if (obj0) {
14400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14401 if (!SWIG_IsOK(res1)) {
14402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14403 }
14404 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14405 }
14406 if (obj1) {
14407 ecode2 = SWIG_AsVal_int(obj1, &val2);
14408 if (!SWIG_IsOK(ecode2)) {
14409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14410 }
14411 arg2 = static_cast< int >(val2);
14412 }
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14416 wxPyEndAllowThreads(__tstate);
14417 if (PyErr_Occurred()) SWIG_fail;
14418 }
14419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14420 return resultobj;
14421 fail:
14422 return NULL;
14423 }
14424
14425
14426 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14427 PyObject *resultobj = 0;
14428 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14429 void *argp1 = 0 ;
14430 int res1 = 0 ;
14431 PyObject *swig_obj[1] ;
14432
14433 if (!args) SWIG_fail;
14434 swig_obj[0] = args;
14435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14436 if (!SWIG_IsOK(res1)) {
14437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14438 }
14439 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 delete arg1;
14443
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 resultobj = SWIG_Py_Void();
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14455 PyObject *resultobj = 0;
14456 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14457 PyObject *arg2 = (PyObject *) 0 ;
14458 PyObject *arg3 = (PyObject *) 0 ;
14459 void *argp1 = 0 ;
14460 int res1 = 0 ;
14461 PyObject * obj0 = 0 ;
14462 PyObject * obj1 = 0 ;
14463 PyObject * obj2 = 0 ;
14464 char * kwnames[] = {
14465 (char *) "self",(char *) "self",(char *) "_class", NULL
14466 };
14467
14468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14470 if (!SWIG_IsOK(res1)) {
14471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14472 }
14473 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14474 arg2 = obj1;
14475 arg3 = obj2;
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 (arg1)->_setCallbackInfo(arg2,arg3);
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 resultobj = SWIG_Py_Void();
14483 return resultobj;
14484 fail:
14485 return NULL;
14486 }
14487
14488
14489 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14490 PyObject *resultobj = 0;
14491 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14492 long result;
14493 void *argp1 = 0 ;
14494 int res1 = 0 ;
14495 PyObject *swig_obj[1] ;
14496
14497 if (!args) SWIG_fail;
14498 swig_obj[0] = args;
14499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14500 if (!SWIG_IsOK(res1)) {
14501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14502 }
14503 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14504 {
14505 PyThreadState* __tstate = wxPyBeginAllowThreads();
14506 result = (long)((wxPyProcess const *)arg1)->GetPid();
14507 wxPyEndAllowThreads(__tstate);
14508 if (PyErr_Occurred()) SWIG_fail;
14509 }
14510 resultobj = SWIG_From_long(static_cast< long >(result));
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = 0;
14519 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14520 int arg2 ;
14521 int arg3 ;
14522 void *argp1 = 0 ;
14523 int res1 = 0 ;
14524 int val2 ;
14525 int ecode2 = 0 ;
14526 int val3 ;
14527 int ecode3 = 0 ;
14528 PyObject * obj0 = 0 ;
14529 PyObject * obj1 = 0 ;
14530 PyObject * obj2 = 0 ;
14531 char * kwnames[] = {
14532 (char *) "self",(char *) "pid",(char *) "status", NULL
14533 };
14534
14535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14537 if (!SWIG_IsOK(res1)) {
14538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14539 }
14540 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14541 ecode2 = SWIG_AsVal_int(obj1, &val2);
14542 if (!SWIG_IsOK(ecode2)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14544 }
14545 arg2 = static_cast< int >(val2);
14546 ecode3 = SWIG_AsVal_int(obj2, &val3);
14547 if (!SWIG_IsOK(ecode3)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14549 }
14550 arg3 = static_cast< int >(val3);
14551 {
14552 PyThreadState* __tstate = wxPyBeginAllowThreads();
14553 (arg1)->OnTerminate(arg2,arg3);
14554 wxPyEndAllowThreads(__tstate);
14555 if (PyErr_Occurred()) SWIG_fail;
14556 }
14557 resultobj = SWIG_Py_Void();
14558 return resultobj;
14559 fail:
14560 return NULL;
14561 }
14562
14563
14564 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14565 PyObject *resultobj = 0;
14566 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14567 void *argp1 = 0 ;
14568 int res1 = 0 ;
14569 PyObject *swig_obj[1] ;
14570
14571 if (!args) SWIG_fail;
14572 swig_obj[0] = args;
14573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14574 if (!SWIG_IsOK(res1)) {
14575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14576 }
14577 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14578 {
14579 PyThreadState* __tstate = wxPyBeginAllowThreads();
14580 (arg1)->Redirect();
14581 wxPyEndAllowThreads(__tstate);
14582 if (PyErr_Occurred()) SWIG_fail;
14583 }
14584 resultobj = SWIG_Py_Void();
14585 return resultobj;
14586 fail:
14587 return NULL;
14588 }
14589
14590
14591 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14592 PyObject *resultobj = 0;
14593 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14594 bool result;
14595 void *argp1 = 0 ;
14596 int res1 = 0 ;
14597 PyObject *swig_obj[1] ;
14598
14599 if (!args) SWIG_fail;
14600 swig_obj[0] = args;
14601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14602 if (!SWIG_IsOK(res1)) {
14603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14604 }
14605 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 result = (bool)(arg1)->IsRedirected();
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 {
14613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14614 }
14615 return resultobj;
14616 fail:
14617 return NULL;
14618 }
14619
14620
14621 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14622 PyObject *resultobj = 0;
14623 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 PyObject *swig_obj[1] ;
14627
14628 if (!args) SWIG_fail;
14629 swig_obj[0] = args;
14630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14631 if (!SWIG_IsOK(res1)) {
14632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14633 }
14634 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14635 {
14636 PyThreadState* __tstate = wxPyBeginAllowThreads();
14637 (arg1)->Detach();
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 resultobj = SWIG_Py_Void();
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14649 PyObject *resultobj = 0;
14650 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14651 wxInputStream *result = 0 ;
14652 void *argp1 = 0 ;
14653 int res1 = 0 ;
14654 PyObject *swig_obj[1] ;
14655
14656 if (!args) SWIG_fail;
14657 swig_obj[0] = args;
14658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14659 if (!SWIG_IsOK(res1)) {
14660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14661 }
14662 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (wxInputStream *)(arg1)->GetInputStream();
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 {
14670 wxPyInputStream * _ptr = NULL;
14671
14672 if (result) {
14673 _ptr = new wxPyInputStream(result);
14674 }
14675 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14676 }
14677 return resultobj;
14678 fail:
14679 return NULL;
14680 }
14681
14682
14683 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14684 PyObject *resultobj = 0;
14685 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14686 wxInputStream *result = 0 ;
14687 void *argp1 = 0 ;
14688 int res1 = 0 ;
14689 PyObject *swig_obj[1] ;
14690
14691 if (!args) SWIG_fail;
14692 swig_obj[0] = args;
14693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14694 if (!SWIG_IsOK(res1)) {
14695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14696 }
14697 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14698 {
14699 PyThreadState* __tstate = wxPyBeginAllowThreads();
14700 result = (wxInputStream *)(arg1)->GetErrorStream();
14701 wxPyEndAllowThreads(__tstate);
14702 if (PyErr_Occurred()) SWIG_fail;
14703 }
14704 {
14705 wxPyInputStream * _ptr = NULL;
14706
14707 if (result) {
14708 _ptr = new wxPyInputStream(result);
14709 }
14710 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14711 }
14712 return resultobj;
14713 fail:
14714 return NULL;
14715 }
14716
14717
14718 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14719 PyObject *resultobj = 0;
14720 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14721 wxOutputStream *result = 0 ;
14722 void *argp1 = 0 ;
14723 int res1 = 0 ;
14724 PyObject *swig_obj[1] ;
14725
14726 if (!args) SWIG_fail;
14727 swig_obj[0] = args;
14728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14729 if (!SWIG_IsOK(res1)) {
14730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14731 }
14732 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 result = (wxOutputStream *)(arg1)->GetOutputStream();
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14740 return resultobj;
14741 fail:
14742 return NULL;
14743 }
14744
14745
14746 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14747 PyObject *resultobj = 0;
14748 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14749 void *argp1 = 0 ;
14750 int res1 = 0 ;
14751 PyObject *swig_obj[1] ;
14752
14753 if (!args) SWIG_fail;
14754 swig_obj[0] = args;
14755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14756 if (!SWIG_IsOK(res1)) {
14757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14758 }
14759 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 (arg1)->CloseOutput();
14763 wxPyEndAllowThreads(__tstate);
14764 if (PyErr_Occurred()) SWIG_fail;
14765 }
14766 resultobj = SWIG_Py_Void();
14767 return resultobj;
14768 fail:
14769 return NULL;
14770 }
14771
14772
14773 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14774 PyObject *resultobj = 0;
14775 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14776 bool result;
14777 void *argp1 = 0 ;
14778 int res1 = 0 ;
14779 PyObject *swig_obj[1] ;
14780
14781 if (!args) SWIG_fail;
14782 swig_obj[0] = args;
14783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14784 if (!SWIG_IsOK(res1)) {
14785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14786 }
14787 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14788 {
14789 PyThreadState* __tstate = wxPyBeginAllowThreads();
14790 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14791 wxPyEndAllowThreads(__tstate);
14792 if (PyErr_Occurred()) SWIG_fail;
14793 }
14794 {
14795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14796 }
14797 return resultobj;
14798 fail:
14799 return NULL;
14800 }
14801
14802
14803 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14804 PyObject *resultobj = 0;
14805 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14806 bool result;
14807 void *argp1 = 0 ;
14808 int res1 = 0 ;
14809 PyObject *swig_obj[1] ;
14810
14811 if (!args) SWIG_fail;
14812 swig_obj[0] = args;
14813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14814 if (!SWIG_IsOK(res1)) {
14815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14816 }
14817 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14818 {
14819 PyThreadState* __tstate = wxPyBeginAllowThreads();
14820 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14821 wxPyEndAllowThreads(__tstate);
14822 if (PyErr_Occurred()) SWIG_fail;
14823 }
14824 {
14825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14826 }
14827 return resultobj;
14828 fail:
14829 return NULL;
14830 }
14831
14832
14833 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14834 PyObject *resultobj = 0;
14835 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14836 bool result;
14837 void *argp1 = 0 ;
14838 int res1 = 0 ;
14839 PyObject *swig_obj[1] ;
14840
14841 if (!args) SWIG_fail;
14842 swig_obj[0] = args;
14843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14844 if (!SWIG_IsOK(res1)) {
14845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14846 }
14847 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14851 wxPyEndAllowThreads(__tstate);
14852 if (PyErr_Occurred()) SWIG_fail;
14853 }
14854 {
14855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14856 }
14857 return resultobj;
14858 fail:
14859 return NULL;
14860 }
14861
14862
14863 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14864 PyObject *obj;
14865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14866 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14867 return SWIG_Py_Void();
14868 }
14869
14870 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14871 return SWIG_Python_InitShadowInstance(args);
14872 }
14873
14874 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14875 PyObject *resultobj = 0;
14876 int arg1 = (int) 0 ;
14877 int arg2 = (int) 0 ;
14878 int arg3 = (int) 0 ;
14879 wxProcessEvent *result = 0 ;
14880 int val1 ;
14881 int ecode1 = 0 ;
14882 int val2 ;
14883 int ecode2 = 0 ;
14884 int val3 ;
14885 int ecode3 = 0 ;
14886 PyObject * obj0 = 0 ;
14887 PyObject * obj1 = 0 ;
14888 PyObject * obj2 = 0 ;
14889 char * kwnames[] = {
14890 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14891 };
14892
14893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14894 if (obj0) {
14895 ecode1 = SWIG_AsVal_int(obj0, &val1);
14896 if (!SWIG_IsOK(ecode1)) {
14897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14898 }
14899 arg1 = static_cast< int >(val1);
14900 }
14901 if (obj1) {
14902 ecode2 = SWIG_AsVal_int(obj1, &val2);
14903 if (!SWIG_IsOK(ecode2)) {
14904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14905 }
14906 arg2 = static_cast< int >(val2);
14907 }
14908 if (obj2) {
14909 ecode3 = SWIG_AsVal_int(obj2, &val3);
14910 if (!SWIG_IsOK(ecode3)) {
14911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14912 }
14913 arg3 = static_cast< int >(val3);
14914 }
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14929 PyObject *resultobj = 0;
14930 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14931 int result;
14932 void *argp1 = 0 ;
14933 int res1 = 0 ;
14934 PyObject *swig_obj[1] ;
14935
14936 if (!args) SWIG_fail;
14937 swig_obj[0] = args;
14938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14939 if (!SWIG_IsOK(res1)) {
14940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14941 }
14942 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (int)(arg1)->GetPid();
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 resultobj = SWIG_From_int(static_cast< int >(result));
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14957 PyObject *resultobj = 0;
14958 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14959 int result;
14960 void *argp1 = 0 ;
14961 int res1 = 0 ;
14962 PyObject *swig_obj[1] ;
14963
14964 if (!args) SWIG_fail;
14965 swig_obj[0] = args;
14966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14967 if (!SWIG_IsOK(res1)) {
14968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14969 }
14970 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14971 {
14972 PyThreadState* __tstate = wxPyBeginAllowThreads();
14973 result = (int)(arg1)->GetExitCode();
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 resultobj = SWIG_From_int(static_cast< int >(result));
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14985 PyObject *resultobj = 0;
14986 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14987 int arg2 ;
14988 void *argp1 = 0 ;
14989 int res1 = 0 ;
14990 int val2 ;
14991 int ecode2 = 0 ;
14992 PyObject *swig_obj[2] ;
14993
14994 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14996 if (!SWIG_IsOK(res1)) {
14997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14998 }
14999 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15000 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15001 if (!SWIG_IsOK(ecode2)) {
15002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
15003 }
15004 arg2 = static_cast< int >(val2);
15005 if (arg1) (arg1)->m_pid = arg2;
15006
15007 resultobj = SWIG_Py_Void();
15008 return resultobj;
15009 fail:
15010 return NULL;
15011 }
15012
15013
15014 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15015 PyObject *resultobj = 0;
15016 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15017 int result;
15018 void *argp1 = 0 ;
15019 int res1 = 0 ;
15020 PyObject *swig_obj[1] ;
15021
15022 if (!args) SWIG_fail;
15023 swig_obj[0] = args;
15024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15025 if (!SWIG_IsOK(res1)) {
15026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15027 }
15028 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15029 result = (int) ((arg1)->m_pid);
15030 resultobj = SWIG_From_int(static_cast< int >(result));
15031 return resultobj;
15032 fail:
15033 return NULL;
15034 }
15035
15036
15037 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15038 PyObject *resultobj = 0;
15039 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15040 int arg2 ;
15041 void *argp1 = 0 ;
15042 int res1 = 0 ;
15043 int val2 ;
15044 int ecode2 = 0 ;
15045 PyObject *swig_obj[2] ;
15046
15047 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15049 if (!SWIG_IsOK(res1)) {
15050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15051 }
15052 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15053 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15054 if (!SWIG_IsOK(ecode2)) {
15055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15056 }
15057 arg2 = static_cast< int >(val2);
15058 if (arg1) (arg1)->m_exitcode = arg2;
15059
15060 resultobj = SWIG_Py_Void();
15061 return resultobj;
15062 fail:
15063 return NULL;
15064 }
15065
15066
15067 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15068 PyObject *resultobj = 0;
15069 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15070 int result;
15071 void *argp1 = 0 ;
15072 int res1 = 0 ;
15073 PyObject *swig_obj[1] ;
15074
15075 if (!args) SWIG_fail;
15076 swig_obj[0] = args;
15077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15078 if (!SWIG_IsOK(res1)) {
15079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15080 }
15081 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15082 result = (int) ((arg1)->m_exitcode);
15083 resultobj = SWIG_From_int(static_cast< int >(result));
15084 return resultobj;
15085 fail:
15086 return NULL;
15087 }
15088
15089
15090 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15091 PyObject *obj;
15092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15093 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15094 return SWIG_Py_Void();
15095 }
15096
15097 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15098 return SWIG_Python_InitShadowInstance(args);
15099 }
15100
15101 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15102 PyObject *resultobj = 0;
15103 wxString *arg1 = 0 ;
15104 int arg2 = (int) wxEXEC_ASYNC ;
15105 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15106 long result;
15107 bool temp1 = false ;
15108 int val2 ;
15109 int ecode2 = 0 ;
15110 void *argp3 = 0 ;
15111 int res3 = 0 ;
15112 PyObject * obj0 = 0 ;
15113 PyObject * obj1 = 0 ;
15114 PyObject * obj2 = 0 ;
15115 char * kwnames[] = {
15116 (char *) "command",(char *) "flags",(char *) "process", NULL
15117 };
15118
15119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15120 {
15121 arg1 = wxString_in_helper(obj0);
15122 if (arg1 == NULL) SWIG_fail;
15123 temp1 = true;
15124 }
15125 if (obj1) {
15126 ecode2 = SWIG_AsVal_int(obj1, &val2);
15127 if (!SWIG_IsOK(ecode2)) {
15128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15129 }
15130 arg2 = static_cast< int >(val2);
15131 }
15132 if (obj2) {
15133 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15134 if (!SWIG_IsOK(res3)) {
15135 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15136 }
15137 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15138 }
15139 {
15140 if (!wxPyCheckForApp()) SWIG_fail;
15141 PyThreadState* __tstate = wxPyBeginAllowThreads();
15142 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15143 wxPyEndAllowThreads(__tstate);
15144 if (PyErr_Occurred()) SWIG_fail;
15145 }
15146 resultobj = SWIG_From_long(static_cast< long >(result));
15147 {
15148 if (temp1)
15149 delete arg1;
15150 }
15151 return resultobj;
15152 fail:
15153 {
15154 if (temp1)
15155 delete arg1;
15156 }
15157 return NULL;
15158 }
15159
15160
15161 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj = 0;
15163 long arg1 ;
15164 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15165 wxKillError *arg3 = (wxKillError *) 0 ;
15166 int arg4 = (int) wxKILL_NOCHILDREN ;
15167 int result;
15168 long val1 ;
15169 int ecode1 = 0 ;
15170 int val2 ;
15171 int ecode2 = 0 ;
15172 wxKillError temp3 ;
15173 int val4 ;
15174 int ecode4 = 0 ;
15175 PyObject * obj0 = 0 ;
15176 PyObject * obj1 = 0 ;
15177 PyObject * obj2 = 0 ;
15178 char * kwnames[] = {
15179 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15180 };
15181
15182 {
15183 arg3 = &temp3;
15184 }
15185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15186 ecode1 = SWIG_AsVal_long(obj0, &val1);
15187 if (!SWIG_IsOK(ecode1)) {
15188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15189 }
15190 arg1 = static_cast< long >(val1);
15191 if (obj1) {
15192 ecode2 = SWIG_AsVal_int(obj1, &val2);
15193 if (!SWIG_IsOK(ecode2)) {
15194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15195 }
15196 arg2 = static_cast< wxSignal >(val2);
15197 }
15198 if (obj2) {
15199 ecode4 = SWIG_AsVal_int(obj2, &val4);
15200 if (!SWIG_IsOK(ecode4)) {
15201 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15202 }
15203 arg4 = static_cast< int >(val4);
15204 }
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 result = (int)wxKill(arg1,arg2,arg3,arg4);
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 resultobj = SWIG_From_int(static_cast< int >(result));
15212 {
15213 PyObject* o;
15214 o = PyInt_FromLong((long) (*arg3));
15215
15216
15217
15218 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15219
15220 }
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj = 0;
15229 int arg1 = (int) wxJOYSTICK1 ;
15230 wxJoystick *result = 0 ;
15231 int val1 ;
15232 int ecode1 = 0 ;
15233 PyObject * obj0 = 0 ;
15234 char * kwnames[] = {
15235 (char *) "joystick", NULL
15236 };
15237
15238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15239 if (obj0) {
15240 ecode1 = SWIG_AsVal_int(obj0, &val1);
15241 if (!SWIG_IsOK(ecode1)) {
15242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15243 }
15244 arg1 = static_cast< int >(val1);
15245 }
15246 {
15247 if (!wxPyCheckForApp()) SWIG_fail;
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = (wxJoystick *)new wxJoystick(arg1);
15250 wxPyEndAllowThreads(__tstate);
15251 if (PyErr_Occurred()) SWIG_fail;
15252 }
15253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15254 return resultobj;
15255 fail:
15256 return NULL;
15257 }
15258
15259
15260 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15261 PyObject *resultobj = 0;
15262 wxJoystick *arg1 = (wxJoystick *) 0 ;
15263 void *argp1 = 0 ;
15264 int res1 = 0 ;
15265 PyObject *swig_obj[1] ;
15266
15267 if (!args) SWIG_fail;
15268 swig_obj[0] = args;
15269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15270 if (!SWIG_IsOK(res1)) {
15271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15272 }
15273 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15274 {
15275 PyThreadState* __tstate = wxPyBeginAllowThreads();
15276 delete arg1;
15277
15278 wxPyEndAllowThreads(__tstate);
15279 if (PyErr_Occurred()) SWIG_fail;
15280 }
15281 resultobj = SWIG_Py_Void();
15282 return resultobj;
15283 fail:
15284 return NULL;
15285 }
15286
15287
15288 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15289 PyObject *resultobj = 0;
15290 wxJoystick *arg1 = (wxJoystick *) 0 ;
15291 wxPoint result;
15292 void *argp1 = 0 ;
15293 int res1 = 0 ;
15294 PyObject *swig_obj[1] ;
15295
15296 if (!args) SWIG_fail;
15297 swig_obj[0] = args;
15298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15299 if (!SWIG_IsOK(res1)) {
15300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15301 }
15302 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (arg1)->GetPosition();
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15317 PyObject *resultobj = 0;
15318 wxJoystick *arg1 = (wxJoystick *) 0 ;
15319 int result;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 PyObject *swig_obj[1] ;
15323
15324 if (!args) SWIG_fail;
15325 swig_obj[0] = args;
15326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15329 }
15330 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (int)(arg1)->GetZPosition();
15334 wxPyEndAllowThreads(__tstate);
15335 if (PyErr_Occurred()) SWIG_fail;
15336 }
15337 resultobj = SWIG_From_int(static_cast< int >(result));
15338 return resultobj;
15339 fail:
15340 return NULL;
15341 }
15342
15343
15344 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15345 PyObject *resultobj = 0;
15346 wxJoystick *arg1 = (wxJoystick *) 0 ;
15347 int result;
15348 void *argp1 = 0 ;
15349 int res1 = 0 ;
15350 PyObject *swig_obj[1] ;
15351
15352 if (!args) SWIG_fail;
15353 swig_obj[0] = args;
15354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15355 if (!SWIG_IsOK(res1)) {
15356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15357 }
15358 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 result = (int)(arg1)->GetButtonState();
15362 wxPyEndAllowThreads(__tstate);
15363 if (PyErr_Occurred()) SWIG_fail;
15364 }
15365 resultobj = SWIG_From_int(static_cast< int >(result));
15366 return resultobj;
15367 fail:
15368 return NULL;
15369 }
15370
15371
15372 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15373 PyObject *resultobj = 0;
15374 wxJoystick *arg1 = (wxJoystick *) 0 ;
15375 int result;
15376 void *argp1 = 0 ;
15377 int res1 = 0 ;
15378 PyObject *swig_obj[1] ;
15379
15380 if (!args) SWIG_fail;
15381 swig_obj[0] = args;
15382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15383 if (!SWIG_IsOK(res1)) {
15384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15385 }
15386 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 result = (int)(arg1)->GetPOVPosition();
15390 wxPyEndAllowThreads(__tstate);
15391 if (PyErr_Occurred()) SWIG_fail;
15392 }
15393 resultobj = SWIG_From_int(static_cast< int >(result));
15394 return resultobj;
15395 fail:
15396 return NULL;
15397 }
15398
15399
15400 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15401 PyObject *resultobj = 0;
15402 wxJoystick *arg1 = (wxJoystick *) 0 ;
15403 int result;
15404 void *argp1 = 0 ;
15405 int res1 = 0 ;
15406 PyObject *swig_obj[1] ;
15407
15408 if (!args) SWIG_fail;
15409 swig_obj[0] = args;
15410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15411 if (!SWIG_IsOK(res1)) {
15412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15413 }
15414 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15415 {
15416 PyThreadState* __tstate = wxPyBeginAllowThreads();
15417 result = (int)(arg1)->GetPOVCTSPosition();
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 resultobj = SWIG_From_int(static_cast< int >(result));
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15429 PyObject *resultobj = 0;
15430 wxJoystick *arg1 = (wxJoystick *) 0 ;
15431 int result;
15432 void *argp1 = 0 ;
15433 int res1 = 0 ;
15434 PyObject *swig_obj[1] ;
15435
15436 if (!args) SWIG_fail;
15437 swig_obj[0] = args;
15438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15439 if (!SWIG_IsOK(res1)) {
15440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15441 }
15442 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15443 {
15444 PyThreadState* __tstate = wxPyBeginAllowThreads();
15445 result = (int)(arg1)->GetRudderPosition();
15446 wxPyEndAllowThreads(__tstate);
15447 if (PyErr_Occurred()) SWIG_fail;
15448 }
15449 resultobj = SWIG_From_int(static_cast< int >(result));
15450 return resultobj;
15451 fail:
15452 return NULL;
15453 }
15454
15455
15456 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15457 PyObject *resultobj = 0;
15458 wxJoystick *arg1 = (wxJoystick *) 0 ;
15459 int result;
15460 void *argp1 = 0 ;
15461 int res1 = 0 ;
15462 PyObject *swig_obj[1] ;
15463
15464 if (!args) SWIG_fail;
15465 swig_obj[0] = args;
15466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15467 if (!SWIG_IsOK(res1)) {
15468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15469 }
15470 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15471 {
15472 PyThreadState* __tstate = wxPyBeginAllowThreads();
15473 result = (int)(arg1)->GetUPosition();
15474 wxPyEndAllowThreads(__tstate);
15475 if (PyErr_Occurred()) SWIG_fail;
15476 }
15477 resultobj = SWIG_From_int(static_cast< int >(result));
15478 return resultobj;
15479 fail:
15480 return NULL;
15481 }
15482
15483
15484 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15485 PyObject *resultobj = 0;
15486 wxJoystick *arg1 = (wxJoystick *) 0 ;
15487 int result;
15488 void *argp1 = 0 ;
15489 int res1 = 0 ;
15490 PyObject *swig_obj[1] ;
15491
15492 if (!args) SWIG_fail;
15493 swig_obj[0] = args;
15494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15495 if (!SWIG_IsOK(res1)) {
15496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15497 }
15498 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15499 {
15500 PyThreadState* __tstate = wxPyBeginAllowThreads();
15501 result = (int)(arg1)->GetVPosition();
15502 wxPyEndAllowThreads(__tstate);
15503 if (PyErr_Occurred()) SWIG_fail;
15504 }
15505 resultobj = SWIG_From_int(static_cast< int >(result));
15506 return resultobj;
15507 fail:
15508 return NULL;
15509 }
15510
15511
15512 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15513 PyObject *resultobj = 0;
15514 wxJoystick *arg1 = (wxJoystick *) 0 ;
15515 int result;
15516 void *argp1 = 0 ;
15517 int res1 = 0 ;
15518 PyObject *swig_obj[1] ;
15519
15520 if (!args) SWIG_fail;
15521 swig_obj[0] = args;
15522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15523 if (!SWIG_IsOK(res1)) {
15524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15525 }
15526 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 result = (int)(arg1)->GetMovementThreshold();
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 resultobj = SWIG_From_int(static_cast< int >(result));
15534 return resultobj;
15535 fail:
15536 return NULL;
15537 }
15538
15539
15540 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15541 PyObject *resultobj = 0;
15542 wxJoystick *arg1 = (wxJoystick *) 0 ;
15543 int arg2 ;
15544 void *argp1 = 0 ;
15545 int res1 = 0 ;
15546 int val2 ;
15547 int ecode2 = 0 ;
15548 PyObject * obj0 = 0 ;
15549 PyObject * obj1 = 0 ;
15550 char * kwnames[] = {
15551 (char *) "self",(char *) "threshold", NULL
15552 };
15553
15554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15556 if (!SWIG_IsOK(res1)) {
15557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15558 }
15559 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15560 ecode2 = SWIG_AsVal_int(obj1, &val2);
15561 if (!SWIG_IsOK(ecode2)) {
15562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15563 }
15564 arg2 = static_cast< int >(val2);
15565 {
15566 PyThreadState* __tstate = wxPyBeginAllowThreads();
15567 (arg1)->SetMovementThreshold(arg2);
15568 wxPyEndAllowThreads(__tstate);
15569 if (PyErr_Occurred()) SWIG_fail;
15570 }
15571 resultobj = SWIG_Py_Void();
15572 return resultobj;
15573 fail:
15574 return NULL;
15575 }
15576
15577
15578 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15579 PyObject *resultobj = 0;
15580 wxJoystick *arg1 = (wxJoystick *) 0 ;
15581 bool result;
15582 void *argp1 = 0 ;
15583 int res1 = 0 ;
15584 PyObject *swig_obj[1] ;
15585
15586 if (!args) SWIG_fail;
15587 swig_obj[0] = args;
15588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15589 if (!SWIG_IsOK(res1)) {
15590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15591 }
15592 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15593 {
15594 PyThreadState* __tstate = wxPyBeginAllowThreads();
15595 result = (bool)(arg1)->IsOk();
15596 wxPyEndAllowThreads(__tstate);
15597 if (PyErr_Occurred()) SWIG_fail;
15598 }
15599 {
15600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15601 }
15602 return resultobj;
15603 fail:
15604 return NULL;
15605 }
15606
15607
15608 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15609 PyObject *resultobj = 0;
15610 wxJoystick *arg1 = (wxJoystick *) 0 ;
15611 int result;
15612 void *argp1 = 0 ;
15613 int res1 = 0 ;
15614 PyObject *swig_obj[1] ;
15615
15616 if (!args) SWIG_fail;
15617 swig_obj[0] = args;
15618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15619 if (!SWIG_IsOK(res1)) {
15620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15621 }
15622 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15623 {
15624 PyThreadState* __tstate = wxPyBeginAllowThreads();
15625 result = (int)(arg1)->GetNumberJoysticks();
15626 wxPyEndAllowThreads(__tstate);
15627 if (PyErr_Occurred()) SWIG_fail;
15628 }
15629 resultobj = SWIG_From_int(static_cast< int >(result));
15630 return resultobj;
15631 fail:
15632 return NULL;
15633 }
15634
15635
15636 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15637 PyObject *resultobj = 0;
15638 wxJoystick *arg1 = (wxJoystick *) 0 ;
15639 int result;
15640 void *argp1 = 0 ;
15641 int res1 = 0 ;
15642 PyObject *swig_obj[1] ;
15643
15644 if (!args) SWIG_fail;
15645 swig_obj[0] = args;
15646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15647 if (!SWIG_IsOK(res1)) {
15648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15649 }
15650 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15651 {
15652 PyThreadState* __tstate = wxPyBeginAllowThreads();
15653 result = (int)(arg1)->GetManufacturerId();
15654 wxPyEndAllowThreads(__tstate);
15655 if (PyErr_Occurred()) SWIG_fail;
15656 }
15657 resultobj = SWIG_From_int(static_cast< int >(result));
15658 return resultobj;
15659 fail:
15660 return NULL;
15661 }
15662
15663
15664 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15665 PyObject *resultobj = 0;
15666 wxJoystick *arg1 = (wxJoystick *) 0 ;
15667 int result;
15668 void *argp1 = 0 ;
15669 int res1 = 0 ;
15670 PyObject *swig_obj[1] ;
15671
15672 if (!args) SWIG_fail;
15673 swig_obj[0] = args;
15674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15675 if (!SWIG_IsOK(res1)) {
15676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15677 }
15678 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 result = (int)(arg1)->GetProductId();
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 resultobj = SWIG_From_int(static_cast< int >(result));
15686 return resultobj;
15687 fail:
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15693 PyObject *resultobj = 0;
15694 wxJoystick *arg1 = (wxJoystick *) 0 ;
15695 wxString result;
15696 void *argp1 = 0 ;
15697 int res1 = 0 ;
15698 PyObject *swig_obj[1] ;
15699
15700 if (!args) SWIG_fail;
15701 swig_obj[0] = args;
15702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15703 if (!SWIG_IsOK(res1)) {
15704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15705 }
15706 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 result = (arg1)->GetProductName();
15710 wxPyEndAllowThreads(__tstate);
15711 if (PyErr_Occurred()) SWIG_fail;
15712 }
15713 {
15714 #if wxUSE_UNICODE
15715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15716 #else
15717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15718 #endif
15719 }
15720 return resultobj;
15721 fail:
15722 return NULL;
15723 }
15724
15725
15726 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15727 PyObject *resultobj = 0;
15728 wxJoystick *arg1 = (wxJoystick *) 0 ;
15729 int result;
15730 void *argp1 = 0 ;
15731 int res1 = 0 ;
15732 PyObject *swig_obj[1] ;
15733
15734 if (!args) SWIG_fail;
15735 swig_obj[0] = args;
15736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15737 if (!SWIG_IsOK(res1)) {
15738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15739 }
15740 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15741 {
15742 PyThreadState* __tstate = wxPyBeginAllowThreads();
15743 result = (int)(arg1)->GetXMin();
15744 wxPyEndAllowThreads(__tstate);
15745 if (PyErr_Occurred()) SWIG_fail;
15746 }
15747 resultobj = SWIG_From_int(static_cast< int >(result));
15748 return resultobj;
15749 fail:
15750 return NULL;
15751 }
15752
15753
15754 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15755 PyObject *resultobj = 0;
15756 wxJoystick *arg1 = (wxJoystick *) 0 ;
15757 int result;
15758 void *argp1 = 0 ;
15759 int res1 = 0 ;
15760 PyObject *swig_obj[1] ;
15761
15762 if (!args) SWIG_fail;
15763 swig_obj[0] = args;
15764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15765 if (!SWIG_IsOK(res1)) {
15766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15767 }
15768 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15769 {
15770 PyThreadState* __tstate = wxPyBeginAllowThreads();
15771 result = (int)(arg1)->GetYMin();
15772 wxPyEndAllowThreads(__tstate);
15773 if (PyErr_Occurred()) SWIG_fail;
15774 }
15775 resultobj = SWIG_From_int(static_cast< int >(result));
15776 return resultobj;
15777 fail:
15778 return NULL;
15779 }
15780
15781
15782 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15783 PyObject *resultobj = 0;
15784 wxJoystick *arg1 = (wxJoystick *) 0 ;
15785 int result;
15786 void *argp1 = 0 ;
15787 int res1 = 0 ;
15788 PyObject *swig_obj[1] ;
15789
15790 if (!args) SWIG_fail;
15791 swig_obj[0] = args;
15792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15793 if (!SWIG_IsOK(res1)) {
15794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15795 }
15796 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15797 {
15798 PyThreadState* __tstate = wxPyBeginAllowThreads();
15799 result = (int)(arg1)->GetZMin();
15800 wxPyEndAllowThreads(__tstate);
15801 if (PyErr_Occurred()) SWIG_fail;
15802 }
15803 resultobj = SWIG_From_int(static_cast< int >(result));
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15811 PyObject *resultobj = 0;
15812 wxJoystick *arg1 = (wxJoystick *) 0 ;
15813 int result;
15814 void *argp1 = 0 ;
15815 int res1 = 0 ;
15816 PyObject *swig_obj[1] ;
15817
15818 if (!args) SWIG_fail;
15819 swig_obj[0] = args;
15820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15821 if (!SWIG_IsOK(res1)) {
15822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15823 }
15824 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15825 {
15826 PyThreadState* __tstate = wxPyBeginAllowThreads();
15827 result = (int)(arg1)->GetXMax();
15828 wxPyEndAllowThreads(__tstate);
15829 if (PyErr_Occurred()) SWIG_fail;
15830 }
15831 resultobj = SWIG_From_int(static_cast< int >(result));
15832 return resultobj;
15833 fail:
15834 return NULL;
15835 }
15836
15837
15838 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15839 PyObject *resultobj = 0;
15840 wxJoystick *arg1 = (wxJoystick *) 0 ;
15841 int result;
15842 void *argp1 = 0 ;
15843 int res1 = 0 ;
15844 PyObject *swig_obj[1] ;
15845
15846 if (!args) SWIG_fail;
15847 swig_obj[0] = args;
15848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15849 if (!SWIG_IsOK(res1)) {
15850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15851 }
15852 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 result = (int)(arg1)->GetYMax();
15856 wxPyEndAllowThreads(__tstate);
15857 if (PyErr_Occurred()) SWIG_fail;
15858 }
15859 resultobj = SWIG_From_int(static_cast< int >(result));
15860 return resultobj;
15861 fail:
15862 return NULL;
15863 }
15864
15865
15866 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15867 PyObject *resultobj = 0;
15868 wxJoystick *arg1 = (wxJoystick *) 0 ;
15869 int result;
15870 void *argp1 = 0 ;
15871 int res1 = 0 ;
15872 PyObject *swig_obj[1] ;
15873
15874 if (!args) SWIG_fail;
15875 swig_obj[0] = args;
15876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15877 if (!SWIG_IsOK(res1)) {
15878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15879 }
15880 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15881 {
15882 PyThreadState* __tstate = wxPyBeginAllowThreads();
15883 result = (int)(arg1)->GetZMax();
15884 wxPyEndAllowThreads(__tstate);
15885 if (PyErr_Occurred()) SWIG_fail;
15886 }
15887 resultobj = SWIG_From_int(static_cast< int >(result));
15888 return resultobj;
15889 fail:
15890 return NULL;
15891 }
15892
15893
15894 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15895 PyObject *resultobj = 0;
15896 wxJoystick *arg1 = (wxJoystick *) 0 ;
15897 int result;
15898 void *argp1 = 0 ;
15899 int res1 = 0 ;
15900 PyObject *swig_obj[1] ;
15901
15902 if (!args) SWIG_fail;
15903 swig_obj[0] = args;
15904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15905 if (!SWIG_IsOK(res1)) {
15906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15907 }
15908 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15909 {
15910 PyThreadState* __tstate = wxPyBeginAllowThreads();
15911 result = (int)(arg1)->GetNumberButtons();
15912 wxPyEndAllowThreads(__tstate);
15913 if (PyErr_Occurred()) SWIG_fail;
15914 }
15915 resultobj = SWIG_From_int(static_cast< int >(result));
15916 return resultobj;
15917 fail:
15918 return NULL;
15919 }
15920
15921
15922 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15923 PyObject *resultobj = 0;
15924 wxJoystick *arg1 = (wxJoystick *) 0 ;
15925 int result;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 PyObject *swig_obj[1] ;
15929
15930 if (!args) SWIG_fail;
15931 swig_obj[0] = args;
15932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15933 if (!SWIG_IsOK(res1)) {
15934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15935 }
15936 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = (int)(arg1)->GetNumberAxes();
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 resultobj = SWIG_From_int(static_cast< int >(result));
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15951 PyObject *resultobj = 0;
15952 wxJoystick *arg1 = (wxJoystick *) 0 ;
15953 int result;
15954 void *argp1 = 0 ;
15955 int res1 = 0 ;
15956 PyObject *swig_obj[1] ;
15957
15958 if (!args) SWIG_fail;
15959 swig_obj[0] = args;
15960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15961 if (!SWIG_IsOK(res1)) {
15962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15963 }
15964 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15965 {
15966 PyThreadState* __tstate = wxPyBeginAllowThreads();
15967 result = (int)(arg1)->GetMaxButtons();
15968 wxPyEndAllowThreads(__tstate);
15969 if (PyErr_Occurred()) SWIG_fail;
15970 }
15971 resultobj = SWIG_From_int(static_cast< int >(result));
15972 return resultobj;
15973 fail:
15974 return NULL;
15975 }
15976
15977
15978 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15979 PyObject *resultobj = 0;
15980 wxJoystick *arg1 = (wxJoystick *) 0 ;
15981 int result;
15982 void *argp1 = 0 ;
15983 int res1 = 0 ;
15984 PyObject *swig_obj[1] ;
15985
15986 if (!args) SWIG_fail;
15987 swig_obj[0] = args;
15988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15989 if (!SWIG_IsOK(res1)) {
15990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15991 }
15992 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15993 {
15994 PyThreadState* __tstate = wxPyBeginAllowThreads();
15995 result = (int)(arg1)->GetMaxAxes();
15996 wxPyEndAllowThreads(__tstate);
15997 if (PyErr_Occurred()) SWIG_fail;
15998 }
15999 resultobj = SWIG_From_int(static_cast< int >(result));
16000 return resultobj;
16001 fail:
16002 return NULL;
16003 }
16004
16005
16006 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16007 PyObject *resultobj = 0;
16008 wxJoystick *arg1 = (wxJoystick *) 0 ;
16009 int result;
16010 void *argp1 = 0 ;
16011 int res1 = 0 ;
16012 PyObject *swig_obj[1] ;
16013
16014 if (!args) SWIG_fail;
16015 swig_obj[0] = args;
16016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16017 if (!SWIG_IsOK(res1)) {
16018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16019 }
16020 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16021 {
16022 PyThreadState* __tstate = wxPyBeginAllowThreads();
16023 result = (int)(arg1)->GetPollingMin();
16024 wxPyEndAllowThreads(__tstate);
16025 if (PyErr_Occurred()) SWIG_fail;
16026 }
16027 resultobj = SWIG_From_int(static_cast< int >(result));
16028 return resultobj;
16029 fail:
16030 return NULL;
16031 }
16032
16033
16034 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16035 PyObject *resultobj = 0;
16036 wxJoystick *arg1 = (wxJoystick *) 0 ;
16037 int result;
16038 void *argp1 = 0 ;
16039 int res1 = 0 ;
16040 PyObject *swig_obj[1] ;
16041
16042 if (!args) SWIG_fail;
16043 swig_obj[0] = args;
16044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16045 if (!SWIG_IsOK(res1)) {
16046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16047 }
16048 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16049 {
16050 PyThreadState* __tstate = wxPyBeginAllowThreads();
16051 result = (int)(arg1)->GetPollingMax();
16052 wxPyEndAllowThreads(__tstate);
16053 if (PyErr_Occurred()) SWIG_fail;
16054 }
16055 resultobj = SWIG_From_int(static_cast< int >(result));
16056 return resultobj;
16057 fail:
16058 return NULL;
16059 }
16060
16061
16062 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16063 PyObject *resultobj = 0;
16064 wxJoystick *arg1 = (wxJoystick *) 0 ;
16065 int result;
16066 void *argp1 = 0 ;
16067 int res1 = 0 ;
16068 PyObject *swig_obj[1] ;
16069
16070 if (!args) SWIG_fail;
16071 swig_obj[0] = args;
16072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16073 if (!SWIG_IsOK(res1)) {
16074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16075 }
16076 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16077 {
16078 PyThreadState* __tstate = wxPyBeginAllowThreads();
16079 result = (int)(arg1)->GetRudderMin();
16080 wxPyEndAllowThreads(__tstate);
16081 if (PyErr_Occurred()) SWIG_fail;
16082 }
16083 resultobj = SWIG_From_int(static_cast< int >(result));
16084 return resultobj;
16085 fail:
16086 return NULL;
16087 }
16088
16089
16090 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16091 PyObject *resultobj = 0;
16092 wxJoystick *arg1 = (wxJoystick *) 0 ;
16093 int result;
16094 void *argp1 = 0 ;
16095 int res1 = 0 ;
16096 PyObject *swig_obj[1] ;
16097
16098 if (!args) SWIG_fail;
16099 swig_obj[0] = args;
16100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16101 if (!SWIG_IsOK(res1)) {
16102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16103 }
16104 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16105 {
16106 PyThreadState* __tstate = wxPyBeginAllowThreads();
16107 result = (int)(arg1)->GetRudderMax();
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 resultobj = SWIG_From_int(static_cast< int >(result));
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16119 PyObject *resultobj = 0;
16120 wxJoystick *arg1 = (wxJoystick *) 0 ;
16121 int result;
16122 void *argp1 = 0 ;
16123 int res1 = 0 ;
16124 PyObject *swig_obj[1] ;
16125
16126 if (!args) SWIG_fail;
16127 swig_obj[0] = args;
16128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16129 if (!SWIG_IsOK(res1)) {
16130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16131 }
16132 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 result = (int)(arg1)->GetUMin();
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 resultobj = SWIG_From_int(static_cast< int >(result));
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16147 PyObject *resultobj = 0;
16148 wxJoystick *arg1 = (wxJoystick *) 0 ;
16149 int result;
16150 void *argp1 = 0 ;
16151 int res1 = 0 ;
16152 PyObject *swig_obj[1] ;
16153
16154 if (!args) SWIG_fail;
16155 swig_obj[0] = args;
16156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16157 if (!SWIG_IsOK(res1)) {
16158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16159 }
16160 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16161 {
16162 PyThreadState* __tstate = wxPyBeginAllowThreads();
16163 result = (int)(arg1)->GetUMax();
16164 wxPyEndAllowThreads(__tstate);
16165 if (PyErr_Occurred()) SWIG_fail;
16166 }
16167 resultobj = SWIG_From_int(static_cast< int >(result));
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16175 PyObject *resultobj = 0;
16176 wxJoystick *arg1 = (wxJoystick *) 0 ;
16177 int result;
16178 void *argp1 = 0 ;
16179 int res1 = 0 ;
16180 PyObject *swig_obj[1] ;
16181
16182 if (!args) SWIG_fail;
16183 swig_obj[0] = args;
16184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16185 if (!SWIG_IsOK(res1)) {
16186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16187 }
16188 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16189 {
16190 PyThreadState* __tstate = wxPyBeginAllowThreads();
16191 result = (int)(arg1)->GetVMin();
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 resultobj = SWIG_From_int(static_cast< int >(result));
16196 return resultobj;
16197 fail:
16198 return NULL;
16199 }
16200
16201
16202 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16203 PyObject *resultobj = 0;
16204 wxJoystick *arg1 = (wxJoystick *) 0 ;
16205 int result;
16206 void *argp1 = 0 ;
16207 int res1 = 0 ;
16208 PyObject *swig_obj[1] ;
16209
16210 if (!args) SWIG_fail;
16211 swig_obj[0] = args;
16212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16213 if (!SWIG_IsOK(res1)) {
16214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16215 }
16216 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16217 {
16218 PyThreadState* __tstate = wxPyBeginAllowThreads();
16219 result = (int)(arg1)->GetVMax();
16220 wxPyEndAllowThreads(__tstate);
16221 if (PyErr_Occurred()) SWIG_fail;
16222 }
16223 resultobj = SWIG_From_int(static_cast< int >(result));
16224 return resultobj;
16225 fail:
16226 return NULL;
16227 }
16228
16229
16230 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16231 PyObject *resultobj = 0;
16232 wxJoystick *arg1 = (wxJoystick *) 0 ;
16233 bool result;
16234 void *argp1 = 0 ;
16235 int res1 = 0 ;
16236 PyObject *swig_obj[1] ;
16237
16238 if (!args) SWIG_fail;
16239 swig_obj[0] = args;
16240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16241 if (!SWIG_IsOK(res1)) {
16242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16243 }
16244 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16245 {
16246 PyThreadState* __tstate = wxPyBeginAllowThreads();
16247 result = (bool)(arg1)->HasRudder();
16248 wxPyEndAllowThreads(__tstate);
16249 if (PyErr_Occurred()) SWIG_fail;
16250 }
16251 {
16252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16253 }
16254 return resultobj;
16255 fail:
16256 return NULL;
16257 }
16258
16259
16260 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16261 PyObject *resultobj = 0;
16262 wxJoystick *arg1 = (wxJoystick *) 0 ;
16263 bool result;
16264 void *argp1 = 0 ;
16265 int res1 = 0 ;
16266 PyObject *swig_obj[1] ;
16267
16268 if (!args) SWIG_fail;
16269 swig_obj[0] = args;
16270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16271 if (!SWIG_IsOK(res1)) {
16272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16273 }
16274 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16275 {
16276 PyThreadState* __tstate = wxPyBeginAllowThreads();
16277 result = (bool)(arg1)->HasZ();
16278 wxPyEndAllowThreads(__tstate);
16279 if (PyErr_Occurred()) SWIG_fail;
16280 }
16281 {
16282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16283 }
16284 return resultobj;
16285 fail:
16286 return NULL;
16287 }
16288
16289
16290 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16291 PyObject *resultobj = 0;
16292 wxJoystick *arg1 = (wxJoystick *) 0 ;
16293 bool result;
16294 void *argp1 = 0 ;
16295 int res1 = 0 ;
16296 PyObject *swig_obj[1] ;
16297
16298 if (!args) SWIG_fail;
16299 swig_obj[0] = args;
16300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16301 if (!SWIG_IsOK(res1)) {
16302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16303 }
16304 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16305 {
16306 PyThreadState* __tstate = wxPyBeginAllowThreads();
16307 result = (bool)(arg1)->HasU();
16308 wxPyEndAllowThreads(__tstate);
16309 if (PyErr_Occurred()) SWIG_fail;
16310 }
16311 {
16312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16313 }
16314 return resultobj;
16315 fail:
16316 return NULL;
16317 }
16318
16319
16320 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16321 PyObject *resultobj = 0;
16322 wxJoystick *arg1 = (wxJoystick *) 0 ;
16323 bool result;
16324 void *argp1 = 0 ;
16325 int res1 = 0 ;
16326 PyObject *swig_obj[1] ;
16327
16328 if (!args) SWIG_fail;
16329 swig_obj[0] = args;
16330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16331 if (!SWIG_IsOK(res1)) {
16332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16333 }
16334 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16335 {
16336 PyThreadState* __tstate = wxPyBeginAllowThreads();
16337 result = (bool)(arg1)->HasV();
16338 wxPyEndAllowThreads(__tstate);
16339 if (PyErr_Occurred()) SWIG_fail;
16340 }
16341 {
16342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16343 }
16344 return resultobj;
16345 fail:
16346 return NULL;
16347 }
16348
16349
16350 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16351 PyObject *resultobj = 0;
16352 wxJoystick *arg1 = (wxJoystick *) 0 ;
16353 bool result;
16354 void *argp1 = 0 ;
16355 int res1 = 0 ;
16356 PyObject *swig_obj[1] ;
16357
16358 if (!args) SWIG_fail;
16359 swig_obj[0] = args;
16360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16361 if (!SWIG_IsOK(res1)) {
16362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16363 }
16364 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 result = (bool)(arg1)->HasPOV();
16368 wxPyEndAllowThreads(__tstate);
16369 if (PyErr_Occurred()) SWIG_fail;
16370 }
16371 {
16372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16373 }
16374 return resultobj;
16375 fail:
16376 return NULL;
16377 }
16378
16379
16380 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16381 PyObject *resultobj = 0;
16382 wxJoystick *arg1 = (wxJoystick *) 0 ;
16383 bool result;
16384 void *argp1 = 0 ;
16385 int res1 = 0 ;
16386 PyObject *swig_obj[1] ;
16387
16388 if (!args) SWIG_fail;
16389 swig_obj[0] = args;
16390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16391 if (!SWIG_IsOK(res1)) {
16392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16393 }
16394 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16395 {
16396 PyThreadState* __tstate = wxPyBeginAllowThreads();
16397 result = (bool)(arg1)->HasPOV4Dir();
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 {
16402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16403 }
16404 return resultobj;
16405 fail:
16406 return NULL;
16407 }
16408
16409
16410 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16411 PyObject *resultobj = 0;
16412 wxJoystick *arg1 = (wxJoystick *) 0 ;
16413 bool result;
16414 void *argp1 = 0 ;
16415 int res1 = 0 ;
16416 PyObject *swig_obj[1] ;
16417
16418 if (!args) SWIG_fail;
16419 swig_obj[0] = args;
16420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16421 if (!SWIG_IsOK(res1)) {
16422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16423 }
16424 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16425 {
16426 PyThreadState* __tstate = wxPyBeginAllowThreads();
16427 result = (bool)(arg1)->HasPOVCTS();
16428 wxPyEndAllowThreads(__tstate);
16429 if (PyErr_Occurred()) SWIG_fail;
16430 }
16431 {
16432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16433 }
16434 return resultobj;
16435 fail:
16436 return NULL;
16437 }
16438
16439
16440 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16441 PyObject *resultobj = 0;
16442 wxJoystick *arg1 = (wxJoystick *) 0 ;
16443 wxWindow *arg2 = (wxWindow *) 0 ;
16444 int arg3 = (int) 0 ;
16445 bool result;
16446 void *argp1 = 0 ;
16447 int res1 = 0 ;
16448 void *argp2 = 0 ;
16449 int res2 = 0 ;
16450 int val3 ;
16451 int ecode3 = 0 ;
16452 PyObject * obj0 = 0 ;
16453 PyObject * obj1 = 0 ;
16454 PyObject * obj2 = 0 ;
16455 char * kwnames[] = {
16456 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16457 };
16458
16459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16461 if (!SWIG_IsOK(res1)) {
16462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16463 }
16464 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16465 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16466 if (!SWIG_IsOK(res2)) {
16467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16468 }
16469 arg2 = reinterpret_cast< wxWindow * >(argp2);
16470 if (obj2) {
16471 ecode3 = SWIG_AsVal_int(obj2, &val3);
16472 if (!SWIG_IsOK(ecode3)) {
16473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16474 }
16475 arg3 = static_cast< int >(val3);
16476 }
16477 {
16478 PyThreadState* __tstate = wxPyBeginAllowThreads();
16479 result = (bool)(arg1)->SetCapture(arg2,arg3);
16480 wxPyEndAllowThreads(__tstate);
16481 if (PyErr_Occurred()) SWIG_fail;
16482 }
16483 {
16484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16485 }
16486 return resultobj;
16487 fail:
16488 return NULL;
16489 }
16490
16491
16492 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16493 PyObject *resultobj = 0;
16494 wxJoystick *arg1 = (wxJoystick *) 0 ;
16495 bool result;
16496 void *argp1 = 0 ;
16497 int res1 = 0 ;
16498 PyObject *swig_obj[1] ;
16499
16500 if (!args) SWIG_fail;
16501 swig_obj[0] = args;
16502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16503 if (!SWIG_IsOK(res1)) {
16504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16505 }
16506 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16507 {
16508 PyThreadState* __tstate = wxPyBeginAllowThreads();
16509 result = (bool)(arg1)->ReleaseCapture();
16510 wxPyEndAllowThreads(__tstate);
16511 if (PyErr_Occurred()) SWIG_fail;
16512 }
16513 {
16514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16515 }
16516 return resultobj;
16517 fail:
16518 return NULL;
16519 }
16520
16521
16522 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16523 PyObject *obj;
16524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16525 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16526 return SWIG_Py_Void();
16527 }
16528
16529 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16530 return SWIG_Python_InitShadowInstance(args);
16531 }
16532
16533 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16536 int arg2 = (int) 0 ;
16537 int arg3 = (int) wxJOYSTICK1 ;
16538 int arg4 = (int) 0 ;
16539 wxJoystickEvent *result = 0 ;
16540 int val1 ;
16541 int ecode1 = 0 ;
16542 int val2 ;
16543 int ecode2 = 0 ;
16544 int val3 ;
16545 int ecode3 = 0 ;
16546 int val4 ;
16547 int ecode4 = 0 ;
16548 PyObject * obj0 = 0 ;
16549 PyObject * obj1 = 0 ;
16550 PyObject * obj2 = 0 ;
16551 PyObject * obj3 = 0 ;
16552 char * kwnames[] = {
16553 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16554 };
16555
16556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16557 if (obj0) {
16558 ecode1 = SWIG_AsVal_int(obj0, &val1);
16559 if (!SWIG_IsOK(ecode1)) {
16560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16561 }
16562 arg1 = static_cast< wxEventType >(val1);
16563 }
16564 if (obj1) {
16565 ecode2 = SWIG_AsVal_int(obj1, &val2);
16566 if (!SWIG_IsOK(ecode2)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16568 }
16569 arg2 = static_cast< int >(val2);
16570 }
16571 if (obj2) {
16572 ecode3 = SWIG_AsVal_int(obj2, &val3);
16573 if (!SWIG_IsOK(ecode3)) {
16574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16575 }
16576 arg3 = static_cast< int >(val3);
16577 }
16578 if (obj3) {
16579 ecode4 = SWIG_AsVal_int(obj3, &val4);
16580 if (!SWIG_IsOK(ecode4)) {
16581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16582 }
16583 arg4 = static_cast< int >(val4);
16584 }
16585 {
16586 PyThreadState* __tstate = wxPyBeginAllowThreads();
16587 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16588 wxPyEndAllowThreads(__tstate);
16589 if (PyErr_Occurred()) SWIG_fail;
16590 }
16591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16599 PyObject *resultobj = 0;
16600 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16601 wxPoint result;
16602 void *argp1 = 0 ;
16603 int res1 = 0 ;
16604 PyObject *swig_obj[1] ;
16605
16606 if (!args) SWIG_fail;
16607 swig_obj[0] = args;
16608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16609 if (!SWIG_IsOK(res1)) {
16610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16611 }
16612 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16613 {
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16620 return resultobj;
16621 fail:
16622 return NULL;
16623 }
16624
16625
16626 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16627 PyObject *resultobj = 0;
16628 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16629 int result;
16630 void *argp1 = 0 ;
16631 int res1 = 0 ;
16632 PyObject *swig_obj[1] ;
16633
16634 if (!args) SWIG_fail;
16635 swig_obj[0] = args;
16636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16637 if (!SWIG_IsOK(res1)) {
16638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16639 }
16640 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16641 {
16642 PyThreadState* __tstate = wxPyBeginAllowThreads();
16643 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 resultobj = SWIG_From_int(static_cast< int >(result));
16648 return resultobj;
16649 fail:
16650 return NULL;
16651 }
16652
16653
16654 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16655 PyObject *resultobj = 0;
16656 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16657 int result;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 PyObject *swig_obj[1] ;
16661
16662 if (!args) SWIG_fail;
16663 swig_obj[0] = args;
16664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16665 if (!SWIG_IsOK(res1)) {
16666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16667 }
16668 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16672 wxPyEndAllowThreads(__tstate);
16673 if (PyErr_Occurred()) SWIG_fail;
16674 }
16675 resultobj = SWIG_From_int(static_cast< int >(result));
16676 return resultobj;
16677 fail:
16678 return NULL;
16679 }
16680
16681
16682 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16683 PyObject *resultobj = 0;
16684 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16685 int result;
16686 void *argp1 = 0 ;
16687 int res1 = 0 ;
16688 PyObject *swig_obj[1] ;
16689
16690 if (!args) SWIG_fail;
16691 swig_obj[0] = args;
16692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16693 if (!SWIG_IsOK(res1)) {
16694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16695 }
16696 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16697 {
16698 PyThreadState* __tstate = wxPyBeginAllowThreads();
16699 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 resultobj = SWIG_From_int(static_cast< int >(result));
16704 return resultobj;
16705 fail:
16706 return NULL;
16707 }
16708
16709
16710 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16711 PyObject *resultobj = 0;
16712 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16713 int result;
16714 void *argp1 = 0 ;
16715 int res1 = 0 ;
16716 PyObject *swig_obj[1] ;
16717
16718 if (!args) SWIG_fail;
16719 swig_obj[0] = args;
16720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16721 if (!SWIG_IsOK(res1)) {
16722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16723 }
16724 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16725 {
16726 PyThreadState* __tstate = wxPyBeginAllowThreads();
16727 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16728 wxPyEndAllowThreads(__tstate);
16729 if (PyErr_Occurred()) SWIG_fail;
16730 }
16731 resultobj = SWIG_From_int(static_cast< int >(result));
16732 return resultobj;
16733 fail:
16734 return NULL;
16735 }
16736
16737
16738 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16739 PyObject *resultobj = 0;
16740 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16741 int arg2 ;
16742 void *argp1 = 0 ;
16743 int res1 = 0 ;
16744 int val2 ;
16745 int ecode2 = 0 ;
16746 PyObject * obj0 = 0 ;
16747 PyObject * obj1 = 0 ;
16748 char * kwnames[] = {
16749 (char *) "self",(char *) "stick", NULL
16750 };
16751
16752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16754 if (!SWIG_IsOK(res1)) {
16755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16756 }
16757 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16758 ecode2 = SWIG_AsVal_int(obj1, &val2);
16759 if (!SWIG_IsOK(ecode2)) {
16760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16761 }
16762 arg2 = static_cast< int >(val2);
16763 {
16764 PyThreadState* __tstate = wxPyBeginAllowThreads();
16765 (arg1)->SetJoystick(arg2);
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 resultobj = SWIG_Py_Void();
16770 return resultobj;
16771 fail:
16772 return NULL;
16773 }
16774
16775
16776 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16777 PyObject *resultobj = 0;
16778 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16779 int arg2 ;
16780 void *argp1 = 0 ;
16781 int res1 = 0 ;
16782 int val2 ;
16783 int ecode2 = 0 ;
16784 PyObject * obj0 = 0 ;
16785 PyObject * obj1 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "self",(char *) "state", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16792 if (!SWIG_IsOK(res1)) {
16793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16794 }
16795 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16796 ecode2 = SWIG_AsVal_int(obj1, &val2);
16797 if (!SWIG_IsOK(ecode2)) {
16798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16799 }
16800 arg2 = static_cast< int >(val2);
16801 {
16802 PyThreadState* __tstate = wxPyBeginAllowThreads();
16803 (arg1)->SetButtonState(arg2);
16804 wxPyEndAllowThreads(__tstate);
16805 if (PyErr_Occurred()) SWIG_fail;
16806 }
16807 resultobj = SWIG_Py_Void();
16808 return resultobj;
16809 fail:
16810 return NULL;
16811 }
16812
16813
16814 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16815 PyObject *resultobj = 0;
16816 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16817 int arg2 ;
16818 void *argp1 = 0 ;
16819 int res1 = 0 ;
16820 int val2 ;
16821 int ecode2 = 0 ;
16822 PyObject * obj0 = 0 ;
16823 PyObject * obj1 = 0 ;
16824 char * kwnames[] = {
16825 (char *) "self",(char *) "change", NULL
16826 };
16827
16828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16830 if (!SWIG_IsOK(res1)) {
16831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16832 }
16833 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16834 ecode2 = SWIG_AsVal_int(obj1, &val2);
16835 if (!SWIG_IsOK(ecode2)) {
16836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16837 }
16838 arg2 = static_cast< int >(val2);
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 (arg1)->SetButtonChange(arg2);
16842 wxPyEndAllowThreads(__tstate);
16843 if (PyErr_Occurred()) SWIG_fail;
16844 }
16845 resultobj = SWIG_Py_Void();
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16853 PyObject *resultobj = 0;
16854 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16855 wxPoint *arg2 = 0 ;
16856 void *argp1 = 0 ;
16857 int res1 = 0 ;
16858 wxPoint temp2 ;
16859 PyObject * obj0 = 0 ;
16860 PyObject * obj1 = 0 ;
16861 char * kwnames[] = {
16862 (char *) "self",(char *) "pos", NULL
16863 };
16864
16865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16867 if (!SWIG_IsOK(res1)) {
16868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16869 }
16870 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16871 {
16872 arg2 = &temp2;
16873 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16874 }
16875 {
16876 PyThreadState* __tstate = wxPyBeginAllowThreads();
16877 (arg1)->SetPosition((wxPoint const &)*arg2);
16878 wxPyEndAllowThreads(__tstate);
16879 if (PyErr_Occurred()) SWIG_fail;
16880 }
16881 resultobj = SWIG_Py_Void();
16882 return resultobj;
16883 fail:
16884 return NULL;
16885 }
16886
16887
16888 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16889 PyObject *resultobj = 0;
16890 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16891 int arg2 ;
16892 void *argp1 = 0 ;
16893 int res1 = 0 ;
16894 int val2 ;
16895 int ecode2 = 0 ;
16896 PyObject * obj0 = 0 ;
16897 PyObject * obj1 = 0 ;
16898 char * kwnames[] = {
16899 (char *) "self",(char *) "zPos", NULL
16900 };
16901
16902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16904 if (!SWIG_IsOK(res1)) {
16905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16906 }
16907 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16908 ecode2 = SWIG_AsVal_int(obj1, &val2);
16909 if (!SWIG_IsOK(ecode2)) {
16910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16911 }
16912 arg2 = static_cast< int >(val2);
16913 {
16914 PyThreadState* __tstate = wxPyBeginAllowThreads();
16915 (arg1)->SetZPosition(arg2);
16916 wxPyEndAllowThreads(__tstate);
16917 if (PyErr_Occurred()) SWIG_fail;
16918 }
16919 resultobj = SWIG_Py_Void();
16920 return resultobj;
16921 fail:
16922 return NULL;
16923 }
16924
16925
16926 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16927 PyObject *resultobj = 0;
16928 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16929 bool result;
16930 void *argp1 = 0 ;
16931 int res1 = 0 ;
16932 PyObject *swig_obj[1] ;
16933
16934 if (!args) SWIG_fail;
16935 swig_obj[0] = args;
16936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16937 if (!SWIG_IsOK(res1)) {
16938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16939 }
16940 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16941 {
16942 PyThreadState* __tstate = wxPyBeginAllowThreads();
16943 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16944 wxPyEndAllowThreads(__tstate);
16945 if (PyErr_Occurred()) SWIG_fail;
16946 }
16947 {
16948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16949 }
16950 return resultobj;
16951 fail:
16952 return NULL;
16953 }
16954
16955
16956 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16957 PyObject *resultobj = 0;
16958 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16959 bool result;
16960 void *argp1 = 0 ;
16961 int res1 = 0 ;
16962 PyObject *swig_obj[1] ;
16963
16964 if (!args) SWIG_fail;
16965 swig_obj[0] = args;
16966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16967 if (!SWIG_IsOK(res1)) {
16968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16969 }
16970 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16971 {
16972 PyThreadState* __tstate = wxPyBeginAllowThreads();
16973 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 {
16978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16979 }
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16987 PyObject *resultobj = 0;
16988 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16989 bool result;
16990 void *argp1 = 0 ;
16991 int res1 = 0 ;
16992 PyObject *swig_obj[1] ;
16993
16994 if (!args) SWIG_fail;
16995 swig_obj[0] = args;
16996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16997 if (!SWIG_IsOK(res1)) {
16998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16999 }
17000 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17001 {
17002 PyThreadState* __tstate = wxPyBeginAllowThreads();
17003 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
17004 wxPyEndAllowThreads(__tstate);
17005 if (PyErr_Occurred()) SWIG_fail;
17006 }
17007 {
17008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17009 }
17010 return resultobj;
17011 fail:
17012 return NULL;
17013 }
17014
17015
17016 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17017 PyObject *resultobj = 0;
17018 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17019 int arg2 = (int) wxJOY_BUTTON_ANY ;
17020 bool result;
17021 void *argp1 = 0 ;
17022 int res1 = 0 ;
17023 int val2 ;
17024 int ecode2 = 0 ;
17025 PyObject * obj0 = 0 ;
17026 PyObject * obj1 = 0 ;
17027 char * kwnames[] = {
17028 (char *) "self",(char *) "but", NULL
17029 };
17030
17031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17033 if (!SWIG_IsOK(res1)) {
17034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17035 }
17036 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17037 if (obj1) {
17038 ecode2 = SWIG_AsVal_int(obj1, &val2);
17039 if (!SWIG_IsOK(ecode2)) {
17040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17041 }
17042 arg2 = static_cast< int >(val2);
17043 }
17044 {
17045 PyThreadState* __tstate = wxPyBeginAllowThreads();
17046 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17047 wxPyEndAllowThreads(__tstate);
17048 if (PyErr_Occurred()) SWIG_fail;
17049 }
17050 {
17051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17052 }
17053 return resultobj;
17054 fail:
17055 return NULL;
17056 }
17057
17058
17059 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17060 PyObject *resultobj = 0;
17061 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17062 int arg2 = (int) wxJOY_BUTTON_ANY ;
17063 bool result;
17064 void *argp1 = 0 ;
17065 int res1 = 0 ;
17066 int val2 ;
17067 int ecode2 = 0 ;
17068 PyObject * obj0 = 0 ;
17069 PyObject * obj1 = 0 ;
17070 char * kwnames[] = {
17071 (char *) "self",(char *) "but", NULL
17072 };
17073
17074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17076 if (!SWIG_IsOK(res1)) {
17077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17078 }
17079 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17080 if (obj1) {
17081 ecode2 = SWIG_AsVal_int(obj1, &val2);
17082 if (!SWIG_IsOK(ecode2)) {
17083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17084 }
17085 arg2 = static_cast< int >(val2);
17086 }
17087 {
17088 PyThreadState* __tstate = wxPyBeginAllowThreads();
17089 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17090 wxPyEndAllowThreads(__tstate);
17091 if (PyErr_Occurred()) SWIG_fail;
17092 }
17093 {
17094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17095 }
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj = 0;
17104 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17105 int arg2 = (int) wxJOY_BUTTON_ANY ;
17106 bool result;
17107 void *argp1 = 0 ;
17108 int res1 = 0 ;
17109 int val2 ;
17110 int ecode2 = 0 ;
17111 PyObject * obj0 = 0 ;
17112 PyObject * obj1 = 0 ;
17113 char * kwnames[] = {
17114 (char *) "self",(char *) "but", NULL
17115 };
17116
17117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17119 if (!SWIG_IsOK(res1)) {
17120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17121 }
17122 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17123 if (obj1) {
17124 ecode2 = SWIG_AsVal_int(obj1, &val2);
17125 if (!SWIG_IsOK(ecode2)) {
17126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17127 }
17128 arg2 = static_cast< int >(val2);
17129 }
17130 {
17131 PyThreadState* __tstate = wxPyBeginAllowThreads();
17132 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17133 wxPyEndAllowThreads(__tstate);
17134 if (PyErr_Occurred()) SWIG_fail;
17135 }
17136 {
17137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17138 }
17139 return resultobj;
17140 fail:
17141 return NULL;
17142 }
17143
17144
17145 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17146 PyObject *obj;
17147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17148 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17149 return SWIG_Py_Void();
17150 }
17151
17152 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17153 return SWIG_Python_InitShadowInstance(args);
17154 }
17155
17156 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj = 0;
17158 wxString const &arg1_defvalue = wxPyEmptyString ;
17159 wxString *arg1 = (wxString *) &arg1_defvalue ;
17160 wxSound *result = 0 ;
17161 bool temp1 = false ;
17162 PyObject * obj0 = 0 ;
17163 char * kwnames[] = {
17164 (char *) "fileName", NULL
17165 };
17166
17167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17168 if (obj0) {
17169 {
17170 arg1 = wxString_in_helper(obj0);
17171 if (arg1 == NULL) SWIG_fail;
17172 temp1 = true;
17173 }
17174 }
17175 {
17176 if (!wxPyCheckForApp()) SWIG_fail;
17177 PyThreadState* __tstate = wxPyBeginAllowThreads();
17178 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17179 wxPyEndAllowThreads(__tstate);
17180 if (PyErr_Occurred()) SWIG_fail;
17181 }
17182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17183 {
17184 if (temp1)
17185 delete arg1;
17186 }
17187 return resultobj;
17188 fail:
17189 {
17190 if (temp1)
17191 delete arg1;
17192 }
17193 return NULL;
17194 }
17195
17196
17197 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17198 PyObject *resultobj = 0;
17199 PyObject *arg1 = (PyObject *) 0 ;
17200 wxSound *result = 0 ;
17201 PyObject * obj0 = 0 ;
17202 char * kwnames[] = {
17203 (char *) "data", NULL
17204 };
17205
17206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17207 arg1 = obj0;
17208 {
17209 if (!wxPyCheckForApp()) SWIG_fail;
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (wxSound *)new_wxSound(arg1);
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17223 PyObject *resultobj = 0;
17224 wxSound *arg1 = (wxSound *) 0 ;
17225 void *argp1 = 0 ;
17226 int res1 = 0 ;
17227 PyObject *swig_obj[1] ;
17228
17229 if (!args) SWIG_fail;
17230 swig_obj[0] = args;
17231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17232 if (!SWIG_IsOK(res1)) {
17233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17234 }
17235 arg1 = reinterpret_cast< wxSound * >(argp1);
17236 {
17237 PyThreadState* __tstate = wxPyBeginAllowThreads();
17238 delete arg1;
17239
17240 wxPyEndAllowThreads(__tstate);
17241 if (PyErr_Occurred()) SWIG_fail;
17242 }
17243 resultobj = SWIG_Py_Void();
17244 return resultobj;
17245 fail:
17246 return NULL;
17247 }
17248
17249
17250 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17251 PyObject *resultobj = 0;
17252 wxSound *arg1 = (wxSound *) 0 ;
17253 wxString *arg2 = 0 ;
17254 bool result;
17255 void *argp1 = 0 ;
17256 int res1 = 0 ;
17257 bool temp2 = false ;
17258 PyObject * obj0 = 0 ;
17259 PyObject * obj1 = 0 ;
17260 char * kwnames[] = {
17261 (char *) "self",(char *) "fileName", NULL
17262 };
17263
17264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17266 if (!SWIG_IsOK(res1)) {
17267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17268 }
17269 arg1 = reinterpret_cast< wxSound * >(argp1);
17270 {
17271 arg2 = wxString_in_helper(obj1);
17272 if (arg2 == NULL) SWIG_fail;
17273 temp2 = true;
17274 }
17275 {
17276 PyThreadState* __tstate = wxPyBeginAllowThreads();
17277 result = (bool)(arg1)->Create((wxString const &)*arg2);
17278 wxPyEndAllowThreads(__tstate);
17279 if (PyErr_Occurred()) SWIG_fail;
17280 }
17281 {
17282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17283 }
17284 {
17285 if (temp2)
17286 delete arg2;
17287 }
17288 return resultobj;
17289 fail:
17290 {
17291 if (temp2)
17292 delete arg2;
17293 }
17294 return NULL;
17295 }
17296
17297
17298 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17299 PyObject *resultobj = 0;
17300 wxSound *arg1 = (wxSound *) 0 ;
17301 PyObject *arg2 = (PyObject *) 0 ;
17302 bool result;
17303 void *argp1 = 0 ;
17304 int res1 = 0 ;
17305 PyObject * obj0 = 0 ;
17306 PyObject * obj1 = 0 ;
17307 char * kwnames[] = {
17308 (char *) "self",(char *) "data", NULL
17309 };
17310
17311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17313 if (!SWIG_IsOK(res1)) {
17314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17315 }
17316 arg1 = reinterpret_cast< wxSound * >(argp1);
17317 arg2 = obj1;
17318 {
17319 PyThreadState* __tstate = wxPyBeginAllowThreads();
17320 result = (bool)wxSound_CreateFromData(arg1,arg2);
17321 wxPyEndAllowThreads(__tstate);
17322 if (PyErr_Occurred()) SWIG_fail;
17323 }
17324 {
17325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17326 }
17327 return resultobj;
17328 fail:
17329 return NULL;
17330 }
17331
17332
17333 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17334 PyObject *resultobj = 0;
17335 wxSound *arg1 = (wxSound *) 0 ;
17336 bool result;
17337 void *argp1 = 0 ;
17338 int res1 = 0 ;
17339 PyObject *swig_obj[1] ;
17340
17341 if (!args) SWIG_fail;
17342 swig_obj[0] = args;
17343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17344 if (!SWIG_IsOK(res1)) {
17345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17346 }
17347 arg1 = reinterpret_cast< wxSound * >(argp1);
17348 {
17349 PyThreadState* __tstate = wxPyBeginAllowThreads();
17350 result = (bool)(arg1)->IsOk();
17351 wxPyEndAllowThreads(__tstate);
17352 if (PyErr_Occurred()) SWIG_fail;
17353 }
17354 {
17355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17356 }
17357 return resultobj;
17358 fail:
17359 return NULL;
17360 }
17361
17362
17363 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17364 PyObject *resultobj = 0;
17365 wxSound *arg1 = (wxSound *) 0 ;
17366 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17367 bool result;
17368 void *argp1 = 0 ;
17369 int res1 = 0 ;
17370 unsigned int val2 ;
17371 int ecode2 = 0 ;
17372 PyObject * obj0 = 0 ;
17373 PyObject * obj1 = 0 ;
17374 char * kwnames[] = {
17375 (char *) "self",(char *) "flags", NULL
17376 };
17377
17378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17380 if (!SWIG_IsOK(res1)) {
17381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17382 }
17383 arg1 = reinterpret_cast< wxSound * >(argp1);
17384 if (obj1) {
17385 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17386 if (!SWIG_IsOK(ecode2)) {
17387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17388 }
17389 arg2 = static_cast< unsigned int >(val2);
17390 }
17391 {
17392 if (!wxPyCheckForApp()) SWIG_fail;
17393 PyThreadState* __tstate = wxPyBeginAllowThreads();
17394 result = (bool)((wxSound const *)arg1)->Play(arg2);
17395 wxPyEndAllowThreads(__tstate);
17396 if (PyErr_Occurred()) SWIG_fail;
17397 }
17398 {
17399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17400 }
17401 return resultobj;
17402 fail:
17403 return NULL;
17404 }
17405
17406
17407 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17408 PyObject *resultobj = 0;
17409 wxString *arg1 = 0 ;
17410 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17411 bool result;
17412 bool temp1 = false ;
17413 unsigned int val2 ;
17414 int ecode2 = 0 ;
17415 PyObject * obj0 = 0 ;
17416 PyObject * obj1 = 0 ;
17417 char * kwnames[] = {
17418 (char *) "filename",(char *) "flags", NULL
17419 };
17420
17421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17422 {
17423 arg1 = wxString_in_helper(obj0);
17424 if (arg1 == NULL) SWIG_fail;
17425 temp1 = true;
17426 }
17427 if (obj1) {
17428 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17429 if (!SWIG_IsOK(ecode2)) {
17430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17431 }
17432 arg2 = static_cast< unsigned int >(val2);
17433 }
17434 {
17435 if (!wxPyCheckForApp()) SWIG_fail;
17436 PyThreadState* __tstate = wxPyBeginAllowThreads();
17437 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17438 wxPyEndAllowThreads(__tstate);
17439 if (PyErr_Occurred()) SWIG_fail;
17440 }
17441 {
17442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17443 }
17444 {
17445 if (temp1)
17446 delete arg1;
17447 }
17448 return resultobj;
17449 fail:
17450 {
17451 if (temp1)
17452 delete arg1;
17453 }
17454 return NULL;
17455 }
17456
17457
17458 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17459 PyObject *resultobj = 0;
17460
17461 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17462 {
17463 if (!wxPyCheckForApp()) SWIG_fail;
17464 PyThreadState* __tstate = wxPyBeginAllowThreads();
17465 wxSound::Stop();
17466 wxPyEndAllowThreads(__tstate);
17467 if (PyErr_Occurred()) SWIG_fail;
17468 }
17469 resultobj = SWIG_Py_Void();
17470 return resultobj;
17471 fail:
17472 return NULL;
17473 }
17474
17475
17476 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17477 PyObject *obj;
17478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17479 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17480 return SWIG_Py_Void();
17481 }
17482
17483 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17484 return SWIG_Python_InitShadowInstance(args);
17485 }
17486
17487 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17488 PyObject *resultobj = 0;
17489 wxString *arg1 = 0 ;
17490 wxString *arg2 = 0 ;
17491 wxString *arg3 = 0 ;
17492 wxString *arg4 = 0 ;
17493 wxFileTypeInfo *result = 0 ;
17494 bool temp1 = false ;
17495 bool temp2 = false ;
17496 bool temp3 = false ;
17497 bool temp4 = false ;
17498 PyObject * obj0 = 0 ;
17499 PyObject * obj1 = 0 ;
17500 PyObject * obj2 = 0 ;
17501 PyObject * obj3 = 0 ;
17502 char * kwnames[] = {
17503 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17504 };
17505
17506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17507 {
17508 arg1 = wxString_in_helper(obj0);
17509 if (arg1 == NULL) SWIG_fail;
17510 temp1 = true;
17511 }
17512 {
17513 arg2 = wxString_in_helper(obj1);
17514 if (arg2 == NULL) SWIG_fail;
17515 temp2 = true;
17516 }
17517 {
17518 arg3 = wxString_in_helper(obj2);
17519 if (arg3 == NULL) SWIG_fail;
17520 temp3 = true;
17521 }
17522 {
17523 arg4 = wxString_in_helper(obj3);
17524 if (arg4 == NULL) SWIG_fail;
17525 temp4 = true;
17526 }
17527 {
17528 PyThreadState* __tstate = wxPyBeginAllowThreads();
17529 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17530 wxPyEndAllowThreads(__tstate);
17531 if (PyErr_Occurred()) SWIG_fail;
17532 }
17533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17534 {
17535 if (temp1)
17536 delete arg1;
17537 }
17538 {
17539 if (temp2)
17540 delete arg2;
17541 }
17542 {
17543 if (temp3)
17544 delete arg3;
17545 }
17546 {
17547 if (temp4)
17548 delete arg4;
17549 }
17550 return resultobj;
17551 fail:
17552 {
17553 if (temp1)
17554 delete arg1;
17555 }
17556 {
17557 if (temp2)
17558 delete arg2;
17559 }
17560 {
17561 if (temp3)
17562 delete arg3;
17563 }
17564 {
17565 if (temp4)
17566 delete arg4;
17567 }
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17573 PyObject *resultobj = 0;
17574 wxArrayString *arg1 = 0 ;
17575 wxFileTypeInfo *result = 0 ;
17576 bool temp1 = false ;
17577 PyObject * obj0 = 0 ;
17578 char * kwnames[] = {
17579 (char *) "sArray", NULL
17580 };
17581
17582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17583 {
17584 if (! PySequence_Check(obj0)) {
17585 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17586 SWIG_fail;
17587 }
17588 arg1 = new wxArrayString;
17589 temp1 = true;
17590 int i, len=PySequence_Length(obj0);
17591 for (i=0; i<len; i++) {
17592 PyObject* item = PySequence_GetItem(obj0, i);
17593 wxString* s = wxString_in_helper(item);
17594 if (PyErr_Occurred()) SWIG_fail;
17595 arg1->Add(*s);
17596 delete s;
17597 Py_DECREF(item);
17598 }
17599 }
17600 {
17601 PyThreadState* __tstate = wxPyBeginAllowThreads();
17602 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17603 wxPyEndAllowThreads(__tstate);
17604 if (PyErr_Occurred()) SWIG_fail;
17605 }
17606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17607 {
17608 if (temp1) delete arg1;
17609 }
17610 return resultobj;
17611 fail:
17612 {
17613 if (temp1) delete arg1;
17614 }
17615 return NULL;
17616 }
17617
17618
17619 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17620 PyObject *resultobj = 0;
17621 wxFileTypeInfo *result = 0 ;
17622
17623 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17624 {
17625 PyThreadState* __tstate = wxPyBeginAllowThreads();
17626 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17627 wxPyEndAllowThreads(__tstate);
17628 if (PyErr_Occurred()) SWIG_fail;
17629 }
17630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17631 return resultobj;
17632 fail:
17633 return NULL;
17634 }
17635
17636
17637 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17638 PyObject *resultobj = 0;
17639 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17640 bool result;
17641 void *argp1 = 0 ;
17642 int res1 = 0 ;
17643 PyObject *swig_obj[1] ;
17644
17645 if (!args) SWIG_fail;
17646 swig_obj[0] = args;
17647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17648 if (!SWIG_IsOK(res1)) {
17649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17650 }
17651 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 {
17659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17660 }
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj = 0;
17669 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17670 wxString *arg2 = 0 ;
17671 int arg3 = (int) 0 ;
17672 void *argp1 = 0 ;
17673 int res1 = 0 ;
17674 bool temp2 = false ;
17675 int val3 ;
17676 int ecode3 = 0 ;
17677 PyObject * obj0 = 0 ;
17678 PyObject * obj1 = 0 ;
17679 PyObject * obj2 = 0 ;
17680 char * kwnames[] = {
17681 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17682 };
17683
17684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17686 if (!SWIG_IsOK(res1)) {
17687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17688 }
17689 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17690 {
17691 arg2 = wxString_in_helper(obj1);
17692 if (arg2 == NULL) SWIG_fail;
17693 temp2 = true;
17694 }
17695 if (obj2) {
17696 ecode3 = SWIG_AsVal_int(obj2, &val3);
17697 if (!SWIG_IsOK(ecode3)) {
17698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17699 }
17700 arg3 = static_cast< int >(val3);
17701 }
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 resultobj = SWIG_Py_Void();
17709 {
17710 if (temp2)
17711 delete arg2;
17712 }
17713 return resultobj;
17714 fail:
17715 {
17716 if (temp2)
17717 delete arg2;
17718 }
17719 return NULL;
17720 }
17721
17722
17723 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj = 0;
17725 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17726 wxString *arg2 = 0 ;
17727 void *argp1 = 0 ;
17728 int res1 = 0 ;
17729 bool temp2 = false ;
17730 PyObject * obj0 = 0 ;
17731 PyObject * obj1 = 0 ;
17732 char * kwnames[] = {
17733 (char *) "self",(char *) "shortDesc", NULL
17734 };
17735
17736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17738 if (!SWIG_IsOK(res1)) {
17739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17740 }
17741 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17742 {
17743 arg2 = wxString_in_helper(obj1);
17744 if (arg2 == NULL) SWIG_fail;
17745 temp2 = true;
17746 }
17747 {
17748 PyThreadState* __tstate = wxPyBeginAllowThreads();
17749 (arg1)->SetShortDesc((wxString const &)*arg2);
17750 wxPyEndAllowThreads(__tstate);
17751 if (PyErr_Occurred()) SWIG_fail;
17752 }
17753 resultobj = SWIG_Py_Void();
17754 {
17755 if (temp2)
17756 delete arg2;
17757 }
17758 return resultobj;
17759 fail:
17760 {
17761 if (temp2)
17762 delete arg2;
17763 }
17764 return NULL;
17765 }
17766
17767
17768 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17769 PyObject *resultobj = 0;
17770 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17771 wxString *result = 0 ;
17772 void *argp1 = 0 ;
17773 int res1 = 0 ;
17774 PyObject *swig_obj[1] ;
17775
17776 if (!args) SWIG_fail;
17777 swig_obj[0] = args;
17778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17779 if (!SWIG_IsOK(res1)) {
17780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17781 }
17782 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17783 {
17784 PyThreadState* __tstate = wxPyBeginAllowThreads();
17785 {
17786 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17787 result = (wxString *) &_result_ref;
17788 }
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 {
17793 #if wxUSE_UNICODE
17794 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17795 #else
17796 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17797 #endif
17798 }
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17806 PyObject *resultobj = 0;
17807 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17808 wxString *result = 0 ;
17809 void *argp1 = 0 ;
17810 int res1 = 0 ;
17811 PyObject *swig_obj[1] ;
17812
17813 if (!args) SWIG_fail;
17814 swig_obj[0] = args;
17815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17816 if (!SWIG_IsOK(res1)) {
17817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17818 }
17819 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17820 {
17821 PyThreadState* __tstate = wxPyBeginAllowThreads();
17822 {
17823 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17824 result = (wxString *) &_result_ref;
17825 }
17826 wxPyEndAllowThreads(__tstate);
17827 if (PyErr_Occurred()) SWIG_fail;
17828 }
17829 {
17830 #if wxUSE_UNICODE
17831 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17832 #else
17833 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17834 #endif
17835 }
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17843 PyObject *resultobj = 0;
17844 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17845 wxString *result = 0 ;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17855 }
17856 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 {
17860 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17861 result = (wxString *) &_result_ref;
17862 }
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 {
17867 #if wxUSE_UNICODE
17868 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17869 #else
17870 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17871 #endif
17872 }
17873 return resultobj;
17874 fail:
17875 return NULL;
17876 }
17877
17878
17879 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17880 PyObject *resultobj = 0;
17881 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17882 wxString *result = 0 ;
17883 void *argp1 = 0 ;
17884 int res1 = 0 ;
17885 PyObject *swig_obj[1] ;
17886
17887 if (!args) SWIG_fail;
17888 swig_obj[0] = args;
17889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17890 if (!SWIG_IsOK(res1)) {
17891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17892 }
17893 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17894 {
17895 PyThreadState* __tstate = wxPyBeginAllowThreads();
17896 {
17897 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17898 result = (wxString *) &_result_ref;
17899 }
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 {
17904 #if wxUSE_UNICODE
17905 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17906 #else
17907 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17908 #endif
17909 }
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17917 PyObject *resultobj = 0;
17918 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17919 wxString *result = 0 ;
17920 void *argp1 = 0 ;
17921 int res1 = 0 ;
17922 PyObject *swig_obj[1] ;
17923
17924 if (!args) SWIG_fail;
17925 swig_obj[0] = args;
17926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17927 if (!SWIG_IsOK(res1)) {
17928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17929 }
17930 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 {
17934 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17935 result = (wxString *) &_result_ref;
17936 }
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 {
17941 #if wxUSE_UNICODE
17942 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17943 #else
17944 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17945 #endif
17946 }
17947 return resultobj;
17948 fail:
17949 return NULL;
17950 }
17951
17952
17953 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17954 PyObject *resultobj = 0;
17955 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17956 wxArrayString *result = 0 ;
17957 void *argp1 = 0 ;
17958 int res1 = 0 ;
17959 PyObject *swig_obj[1] ;
17960
17961 if (!args) SWIG_fail;
17962 swig_obj[0] = args;
17963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17964 if (!SWIG_IsOK(res1)) {
17965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17966 }
17967 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17968 {
17969 PyThreadState* __tstate = wxPyBeginAllowThreads();
17970 {
17971 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17972 result = (wxArrayString *) &_result_ref;
17973 }
17974 wxPyEndAllowThreads(__tstate);
17975 if (PyErr_Occurred()) SWIG_fail;
17976 }
17977 {
17978 resultobj = wxArrayString2PyList_helper(*result);
17979 }
17980 return resultobj;
17981 fail:
17982 return NULL;
17983 }
17984
17985
17986 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17987 PyObject *resultobj = 0;
17988 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17989 size_t result;
17990 void *argp1 = 0 ;
17991 int res1 = 0 ;
17992 PyObject *swig_obj[1] ;
17993
17994 if (!args) SWIG_fail;
17995 swig_obj[0] = args;
17996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17997 if (!SWIG_IsOK(res1)) {
17998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17999 }
18000 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18001 {
18002 PyThreadState* __tstate = wxPyBeginAllowThreads();
18003 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
18004 wxPyEndAllowThreads(__tstate);
18005 if (PyErr_Occurred()) SWIG_fail;
18006 }
18007 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18015 PyObject *resultobj = 0;
18016 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18017 wxString *result = 0 ;
18018 void *argp1 = 0 ;
18019 int res1 = 0 ;
18020 PyObject *swig_obj[1] ;
18021
18022 if (!args) SWIG_fail;
18023 swig_obj[0] = args;
18024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18025 if (!SWIG_IsOK(res1)) {
18026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18027 }
18028 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18029 {
18030 PyThreadState* __tstate = wxPyBeginAllowThreads();
18031 {
18032 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18033 result = (wxString *) &_result_ref;
18034 }
18035 wxPyEndAllowThreads(__tstate);
18036 if (PyErr_Occurred()) SWIG_fail;
18037 }
18038 {
18039 #if wxUSE_UNICODE
18040 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18041 #else
18042 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18043 #endif
18044 }
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18052 PyObject *resultobj = 0;
18053 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18054 int result;
18055 void *argp1 = 0 ;
18056 int res1 = 0 ;
18057 PyObject *swig_obj[1] ;
18058
18059 if (!args) SWIG_fail;
18060 swig_obj[0] = args;
18061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18062 if (!SWIG_IsOK(res1)) {
18063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18064 }
18065 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 resultobj = SWIG_From_int(static_cast< int >(result));
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18080 PyObject *obj;
18081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18082 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18083 return SWIG_Py_Void();
18084 }
18085
18086 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 return SWIG_Python_InitShadowInstance(args);
18088 }
18089
18090 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj = 0;
18092 wxFileTypeInfo *arg1 = 0 ;
18093 wxFileType *result = 0 ;
18094 void *argp1 = 0 ;
18095 int res1 = 0 ;
18096 PyObject * obj0 = 0 ;
18097 char * kwnames[] = {
18098 (char *) "ftInfo", NULL
18099 };
18100
18101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18102 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18103 if (!SWIG_IsOK(res1)) {
18104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18105 }
18106 if (!argp1) {
18107 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18108 }
18109 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18110 {
18111 PyThreadState* __tstate = wxPyBeginAllowThreads();
18112 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18117 return resultobj;
18118 fail:
18119 return NULL;
18120 }
18121
18122
18123 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18124 PyObject *resultobj = 0;
18125 wxFileType *arg1 = (wxFileType *) 0 ;
18126 void *argp1 = 0 ;
18127 int res1 = 0 ;
18128 PyObject *swig_obj[1] ;
18129
18130 if (!args) SWIG_fail;
18131 swig_obj[0] = args;
18132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18133 if (!SWIG_IsOK(res1)) {
18134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18135 }
18136 arg1 = reinterpret_cast< wxFileType * >(argp1);
18137 {
18138 PyThreadState* __tstate = wxPyBeginAllowThreads();
18139 delete arg1;
18140
18141 wxPyEndAllowThreads(__tstate);
18142 if (PyErr_Occurred()) SWIG_fail;
18143 }
18144 resultobj = SWIG_Py_Void();
18145 return resultobj;
18146 fail:
18147 return NULL;
18148 }
18149
18150
18151 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18152 PyObject *resultobj = 0;
18153 wxFileType *arg1 = (wxFileType *) 0 ;
18154 PyObject *result = 0 ;
18155 void *argp1 = 0 ;
18156 int res1 = 0 ;
18157 PyObject *swig_obj[1] ;
18158
18159 if (!args) SWIG_fail;
18160 swig_obj[0] = args;
18161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18162 if (!SWIG_IsOK(res1)) {
18163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18164 }
18165 arg1 = reinterpret_cast< wxFileType * >(argp1);
18166 {
18167 PyThreadState* __tstate = wxPyBeginAllowThreads();
18168 result = (PyObject *)wxFileType_GetMimeType(arg1);
18169 wxPyEndAllowThreads(__tstate);
18170 if (PyErr_Occurred()) SWIG_fail;
18171 }
18172 resultobj = result;
18173 return resultobj;
18174 fail:
18175 return NULL;
18176 }
18177
18178
18179 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18180 PyObject *resultobj = 0;
18181 wxFileType *arg1 = (wxFileType *) 0 ;
18182 PyObject *result = 0 ;
18183 void *argp1 = 0 ;
18184 int res1 = 0 ;
18185 PyObject *swig_obj[1] ;
18186
18187 if (!args) SWIG_fail;
18188 swig_obj[0] = args;
18189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18190 if (!SWIG_IsOK(res1)) {
18191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18192 }
18193 arg1 = reinterpret_cast< wxFileType * >(argp1);
18194 {
18195 PyThreadState* __tstate = wxPyBeginAllowThreads();
18196 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18197 wxPyEndAllowThreads(__tstate);
18198 if (PyErr_Occurred()) SWIG_fail;
18199 }
18200 resultobj = result;
18201 return resultobj;
18202 fail:
18203 return NULL;
18204 }
18205
18206
18207 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18208 PyObject *resultobj = 0;
18209 wxFileType *arg1 = (wxFileType *) 0 ;
18210 PyObject *result = 0 ;
18211 void *argp1 = 0 ;
18212 int res1 = 0 ;
18213 PyObject *swig_obj[1] ;
18214
18215 if (!args) SWIG_fail;
18216 swig_obj[0] = args;
18217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18218 if (!SWIG_IsOK(res1)) {
18219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18220 }
18221 arg1 = reinterpret_cast< wxFileType * >(argp1);
18222 {
18223 PyThreadState* __tstate = wxPyBeginAllowThreads();
18224 result = (PyObject *)wxFileType_GetExtensions(arg1);
18225 wxPyEndAllowThreads(__tstate);
18226 if (PyErr_Occurred()) SWIG_fail;
18227 }
18228 resultobj = result;
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18236 PyObject *resultobj = 0;
18237 wxFileType *arg1 = (wxFileType *) 0 ;
18238 wxIcon *result = 0 ;
18239 void *argp1 = 0 ;
18240 int res1 = 0 ;
18241 PyObject *swig_obj[1] ;
18242
18243 if (!args) SWIG_fail;
18244 swig_obj[0] = args;
18245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18246 if (!SWIG_IsOK(res1)) {
18247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18248 }
18249 arg1 = reinterpret_cast< wxFileType * >(argp1);
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 result = (wxIcon *)wxFileType_GetIcon(arg1);
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18264 PyObject *resultobj = 0;
18265 wxFileType *arg1 = (wxFileType *) 0 ;
18266 PyObject *result = 0 ;
18267 void *argp1 = 0 ;
18268 int res1 = 0 ;
18269 PyObject *swig_obj[1] ;
18270
18271 if (!args) SWIG_fail;
18272 swig_obj[0] = args;
18273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18274 if (!SWIG_IsOK(res1)) {
18275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18276 }
18277 arg1 = reinterpret_cast< wxFileType * >(argp1);
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 resultobj = result;
18285 return resultobj;
18286 fail:
18287 return NULL;
18288 }
18289
18290
18291 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18292 PyObject *resultobj = 0;
18293 wxFileType *arg1 = (wxFileType *) 0 ;
18294 PyObject *result = 0 ;
18295 void *argp1 = 0 ;
18296 int res1 = 0 ;
18297 PyObject *swig_obj[1] ;
18298
18299 if (!args) SWIG_fail;
18300 swig_obj[0] = args;
18301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18302 if (!SWIG_IsOK(res1)) {
18303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18304 }
18305 arg1 = reinterpret_cast< wxFileType * >(argp1);
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 result = (PyObject *)wxFileType_GetDescription(arg1);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = result;
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18320 PyObject *resultobj = 0;
18321 wxFileType *arg1 = (wxFileType *) 0 ;
18322 wxString *arg2 = 0 ;
18323 wxString const &arg3_defvalue = wxPyEmptyString ;
18324 wxString *arg3 = (wxString *) &arg3_defvalue ;
18325 PyObject *result = 0 ;
18326 void *argp1 = 0 ;
18327 int res1 = 0 ;
18328 bool temp2 = false ;
18329 bool temp3 = false ;
18330 PyObject * obj0 = 0 ;
18331 PyObject * obj1 = 0 ;
18332 PyObject * obj2 = 0 ;
18333 char * kwnames[] = {
18334 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18335 };
18336
18337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18339 if (!SWIG_IsOK(res1)) {
18340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18341 }
18342 arg1 = reinterpret_cast< wxFileType * >(argp1);
18343 {
18344 arg2 = wxString_in_helper(obj1);
18345 if (arg2 == NULL) SWIG_fail;
18346 temp2 = true;
18347 }
18348 if (obj2) {
18349 {
18350 arg3 = wxString_in_helper(obj2);
18351 if (arg3 == NULL) SWIG_fail;
18352 temp3 = true;
18353 }
18354 }
18355 {
18356 PyThreadState* __tstate = wxPyBeginAllowThreads();
18357 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18358 wxPyEndAllowThreads(__tstate);
18359 if (PyErr_Occurred()) SWIG_fail;
18360 }
18361 resultobj = result;
18362 {
18363 if (temp2)
18364 delete arg2;
18365 }
18366 {
18367 if (temp3)
18368 delete arg3;
18369 }
18370 return resultobj;
18371 fail:
18372 {
18373 if (temp2)
18374 delete arg2;
18375 }
18376 {
18377 if (temp3)
18378 delete arg3;
18379 }
18380 return NULL;
18381 }
18382
18383
18384 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj = 0;
18386 wxFileType *arg1 = (wxFileType *) 0 ;
18387 wxString *arg2 = 0 ;
18388 wxString const &arg3_defvalue = wxPyEmptyString ;
18389 wxString *arg3 = (wxString *) &arg3_defvalue ;
18390 PyObject *result = 0 ;
18391 void *argp1 = 0 ;
18392 int res1 = 0 ;
18393 bool temp2 = false ;
18394 bool temp3 = false ;
18395 PyObject * obj0 = 0 ;
18396 PyObject * obj1 = 0 ;
18397 PyObject * obj2 = 0 ;
18398 char * kwnames[] = {
18399 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18400 };
18401
18402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18404 if (!SWIG_IsOK(res1)) {
18405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18406 }
18407 arg1 = reinterpret_cast< wxFileType * >(argp1);
18408 {
18409 arg2 = wxString_in_helper(obj1);
18410 if (arg2 == NULL) SWIG_fail;
18411 temp2 = true;
18412 }
18413 if (obj2) {
18414 {
18415 arg3 = wxString_in_helper(obj2);
18416 if (arg3 == NULL) SWIG_fail;
18417 temp3 = true;
18418 }
18419 }
18420 {
18421 PyThreadState* __tstate = wxPyBeginAllowThreads();
18422 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18423 wxPyEndAllowThreads(__tstate);
18424 if (PyErr_Occurred()) SWIG_fail;
18425 }
18426 resultobj = result;
18427 {
18428 if (temp2)
18429 delete arg2;
18430 }
18431 {
18432 if (temp3)
18433 delete arg3;
18434 }
18435 return resultobj;
18436 fail:
18437 {
18438 if (temp2)
18439 delete arg2;
18440 }
18441 {
18442 if (temp3)
18443 delete arg3;
18444 }
18445 return NULL;
18446 }
18447
18448
18449 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18450 PyObject *resultobj = 0;
18451 wxFileType *arg1 = (wxFileType *) 0 ;
18452 wxString *arg2 = 0 ;
18453 wxString const &arg3_defvalue = wxPyEmptyString ;
18454 wxString *arg3 = (wxString *) &arg3_defvalue ;
18455 PyObject *result = 0 ;
18456 void *argp1 = 0 ;
18457 int res1 = 0 ;
18458 bool temp2 = false ;
18459 bool temp3 = false ;
18460 PyObject * obj0 = 0 ;
18461 PyObject * obj1 = 0 ;
18462 PyObject * obj2 = 0 ;
18463 char * kwnames[] = {
18464 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18465 };
18466
18467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18469 if (!SWIG_IsOK(res1)) {
18470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18471 }
18472 arg1 = reinterpret_cast< wxFileType * >(argp1);
18473 {
18474 arg2 = wxString_in_helper(obj1);
18475 if (arg2 == NULL) SWIG_fail;
18476 temp2 = true;
18477 }
18478 if (obj2) {
18479 {
18480 arg3 = wxString_in_helper(obj2);
18481 if (arg3 == NULL) SWIG_fail;
18482 temp3 = true;
18483 }
18484 }
18485 {
18486 PyThreadState* __tstate = wxPyBeginAllowThreads();
18487 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18488 wxPyEndAllowThreads(__tstate);
18489 if (PyErr_Occurred()) SWIG_fail;
18490 }
18491 resultobj = result;
18492 {
18493 if (temp2)
18494 delete arg2;
18495 }
18496 {
18497 if (temp3)
18498 delete arg3;
18499 }
18500 return resultobj;
18501 fail:
18502 {
18503 if (temp2)
18504 delete arg2;
18505 }
18506 {
18507 if (temp3)
18508 delete arg3;
18509 }
18510 return NULL;
18511 }
18512
18513
18514 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18515 PyObject *resultobj = 0;
18516 wxFileType *arg1 = (wxFileType *) 0 ;
18517 wxString *arg2 = 0 ;
18518 wxString *arg3 = 0 ;
18519 bool arg4 = (bool) true ;
18520 bool result;
18521 void *argp1 = 0 ;
18522 int res1 = 0 ;
18523 bool temp2 = false ;
18524 bool temp3 = false ;
18525 bool val4 ;
18526 int ecode4 = 0 ;
18527 PyObject * obj0 = 0 ;
18528 PyObject * obj1 = 0 ;
18529 PyObject * obj2 = 0 ;
18530 PyObject * obj3 = 0 ;
18531 char * kwnames[] = {
18532 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18533 };
18534
18535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18537 if (!SWIG_IsOK(res1)) {
18538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18539 }
18540 arg1 = reinterpret_cast< wxFileType * >(argp1);
18541 {
18542 arg2 = wxString_in_helper(obj1);
18543 if (arg2 == NULL) SWIG_fail;
18544 temp2 = true;
18545 }
18546 {
18547 arg3 = wxString_in_helper(obj2);
18548 if (arg3 == NULL) SWIG_fail;
18549 temp3 = true;
18550 }
18551 if (obj3) {
18552 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18553 if (!SWIG_IsOK(ecode4)) {
18554 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18555 }
18556 arg4 = static_cast< bool >(val4);
18557 }
18558 {
18559 PyThreadState* __tstate = wxPyBeginAllowThreads();
18560 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18561 wxPyEndAllowThreads(__tstate);
18562 if (PyErr_Occurred()) SWIG_fail;
18563 }
18564 {
18565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18566 }
18567 {
18568 if (temp2)
18569 delete arg2;
18570 }
18571 {
18572 if (temp3)
18573 delete arg3;
18574 }
18575 return resultobj;
18576 fail:
18577 {
18578 if (temp2)
18579 delete arg2;
18580 }
18581 {
18582 if (temp3)
18583 delete arg3;
18584 }
18585 return NULL;
18586 }
18587
18588
18589 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18590 PyObject *resultobj = 0;
18591 wxFileType *arg1 = (wxFileType *) 0 ;
18592 wxString const &arg2_defvalue = wxPyEmptyString ;
18593 wxString *arg2 = (wxString *) &arg2_defvalue ;
18594 int arg3 = (int) 0 ;
18595 bool result;
18596 void *argp1 = 0 ;
18597 int res1 = 0 ;
18598 bool temp2 = false ;
18599 int val3 ;
18600 int ecode3 = 0 ;
18601 PyObject * obj0 = 0 ;
18602 PyObject * obj1 = 0 ;
18603 PyObject * obj2 = 0 ;
18604 char * kwnames[] = {
18605 (char *) "self",(char *) "cmd",(char *) "index", NULL
18606 };
18607
18608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18610 if (!SWIG_IsOK(res1)) {
18611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18612 }
18613 arg1 = reinterpret_cast< wxFileType * >(argp1);
18614 if (obj1) {
18615 {
18616 arg2 = wxString_in_helper(obj1);
18617 if (arg2 == NULL) SWIG_fail;
18618 temp2 = true;
18619 }
18620 }
18621 if (obj2) {
18622 ecode3 = SWIG_AsVal_int(obj2, &val3);
18623 if (!SWIG_IsOK(ecode3)) {
18624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18625 }
18626 arg3 = static_cast< int >(val3);
18627 }
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18631 wxPyEndAllowThreads(__tstate);
18632 if (PyErr_Occurred()) SWIG_fail;
18633 }
18634 {
18635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18636 }
18637 {
18638 if (temp2)
18639 delete arg2;
18640 }
18641 return resultobj;
18642 fail:
18643 {
18644 if (temp2)
18645 delete arg2;
18646 }
18647 return NULL;
18648 }
18649
18650
18651 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18652 PyObject *resultobj = 0;
18653 wxFileType *arg1 = (wxFileType *) 0 ;
18654 bool result;
18655 void *argp1 = 0 ;
18656 int res1 = 0 ;
18657 PyObject *swig_obj[1] ;
18658
18659 if (!args) SWIG_fail;
18660 swig_obj[0] = args;
18661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18662 if (!SWIG_IsOK(res1)) {
18663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18664 }
18665 arg1 = reinterpret_cast< wxFileType * >(argp1);
18666 {
18667 PyThreadState* __tstate = wxPyBeginAllowThreads();
18668 result = (bool)(arg1)->Unassociate();
18669 wxPyEndAllowThreads(__tstate);
18670 if (PyErr_Occurred()) SWIG_fail;
18671 }
18672 {
18673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18674 }
18675 return resultobj;
18676 fail:
18677 return NULL;
18678 }
18679
18680
18681 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj = 0;
18683 wxString *arg1 = 0 ;
18684 wxString *arg2 = 0 ;
18685 wxString const &arg3_defvalue = wxPyEmptyString ;
18686 wxString *arg3 = (wxString *) &arg3_defvalue ;
18687 wxString result;
18688 bool temp1 = false ;
18689 bool temp2 = false ;
18690 bool temp3 = false ;
18691 PyObject * obj0 = 0 ;
18692 PyObject * obj1 = 0 ;
18693 PyObject * obj2 = 0 ;
18694 char * kwnames[] = {
18695 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18696 };
18697
18698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18699 {
18700 arg1 = wxString_in_helper(obj0);
18701 if (arg1 == NULL) SWIG_fail;
18702 temp1 = true;
18703 }
18704 {
18705 arg2 = wxString_in_helper(obj1);
18706 if (arg2 == NULL) SWIG_fail;
18707 temp2 = true;
18708 }
18709 if (obj2) {
18710 {
18711 arg3 = wxString_in_helper(obj2);
18712 if (arg3 == NULL) SWIG_fail;
18713 temp3 = true;
18714 }
18715 }
18716 {
18717 PyThreadState* __tstate = wxPyBeginAllowThreads();
18718 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18719 wxPyEndAllowThreads(__tstate);
18720 if (PyErr_Occurred()) SWIG_fail;
18721 }
18722 {
18723 #if wxUSE_UNICODE
18724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18725 #else
18726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18727 #endif
18728 }
18729 {
18730 if (temp1)
18731 delete arg1;
18732 }
18733 {
18734 if (temp2)
18735 delete arg2;
18736 }
18737 {
18738 if (temp3)
18739 delete arg3;
18740 }
18741 return resultobj;
18742 fail:
18743 {
18744 if (temp1)
18745 delete arg1;
18746 }
18747 {
18748 if (temp2)
18749 delete arg2;
18750 }
18751 {
18752 if (temp3)
18753 delete arg3;
18754 }
18755 return NULL;
18756 }
18757
18758
18759 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18760 PyObject *obj;
18761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18762 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18763 return SWIG_Py_Void();
18764 }
18765
18766 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18767 return SWIG_Python_InitShadowInstance(args);
18768 }
18769
18770 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18771 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18772 return 1;
18773 }
18774
18775
18776 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18777 PyObject *pyobj = 0;
18778
18779 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18780 return pyobj;
18781 }
18782
18783
18784 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18785 PyObject *resultobj = 0;
18786 wxString *arg1 = 0 ;
18787 wxString *arg2 = 0 ;
18788 bool result;
18789 bool temp1 = false ;
18790 bool temp2 = false ;
18791 PyObject * obj0 = 0 ;
18792 PyObject * obj1 = 0 ;
18793 char * kwnames[] = {
18794 (char *) "mimeType",(char *) "wildcard", NULL
18795 };
18796
18797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18798 {
18799 arg1 = wxString_in_helper(obj0);
18800 if (arg1 == NULL) SWIG_fail;
18801 temp1 = true;
18802 }
18803 {
18804 arg2 = wxString_in_helper(obj1);
18805 if (arg2 == NULL) SWIG_fail;
18806 temp2 = true;
18807 }
18808 {
18809 PyThreadState* __tstate = wxPyBeginAllowThreads();
18810 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18811 wxPyEndAllowThreads(__tstate);
18812 if (PyErr_Occurred()) SWIG_fail;
18813 }
18814 {
18815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18816 }
18817 {
18818 if (temp1)
18819 delete arg1;
18820 }
18821 {
18822 if (temp2)
18823 delete arg2;
18824 }
18825 return resultobj;
18826 fail:
18827 {
18828 if (temp1)
18829 delete arg1;
18830 }
18831 {
18832 if (temp2)
18833 delete arg2;
18834 }
18835 return NULL;
18836 }
18837
18838
18839 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18840 PyObject *resultobj = 0;
18841 wxMimeTypesManager *result = 0 ;
18842
18843 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18844 {
18845 PyThreadState* __tstate = wxPyBeginAllowThreads();
18846 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18847 wxPyEndAllowThreads(__tstate);
18848 if (PyErr_Occurred()) SWIG_fail;
18849 }
18850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18851 return resultobj;
18852 fail:
18853 return NULL;
18854 }
18855
18856
18857 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18858 PyObject *resultobj = 0;
18859 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18860 int arg2 = (int) wxMAILCAP_ALL ;
18861 wxString const &arg3_defvalue = wxPyEmptyString ;
18862 wxString *arg3 = (wxString *) &arg3_defvalue ;
18863 void *argp1 = 0 ;
18864 int res1 = 0 ;
18865 int val2 ;
18866 int ecode2 = 0 ;
18867 bool temp3 = false ;
18868 PyObject * obj0 = 0 ;
18869 PyObject * obj1 = 0 ;
18870 PyObject * obj2 = 0 ;
18871 char * kwnames[] = {
18872 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18873 };
18874
18875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18877 if (!SWIG_IsOK(res1)) {
18878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18879 }
18880 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18881 if (obj1) {
18882 ecode2 = SWIG_AsVal_int(obj1, &val2);
18883 if (!SWIG_IsOK(ecode2)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18885 }
18886 arg2 = static_cast< int >(val2);
18887 }
18888 if (obj2) {
18889 {
18890 arg3 = wxString_in_helper(obj2);
18891 if (arg3 == NULL) SWIG_fail;
18892 temp3 = true;
18893 }
18894 }
18895 {
18896 PyThreadState* __tstate = wxPyBeginAllowThreads();
18897 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18898 wxPyEndAllowThreads(__tstate);
18899 if (PyErr_Occurred()) SWIG_fail;
18900 }
18901 resultobj = SWIG_Py_Void();
18902 {
18903 if (temp3)
18904 delete arg3;
18905 }
18906 return resultobj;
18907 fail:
18908 {
18909 if (temp3)
18910 delete arg3;
18911 }
18912 return NULL;
18913 }
18914
18915
18916 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18917 PyObject *resultobj = 0;
18918 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18919 void *argp1 = 0 ;
18920 int res1 = 0 ;
18921 PyObject *swig_obj[1] ;
18922
18923 if (!args) SWIG_fail;
18924 swig_obj[0] = args;
18925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18926 if (!SWIG_IsOK(res1)) {
18927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18928 }
18929 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18930 {
18931 PyThreadState* __tstate = wxPyBeginAllowThreads();
18932 (arg1)->ClearData();
18933 wxPyEndAllowThreads(__tstate);
18934 if (PyErr_Occurred()) SWIG_fail;
18935 }
18936 resultobj = SWIG_Py_Void();
18937 return resultobj;
18938 fail:
18939 return NULL;
18940 }
18941
18942
18943 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18944 PyObject *resultobj = 0;
18945 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18946 wxString *arg2 = 0 ;
18947 wxFileType *result = 0 ;
18948 void *argp1 = 0 ;
18949 int res1 = 0 ;
18950 bool temp2 = false ;
18951 PyObject * obj0 = 0 ;
18952 PyObject * obj1 = 0 ;
18953 char * kwnames[] = {
18954 (char *) "self",(char *) "ext", NULL
18955 };
18956
18957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18959 if (!SWIG_IsOK(res1)) {
18960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18961 }
18962 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18963 {
18964 arg2 = wxString_in_helper(obj1);
18965 if (arg2 == NULL) SWIG_fail;
18966 temp2 = true;
18967 }
18968 {
18969 PyThreadState* __tstate = wxPyBeginAllowThreads();
18970 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18971 wxPyEndAllowThreads(__tstate);
18972 if (PyErr_Occurred()) SWIG_fail;
18973 }
18974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18975 {
18976 if (temp2)
18977 delete arg2;
18978 }
18979 return resultobj;
18980 fail:
18981 {
18982 if (temp2)
18983 delete arg2;
18984 }
18985 return NULL;
18986 }
18987
18988
18989 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18990 PyObject *resultobj = 0;
18991 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18992 wxString *arg2 = 0 ;
18993 wxFileType *result = 0 ;
18994 void *argp1 = 0 ;
18995 int res1 = 0 ;
18996 bool temp2 = false ;
18997 PyObject * obj0 = 0 ;
18998 PyObject * obj1 = 0 ;
18999 char * kwnames[] = {
19000 (char *) "self",(char *) "mimeType", NULL
19001 };
19002
19003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
19004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19005 if (!SWIG_IsOK(res1)) {
19006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19007 }
19008 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19009 {
19010 arg2 = wxString_in_helper(obj1);
19011 if (arg2 == NULL) SWIG_fail;
19012 temp2 = true;
19013 }
19014 {
19015 PyThreadState* __tstate = wxPyBeginAllowThreads();
19016 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19021 {
19022 if (temp2)
19023 delete arg2;
19024 }
19025 return resultobj;
19026 fail:
19027 {
19028 if (temp2)
19029 delete arg2;
19030 }
19031 return NULL;
19032 }
19033
19034
19035 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19036 PyObject *resultobj = 0;
19037 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19038 wxString *arg2 = 0 ;
19039 bool arg3 = (bool) false ;
19040 bool result;
19041 void *argp1 = 0 ;
19042 int res1 = 0 ;
19043 bool temp2 = false ;
19044 bool val3 ;
19045 int ecode3 = 0 ;
19046 PyObject * obj0 = 0 ;
19047 PyObject * obj1 = 0 ;
19048 PyObject * obj2 = 0 ;
19049 char * kwnames[] = {
19050 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19051 };
19052
19053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19055 if (!SWIG_IsOK(res1)) {
19056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19057 }
19058 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19059 {
19060 arg2 = wxString_in_helper(obj1);
19061 if (arg2 == NULL) SWIG_fail;
19062 temp2 = true;
19063 }
19064 if (obj2) {
19065 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19066 if (!SWIG_IsOK(ecode3)) {
19067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19068 }
19069 arg3 = static_cast< bool >(val3);
19070 }
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19074 wxPyEndAllowThreads(__tstate);
19075 if (PyErr_Occurred()) SWIG_fail;
19076 }
19077 {
19078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19079 }
19080 {
19081 if (temp2)
19082 delete arg2;
19083 }
19084 return resultobj;
19085 fail:
19086 {
19087 if (temp2)
19088 delete arg2;
19089 }
19090 return NULL;
19091 }
19092
19093
19094 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19095 PyObject *resultobj = 0;
19096 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19097 wxString *arg2 = 0 ;
19098 bool result;
19099 void *argp1 = 0 ;
19100 int res1 = 0 ;
19101 bool temp2 = false ;
19102 PyObject * obj0 = 0 ;
19103 PyObject * obj1 = 0 ;
19104 char * kwnames[] = {
19105 (char *) "self",(char *) "filename", NULL
19106 };
19107
19108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19112 }
19113 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19114 {
19115 arg2 = wxString_in_helper(obj1);
19116 if (arg2 == NULL) SWIG_fail;
19117 temp2 = true;
19118 }
19119 {
19120 PyThreadState* __tstate = wxPyBeginAllowThreads();
19121 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19122 wxPyEndAllowThreads(__tstate);
19123 if (PyErr_Occurred()) SWIG_fail;
19124 }
19125 {
19126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19127 }
19128 {
19129 if (temp2)
19130 delete arg2;
19131 }
19132 return resultobj;
19133 fail:
19134 {
19135 if (temp2)
19136 delete arg2;
19137 }
19138 return NULL;
19139 }
19140
19141
19142 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19143 PyObject *resultobj = 0;
19144 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19145 PyObject *result = 0 ;
19146 void *argp1 = 0 ;
19147 int res1 = 0 ;
19148 PyObject *swig_obj[1] ;
19149
19150 if (!args) SWIG_fail;
19151 swig_obj[0] = args;
19152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19153 if (!SWIG_IsOK(res1)) {
19154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19155 }
19156 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19157 {
19158 PyThreadState* __tstate = wxPyBeginAllowThreads();
19159 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19160 wxPyEndAllowThreads(__tstate);
19161 if (PyErr_Occurred()) SWIG_fail;
19162 }
19163 resultobj = result;
19164 return resultobj;
19165 fail:
19166 return NULL;
19167 }
19168
19169
19170 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19171 PyObject *resultobj = 0;
19172 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19173 wxFileTypeInfo *arg2 = 0 ;
19174 void *argp1 = 0 ;
19175 int res1 = 0 ;
19176 void *argp2 = 0 ;
19177 int res2 = 0 ;
19178 PyObject * obj0 = 0 ;
19179 PyObject * obj1 = 0 ;
19180 char * kwnames[] = {
19181 (char *) "self",(char *) "ft", NULL
19182 };
19183
19184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19186 if (!SWIG_IsOK(res1)) {
19187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19188 }
19189 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19190 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19191 if (!SWIG_IsOK(res2)) {
19192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19193 }
19194 if (!argp2) {
19195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19196 }
19197 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19198 {
19199 PyThreadState* __tstate = wxPyBeginAllowThreads();
19200 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19201 wxPyEndAllowThreads(__tstate);
19202 if (PyErr_Occurred()) SWIG_fail;
19203 }
19204 resultobj = SWIG_Py_Void();
19205 return resultobj;
19206 fail:
19207 return NULL;
19208 }
19209
19210
19211 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj = 0;
19213 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19214 wxFileTypeInfo *arg2 = 0 ;
19215 wxFileType *result = 0 ;
19216 void *argp1 = 0 ;
19217 int res1 = 0 ;
19218 void *argp2 = 0 ;
19219 int res2 = 0 ;
19220 PyObject * obj0 = 0 ;
19221 PyObject * obj1 = 0 ;
19222 char * kwnames[] = {
19223 (char *) "self",(char *) "ftInfo", NULL
19224 };
19225
19226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19228 if (!SWIG_IsOK(res1)) {
19229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19230 }
19231 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19232 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19233 if (!SWIG_IsOK(res2)) {
19234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19235 }
19236 if (!argp2) {
19237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19238 }
19239 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19240 {
19241 PyThreadState* __tstate = wxPyBeginAllowThreads();
19242 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19243 wxPyEndAllowThreads(__tstate);
19244 if (PyErr_Occurred()) SWIG_fail;
19245 }
19246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19247 return resultobj;
19248 fail:
19249 return NULL;
19250 }
19251
19252
19253 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19254 PyObject *resultobj = 0;
19255 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19256 wxFileType *arg2 = (wxFileType *) 0 ;
19257 bool result;
19258 void *argp1 = 0 ;
19259 int res1 = 0 ;
19260 void *argp2 = 0 ;
19261 int res2 = 0 ;
19262 PyObject * obj0 = 0 ;
19263 PyObject * obj1 = 0 ;
19264 char * kwnames[] = {
19265 (char *) "self",(char *) "ft", NULL
19266 };
19267
19268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19270 if (!SWIG_IsOK(res1)) {
19271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19272 }
19273 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19275 if (!SWIG_IsOK(res2)) {
19276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19277 }
19278 arg2 = reinterpret_cast< wxFileType * >(argp2);
19279 {
19280 PyThreadState* __tstate = wxPyBeginAllowThreads();
19281 result = (bool)(arg1)->Unassociate(arg2);
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19287 }
19288 return resultobj;
19289 fail:
19290 return NULL;
19291 }
19292
19293
19294 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19295 PyObject *resultobj = 0;
19296 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19297 void *argp1 = 0 ;
19298 int res1 = 0 ;
19299 PyObject *swig_obj[1] ;
19300
19301 if (!args) SWIG_fail;
19302 swig_obj[0] = args;
19303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19304 if (!SWIG_IsOK(res1)) {
19305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19306 }
19307 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19308 {
19309 PyThreadState* __tstate = wxPyBeginAllowThreads();
19310 delete arg1;
19311
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 resultobj = SWIG_Py_Void();
19316 return resultobj;
19317 fail:
19318 return NULL;
19319 }
19320
19321
19322 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19323 PyObject *obj;
19324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19325 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19326 return SWIG_Py_Void();
19327 }
19328
19329 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19330 return SWIG_Python_InitShadowInstance(args);
19331 }
19332
19333 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19334 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19335 return 1;
19336 }
19337
19338
19339 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19340 PyObject *pyobj = 0;
19341
19342 {
19343 #if wxUSE_UNICODE
19344 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19345 #else
19346 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19347 #endif
19348 }
19349 return pyobj;
19350 }
19351
19352
19353 SWIGINTERN int ART_MENU_set(PyObject *) {
19354 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19355 return 1;
19356 }
19357
19358
19359 SWIGINTERN PyObject *ART_MENU_get(void) {
19360 PyObject *pyobj = 0;
19361
19362 {
19363 #if wxUSE_UNICODE
19364 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19365 #else
19366 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19367 #endif
19368 }
19369 return pyobj;
19370 }
19371
19372
19373 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19374 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19375 return 1;
19376 }
19377
19378
19379 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19380 PyObject *pyobj = 0;
19381
19382 {
19383 #if wxUSE_UNICODE
19384 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19385 #else
19386 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19387 #endif
19388 }
19389 return pyobj;
19390 }
19391
19392
19393 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19394 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19395 return 1;
19396 }
19397
19398
19399 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19400 PyObject *pyobj = 0;
19401
19402 {
19403 #if wxUSE_UNICODE
19404 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19405 #else
19406 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19407 #endif
19408 }
19409 return pyobj;
19410 }
19411
19412
19413 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19414 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19415 return 1;
19416 }
19417
19418
19419 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19420 PyObject *pyobj = 0;
19421
19422 {
19423 #if wxUSE_UNICODE
19424 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19425 #else
19426 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19427 #endif
19428 }
19429 return pyobj;
19430 }
19431
19432
19433 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19434 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19435 return 1;
19436 }
19437
19438
19439 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19440 PyObject *pyobj = 0;
19441
19442 {
19443 #if wxUSE_UNICODE
19444 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19445 #else
19446 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19447 #endif
19448 }
19449 return pyobj;
19450 }
19451
19452
19453 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19454 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19455 return 1;
19456 }
19457
19458
19459 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19460 PyObject *pyobj = 0;
19461
19462 {
19463 #if wxUSE_UNICODE
19464 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19465 #else
19466 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19467 #endif
19468 }
19469 return pyobj;
19470 }
19471
19472
19473 SWIGINTERN int ART_OTHER_set(PyObject *) {
19474 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19475 return 1;
19476 }
19477
19478
19479 SWIGINTERN PyObject *ART_OTHER_get(void) {
19480 PyObject *pyobj = 0;
19481
19482 {
19483 #if wxUSE_UNICODE
19484 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19485 #else
19486 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19487 #endif
19488 }
19489 return pyobj;
19490 }
19491
19492
19493 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19494 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19495 return 1;
19496 }
19497
19498
19499 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19500 PyObject *pyobj = 0;
19501
19502 {
19503 #if wxUSE_UNICODE
19504 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19505 #else
19506 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19507 #endif
19508 }
19509 return pyobj;
19510 }
19511
19512
19513 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19514 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19515 return 1;
19516 }
19517
19518
19519 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19520 PyObject *pyobj = 0;
19521
19522 {
19523 #if wxUSE_UNICODE
19524 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19525 #else
19526 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19527 #endif
19528 }
19529 return pyobj;
19530 }
19531
19532
19533 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19534 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19535 return 1;
19536 }
19537
19538
19539 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19540 PyObject *pyobj = 0;
19541
19542 {
19543 #if wxUSE_UNICODE
19544 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19545 #else
19546 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19547 #endif
19548 }
19549 return pyobj;
19550 }
19551
19552
19553 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19554 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19555 return 1;
19556 }
19557
19558
19559 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19560 PyObject *pyobj = 0;
19561
19562 {
19563 #if wxUSE_UNICODE
19564 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19565 #else
19566 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19567 #endif
19568 }
19569 return pyobj;
19570 }
19571
19572
19573 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19574 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19575 return 1;
19576 }
19577
19578
19579 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19580 PyObject *pyobj = 0;
19581
19582 {
19583 #if wxUSE_UNICODE
19584 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19585 #else
19586 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19587 #endif
19588 }
19589 return pyobj;
19590 }
19591
19592
19593 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19594 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19595 return 1;
19596 }
19597
19598
19599 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19600 PyObject *pyobj = 0;
19601
19602 {
19603 #if wxUSE_UNICODE
19604 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19605 #else
19606 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19607 #endif
19608 }
19609 return pyobj;
19610 }
19611
19612
19613 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19614 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19615 return 1;
19616 }
19617
19618
19619 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19620 PyObject *pyobj = 0;
19621
19622 {
19623 #if wxUSE_UNICODE
19624 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19625 #else
19626 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19627 #endif
19628 }
19629 return pyobj;
19630 }
19631
19632
19633 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19634 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19635 return 1;
19636 }
19637
19638
19639 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19640 PyObject *pyobj = 0;
19641
19642 {
19643 #if wxUSE_UNICODE
19644 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19645 #else
19646 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19647 #endif
19648 }
19649 return pyobj;
19650 }
19651
19652
19653 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19654 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19655 return 1;
19656 }
19657
19658
19659 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19660 PyObject *pyobj = 0;
19661
19662 {
19663 #if wxUSE_UNICODE
19664 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19665 #else
19666 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19667 #endif
19668 }
19669 return pyobj;
19670 }
19671
19672
19673 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19674 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19675 return 1;
19676 }
19677
19678
19679 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19680 PyObject *pyobj = 0;
19681
19682 {
19683 #if wxUSE_UNICODE
19684 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19685 #else
19686 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19687 #endif
19688 }
19689 return pyobj;
19690 }
19691
19692
19693 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19694 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19695 return 1;
19696 }
19697
19698
19699 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19700 PyObject *pyobj = 0;
19701
19702 {
19703 #if wxUSE_UNICODE
19704 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19705 #else
19706 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19707 #endif
19708 }
19709 return pyobj;
19710 }
19711
19712
19713 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19714 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19715 return 1;
19716 }
19717
19718
19719 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19720 PyObject *pyobj = 0;
19721
19722 {
19723 #if wxUSE_UNICODE
19724 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19725 #else
19726 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19727 #endif
19728 }
19729 return pyobj;
19730 }
19731
19732
19733 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19734 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19735 return 1;
19736 }
19737
19738
19739 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19740 PyObject *pyobj = 0;
19741
19742 {
19743 #if wxUSE_UNICODE
19744 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19745 #else
19746 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19747 #endif
19748 }
19749 return pyobj;
19750 }
19751
19752
19753 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19754 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19755 return 1;
19756 }
19757
19758
19759 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19760 PyObject *pyobj = 0;
19761
19762 {
19763 #if wxUSE_UNICODE
19764 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19765 #else
19766 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19767 #endif
19768 }
19769 return pyobj;
19770 }
19771
19772
19773 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19774 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19775 return 1;
19776 }
19777
19778
19779 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19780 PyObject *pyobj = 0;
19781
19782 {
19783 #if wxUSE_UNICODE
19784 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19785 #else
19786 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19787 #endif
19788 }
19789 return pyobj;
19790 }
19791
19792
19793 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19794 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19795 return 1;
19796 }
19797
19798
19799 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19800 PyObject *pyobj = 0;
19801
19802 {
19803 #if wxUSE_UNICODE
19804 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19805 #else
19806 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19807 #endif
19808 }
19809 return pyobj;
19810 }
19811
19812
19813 SWIGINTERN int ART_PRINT_set(PyObject *) {
19814 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19815 return 1;
19816 }
19817
19818
19819 SWIGINTERN PyObject *ART_PRINT_get(void) {
19820 PyObject *pyobj = 0;
19821
19822 {
19823 #if wxUSE_UNICODE
19824 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19825 #else
19826 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19827 #endif
19828 }
19829 return pyobj;
19830 }
19831
19832
19833 SWIGINTERN int ART_HELP_set(PyObject *) {
19834 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19835 return 1;
19836 }
19837
19838
19839 SWIGINTERN PyObject *ART_HELP_get(void) {
19840 PyObject *pyobj = 0;
19841
19842 {
19843 #if wxUSE_UNICODE
19844 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19845 #else
19846 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19847 #endif
19848 }
19849 return pyobj;
19850 }
19851
19852
19853 SWIGINTERN int ART_TIP_set(PyObject *) {
19854 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19855 return 1;
19856 }
19857
19858
19859 SWIGINTERN PyObject *ART_TIP_get(void) {
19860 PyObject *pyobj = 0;
19861
19862 {
19863 #if wxUSE_UNICODE
19864 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19865 #else
19866 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19867 #endif
19868 }
19869 return pyobj;
19870 }
19871
19872
19873 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19874 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19875 return 1;
19876 }
19877
19878
19879 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19880 PyObject *pyobj = 0;
19881
19882 {
19883 #if wxUSE_UNICODE
19884 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19885 #else
19886 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19887 #endif
19888 }
19889 return pyobj;
19890 }
19891
19892
19893 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19894 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19895 return 1;
19896 }
19897
19898
19899 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19900 PyObject *pyobj = 0;
19901
19902 {
19903 #if wxUSE_UNICODE
19904 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19905 #else
19906 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19907 #endif
19908 }
19909 return pyobj;
19910 }
19911
19912
19913 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19914 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19915 return 1;
19916 }
19917
19918
19919 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19920 PyObject *pyobj = 0;
19921
19922 {
19923 #if wxUSE_UNICODE
19924 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19925 #else
19926 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19927 #endif
19928 }
19929 return pyobj;
19930 }
19931
19932
19933 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19934 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19935 return 1;
19936 }
19937
19938
19939 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19940 PyObject *pyobj = 0;
19941
19942 {
19943 #if wxUSE_UNICODE
19944 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19945 #else
19946 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19947 #endif
19948 }
19949 return pyobj;
19950 }
19951
19952
19953 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19954 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19955 return 1;
19956 }
19957
19958
19959 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19960 PyObject *pyobj = 0;
19961
19962 {
19963 #if wxUSE_UNICODE
19964 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19965 #else
19966 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19967 #endif
19968 }
19969 return pyobj;
19970 }
19971
19972
19973 SWIGINTERN int ART_CDROM_set(PyObject *) {
19974 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19975 return 1;
19976 }
19977
19978
19979 SWIGINTERN PyObject *ART_CDROM_get(void) {
19980 PyObject *pyobj = 0;
19981
19982 {
19983 #if wxUSE_UNICODE
19984 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19985 #else
19986 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19987 #endif
19988 }
19989 return pyobj;
19990 }
19991
19992
19993 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19994 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19995 return 1;
19996 }
19997
19998
19999 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20000 PyObject *pyobj = 0;
20001
20002 {
20003 #if wxUSE_UNICODE
20004 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20005 #else
20006 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20007 #endif
20008 }
20009 return pyobj;
20010 }
20011
20012
20013 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20014 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20015 return 1;
20016 }
20017
20018
20019 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20020 PyObject *pyobj = 0;
20021
20022 {
20023 #if wxUSE_UNICODE
20024 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20025 #else
20026 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20027 #endif
20028 }
20029 return pyobj;
20030 }
20031
20032
20033 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20034 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20035 return 1;
20036 }
20037
20038
20039 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20040 PyObject *pyobj = 0;
20041
20042 {
20043 #if wxUSE_UNICODE
20044 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20045 #else
20046 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20047 #endif
20048 }
20049 return pyobj;
20050 }
20051
20052
20053 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20054 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20055 return 1;
20056 }
20057
20058
20059 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20060 PyObject *pyobj = 0;
20061
20062 {
20063 #if wxUSE_UNICODE
20064 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20065 #else
20066 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20067 #endif
20068 }
20069 return pyobj;
20070 }
20071
20072
20073 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20074 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20075 return 1;
20076 }
20077
20078
20079 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20080 PyObject *pyobj = 0;
20081
20082 {
20083 #if wxUSE_UNICODE
20084 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20085 #else
20086 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20087 #endif
20088 }
20089 return pyobj;
20090 }
20091
20092
20093 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20094 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20095 return 1;
20096 }
20097
20098
20099 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20100 PyObject *pyobj = 0;
20101
20102 {
20103 #if wxUSE_UNICODE
20104 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20105 #else
20106 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20107 #endif
20108 }
20109 return pyobj;
20110 }
20111
20112
20113 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20114 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20115 return 1;
20116 }
20117
20118
20119 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20120 PyObject *pyobj = 0;
20121
20122 {
20123 #if wxUSE_UNICODE
20124 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20125 #else
20126 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20127 #endif
20128 }
20129 return pyobj;
20130 }
20131
20132
20133 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20134 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20135 return 1;
20136 }
20137
20138
20139 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20140 PyObject *pyobj = 0;
20141
20142 {
20143 #if wxUSE_UNICODE
20144 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20145 #else
20146 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20147 #endif
20148 }
20149 return pyobj;
20150 }
20151
20152
20153 SWIGINTERN int ART_ERROR_set(PyObject *) {
20154 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20155 return 1;
20156 }
20157
20158
20159 SWIGINTERN PyObject *ART_ERROR_get(void) {
20160 PyObject *pyobj = 0;
20161
20162 {
20163 #if wxUSE_UNICODE
20164 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20165 #else
20166 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20167 #endif
20168 }
20169 return pyobj;
20170 }
20171
20172
20173 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20174 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20175 return 1;
20176 }
20177
20178
20179 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20180 PyObject *pyobj = 0;
20181
20182 {
20183 #if wxUSE_UNICODE
20184 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20185 #else
20186 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20187 #endif
20188 }
20189 return pyobj;
20190 }
20191
20192
20193 SWIGINTERN int ART_WARNING_set(PyObject *) {
20194 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20195 return 1;
20196 }
20197
20198
20199 SWIGINTERN PyObject *ART_WARNING_get(void) {
20200 PyObject *pyobj = 0;
20201
20202 {
20203 #if wxUSE_UNICODE
20204 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20205 #else
20206 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20207 #endif
20208 }
20209 return pyobj;
20210 }
20211
20212
20213 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20214 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20215 return 1;
20216 }
20217
20218
20219 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20220 PyObject *pyobj = 0;
20221
20222 {
20223 #if wxUSE_UNICODE
20224 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20225 #else
20226 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20227 #endif
20228 }
20229 return pyobj;
20230 }
20231
20232
20233 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20234 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20235 return 1;
20236 }
20237
20238
20239 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20240 PyObject *pyobj = 0;
20241
20242 {
20243 #if wxUSE_UNICODE
20244 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20245 #else
20246 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20247 #endif
20248 }
20249 return pyobj;
20250 }
20251
20252
20253 SWIGINTERN int ART_COPY_set(PyObject *) {
20254 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20255 return 1;
20256 }
20257
20258
20259 SWIGINTERN PyObject *ART_COPY_get(void) {
20260 PyObject *pyobj = 0;
20261
20262 {
20263 #if wxUSE_UNICODE
20264 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20265 #else
20266 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20267 #endif
20268 }
20269 return pyobj;
20270 }
20271
20272
20273 SWIGINTERN int ART_CUT_set(PyObject *) {
20274 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20275 return 1;
20276 }
20277
20278
20279 SWIGINTERN PyObject *ART_CUT_get(void) {
20280 PyObject *pyobj = 0;
20281
20282 {
20283 #if wxUSE_UNICODE
20284 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20285 #else
20286 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20287 #endif
20288 }
20289 return pyobj;
20290 }
20291
20292
20293 SWIGINTERN int ART_PASTE_set(PyObject *) {
20294 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20295 return 1;
20296 }
20297
20298
20299 SWIGINTERN PyObject *ART_PASTE_get(void) {
20300 PyObject *pyobj = 0;
20301
20302 {
20303 #if wxUSE_UNICODE
20304 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20305 #else
20306 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20307 #endif
20308 }
20309 return pyobj;
20310 }
20311
20312
20313 SWIGINTERN int ART_DELETE_set(PyObject *) {
20314 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20315 return 1;
20316 }
20317
20318
20319 SWIGINTERN PyObject *ART_DELETE_get(void) {
20320 PyObject *pyobj = 0;
20321
20322 {
20323 #if wxUSE_UNICODE
20324 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20325 #else
20326 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20327 #endif
20328 }
20329 return pyobj;
20330 }
20331
20332
20333 SWIGINTERN int ART_NEW_set(PyObject *) {
20334 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20335 return 1;
20336 }
20337
20338
20339 SWIGINTERN PyObject *ART_NEW_get(void) {
20340 PyObject *pyobj = 0;
20341
20342 {
20343 #if wxUSE_UNICODE
20344 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20345 #else
20346 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20347 #endif
20348 }
20349 return pyobj;
20350 }
20351
20352
20353 SWIGINTERN int ART_UNDO_set(PyObject *) {
20354 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20355 return 1;
20356 }
20357
20358
20359 SWIGINTERN PyObject *ART_UNDO_get(void) {
20360 PyObject *pyobj = 0;
20361
20362 {
20363 #if wxUSE_UNICODE
20364 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20365 #else
20366 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20367 #endif
20368 }
20369 return pyobj;
20370 }
20371
20372
20373 SWIGINTERN int ART_REDO_set(PyObject *) {
20374 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20375 return 1;
20376 }
20377
20378
20379 SWIGINTERN PyObject *ART_REDO_get(void) {
20380 PyObject *pyobj = 0;
20381
20382 {
20383 #if wxUSE_UNICODE
20384 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20385 #else
20386 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20387 #endif
20388 }
20389 return pyobj;
20390 }
20391
20392
20393 SWIGINTERN int ART_QUIT_set(PyObject *) {
20394 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20395 return 1;
20396 }
20397
20398
20399 SWIGINTERN PyObject *ART_QUIT_get(void) {
20400 PyObject *pyobj = 0;
20401
20402 {
20403 #if wxUSE_UNICODE
20404 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20405 #else
20406 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20407 #endif
20408 }
20409 return pyobj;
20410 }
20411
20412
20413 SWIGINTERN int ART_FIND_set(PyObject *) {
20414 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20415 return 1;
20416 }
20417
20418
20419 SWIGINTERN PyObject *ART_FIND_get(void) {
20420 PyObject *pyobj = 0;
20421
20422 {
20423 #if wxUSE_UNICODE
20424 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20425 #else
20426 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20427 #endif
20428 }
20429 return pyobj;
20430 }
20431
20432
20433 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20434 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20435 return 1;
20436 }
20437
20438
20439 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20440 PyObject *pyobj = 0;
20441
20442 {
20443 #if wxUSE_UNICODE
20444 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20445 #else
20446 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20447 #endif
20448 }
20449 return pyobj;
20450 }
20451
20452
20453 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20454 PyObject *resultobj = 0;
20455 wxPyArtProvider *result = 0 ;
20456
20457 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20458 {
20459 if (!wxPyCheckForApp()) SWIG_fail;
20460 PyThreadState* __tstate = wxPyBeginAllowThreads();
20461 result = (wxPyArtProvider *)new wxPyArtProvider();
20462 wxPyEndAllowThreads(__tstate);
20463 if (PyErr_Occurred()) SWIG_fail;
20464 }
20465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20466 return resultobj;
20467 fail:
20468 return NULL;
20469 }
20470
20471
20472 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20473 PyObject *resultobj = 0;
20474 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20475 void *argp1 = 0 ;
20476 int res1 = 0 ;
20477 PyObject *swig_obj[1] ;
20478
20479 if (!args) SWIG_fail;
20480 swig_obj[0] = args;
20481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20482 if (!SWIG_IsOK(res1)) {
20483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20484 }
20485 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 delete arg1;
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 resultobj = SWIG_Py_Void();
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20501 PyObject *resultobj = 0;
20502 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20503 PyObject *arg2 = (PyObject *) 0 ;
20504 PyObject *arg3 = (PyObject *) 0 ;
20505 void *argp1 = 0 ;
20506 int res1 = 0 ;
20507 PyObject * obj0 = 0 ;
20508 PyObject * obj1 = 0 ;
20509 PyObject * obj2 = 0 ;
20510 char * kwnames[] = {
20511 (char *) "self",(char *) "self",(char *) "_class", NULL
20512 };
20513
20514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20516 if (!SWIG_IsOK(res1)) {
20517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20518 }
20519 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20520 arg2 = obj1;
20521 arg3 = obj2;
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 (arg1)->_setCallbackInfo(arg2,arg3);
20525 wxPyEndAllowThreads(__tstate);
20526 if (PyErr_Occurred()) SWIG_fail;
20527 }
20528 resultobj = SWIG_Py_Void();
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20536 PyObject *resultobj = 0;
20537 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20538 int res1 = 0 ;
20539 PyObject * obj0 = 0 ;
20540 char * kwnames[] = {
20541 (char *) "provider", NULL
20542 };
20543
20544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20545 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20546 if (!SWIG_IsOK(res1)) {
20547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20548 }
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 wxPyArtProvider::Push(arg1);
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 resultobj = SWIG_Py_Void();
20556 return resultobj;
20557 fail:
20558 return NULL;
20559 }
20560
20561
20562 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20563 PyObject *resultobj = 0;
20564 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20565 int res1 = 0 ;
20566 PyObject * obj0 = 0 ;
20567 char * kwnames[] = {
20568 (char *) "provider", NULL
20569 };
20570
20571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20572 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20573 if (!SWIG_IsOK(res1)) {
20574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20575 }
20576 {
20577 PyThreadState* __tstate = wxPyBeginAllowThreads();
20578 wxPyArtProvider::Insert(arg1);
20579 wxPyEndAllowThreads(__tstate);
20580 if (PyErr_Occurred()) SWIG_fail;
20581 }
20582 resultobj = SWIG_Py_Void();
20583 return resultobj;
20584 fail:
20585 return NULL;
20586 }
20587
20588
20589 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20590 PyObject *resultobj = 0;
20591 bool result;
20592
20593 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20594 {
20595 PyThreadState* __tstate = wxPyBeginAllowThreads();
20596 result = (bool)wxPyArtProvider::Pop();
20597 wxPyEndAllowThreads(__tstate);
20598 if (PyErr_Occurred()) SWIG_fail;
20599 }
20600 {
20601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20602 }
20603 return resultobj;
20604 fail:
20605 return NULL;
20606 }
20607
20608
20609 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20610 PyObject *resultobj = 0;
20611 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20612 bool result;
20613 void *argp1 = 0 ;
20614 int res1 = 0 ;
20615 PyObject * obj0 = 0 ;
20616 char * kwnames[] = {
20617 (char *) "provider", NULL
20618 };
20619
20620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20622 if (!SWIG_IsOK(res1)) {
20623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20624 }
20625 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20626 {
20627 PyThreadState* __tstate = wxPyBeginAllowThreads();
20628 result = (bool)wxPyArtProvider::Delete(arg1);
20629 wxPyEndAllowThreads(__tstate);
20630 if (PyErr_Occurred()) SWIG_fail;
20631 }
20632 {
20633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20634 }
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20642 PyObject *resultobj = 0;
20643 wxString *arg1 = 0 ;
20644 wxString const &arg2_defvalue = wxPyART_OTHER ;
20645 wxString *arg2 = (wxString *) &arg2_defvalue ;
20646 wxSize const &arg3_defvalue = wxDefaultSize ;
20647 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20648 wxBitmap result;
20649 bool temp1 = false ;
20650 bool temp2 = false ;
20651 wxSize temp3 ;
20652 PyObject * obj0 = 0 ;
20653 PyObject * obj1 = 0 ;
20654 PyObject * obj2 = 0 ;
20655 char * kwnames[] = {
20656 (char *) "id",(char *) "client",(char *) "size", NULL
20657 };
20658
20659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20660 {
20661 arg1 = wxString_in_helper(obj0);
20662 if (arg1 == NULL) SWIG_fail;
20663 temp1 = true;
20664 }
20665 if (obj1) {
20666 {
20667 arg2 = wxString_in_helper(obj1);
20668 if (arg2 == NULL) SWIG_fail;
20669 temp2 = true;
20670 }
20671 }
20672 if (obj2) {
20673 {
20674 arg3 = &temp3;
20675 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20676 }
20677 }
20678 {
20679 if (!wxPyCheckForApp()) SWIG_fail;
20680 PyThreadState* __tstate = wxPyBeginAllowThreads();
20681 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20682 wxPyEndAllowThreads(__tstate);
20683 if (PyErr_Occurred()) SWIG_fail;
20684 }
20685 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20686 {
20687 if (temp1)
20688 delete arg1;
20689 }
20690 {
20691 if (temp2)
20692 delete arg2;
20693 }
20694 return resultobj;
20695 fail:
20696 {
20697 if (temp1)
20698 delete arg1;
20699 }
20700 {
20701 if (temp2)
20702 delete arg2;
20703 }
20704 return NULL;
20705 }
20706
20707
20708 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20709 PyObject *resultobj = 0;
20710 wxString *arg1 = 0 ;
20711 wxString const &arg2_defvalue = wxPyART_OTHER ;
20712 wxString *arg2 = (wxString *) &arg2_defvalue ;
20713 wxSize const &arg3_defvalue = wxDefaultSize ;
20714 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20715 wxIcon result;
20716 bool temp1 = false ;
20717 bool temp2 = false ;
20718 wxSize temp3 ;
20719 PyObject * obj0 = 0 ;
20720 PyObject * obj1 = 0 ;
20721 PyObject * obj2 = 0 ;
20722 char * kwnames[] = {
20723 (char *) "id",(char *) "client",(char *) "size", NULL
20724 };
20725
20726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20727 {
20728 arg1 = wxString_in_helper(obj0);
20729 if (arg1 == NULL) SWIG_fail;
20730 temp1 = true;
20731 }
20732 if (obj1) {
20733 {
20734 arg2 = wxString_in_helper(obj1);
20735 if (arg2 == NULL) SWIG_fail;
20736 temp2 = true;
20737 }
20738 }
20739 if (obj2) {
20740 {
20741 arg3 = &temp3;
20742 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20743 }
20744 }
20745 {
20746 if (!wxPyCheckForApp()) SWIG_fail;
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20753 {
20754 if (temp1)
20755 delete arg1;
20756 }
20757 {
20758 if (temp2)
20759 delete arg2;
20760 }
20761 return resultobj;
20762 fail:
20763 {
20764 if (temp1)
20765 delete arg1;
20766 }
20767 {
20768 if (temp2)
20769 delete arg2;
20770 }
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20776 PyObject *resultobj = 0;
20777 wxString *arg1 = 0 ;
20778 bool arg2 = (bool) false ;
20779 wxSize result;
20780 bool temp1 = false ;
20781 bool val2 ;
20782 int ecode2 = 0 ;
20783 PyObject * obj0 = 0 ;
20784 PyObject * obj1 = 0 ;
20785 char * kwnames[] = {
20786 (char *) "client",(char *) "platform_dependent", NULL
20787 };
20788
20789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20790 {
20791 arg1 = wxString_in_helper(obj0);
20792 if (arg1 == NULL) SWIG_fail;
20793 temp1 = true;
20794 }
20795 if (obj1) {
20796 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20797 if (!SWIG_IsOK(ecode2)) {
20798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20799 }
20800 arg2 = static_cast< bool >(val2);
20801 }
20802 {
20803 PyThreadState* __tstate = wxPyBeginAllowThreads();
20804 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20805 wxPyEndAllowThreads(__tstate);
20806 if (PyErr_Occurred()) SWIG_fail;
20807 }
20808 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20809 {
20810 if (temp1)
20811 delete arg1;
20812 }
20813 return resultobj;
20814 fail:
20815 {
20816 if (temp1)
20817 delete arg1;
20818 }
20819 return NULL;
20820 }
20821
20822
20823 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20824 PyObject *resultobj = 0;
20825 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20826 void *argp1 = 0 ;
20827 int res1 = 0 ;
20828 PyObject *swig_obj[1] ;
20829
20830 if (!args) SWIG_fail;
20831 swig_obj[0] = args;
20832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20833 if (!SWIG_IsOK(res1)) {
20834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20835 }
20836 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20837 {
20838 PyThreadState* __tstate = wxPyBeginAllowThreads();
20839 wxPyArtProvider_Destroy(arg1);
20840 wxPyEndAllowThreads(__tstate);
20841 if (PyErr_Occurred()) SWIG_fail;
20842 }
20843 resultobj = SWIG_Py_Void();
20844 return resultobj;
20845 fail:
20846 return NULL;
20847 }
20848
20849
20850 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20851 PyObject *obj;
20852 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20853 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20854 return SWIG_Py_Void();
20855 }
20856
20857 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20858 return SWIG_Python_InitShadowInstance(args);
20859 }
20860
20861 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20862 PyObject *resultobj = 0;
20863 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20864 void *argp1 = 0 ;
20865 int res1 = 0 ;
20866 PyObject *swig_obj[1] ;
20867
20868 if (!args) SWIG_fail;
20869 swig_obj[0] = args;
20870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20871 if (!SWIG_IsOK(res1)) {
20872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20873 }
20874 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 delete arg1;
20878
20879 wxPyEndAllowThreads(__tstate);
20880 if (PyErr_Occurred()) SWIG_fail;
20881 }
20882 resultobj = SWIG_Py_Void();
20883 return resultobj;
20884 fail:
20885 return NULL;
20886 }
20887
20888
20889 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20890 PyObject *resultobj = 0;
20891 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20892 wxConfigBase *result = 0 ;
20893 int res1 = 0 ;
20894 PyObject * obj0 = 0 ;
20895 char * kwnames[] = {
20896 (char *) "config", NULL
20897 };
20898
20899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20900 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20901 if (!SWIG_IsOK(res1)) {
20902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20903 }
20904 {
20905 PyThreadState* __tstate = wxPyBeginAllowThreads();
20906 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20907 wxPyEndAllowThreads(__tstate);
20908 if (PyErr_Occurred()) SWIG_fail;
20909 }
20910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20911 return resultobj;
20912 fail:
20913 return NULL;
20914 }
20915
20916
20917 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20918 PyObject *resultobj = 0;
20919 bool arg1 = (bool) true ;
20920 wxConfigBase *result = 0 ;
20921 bool val1 ;
20922 int ecode1 = 0 ;
20923 PyObject * obj0 = 0 ;
20924 char * kwnames[] = {
20925 (char *) "createOnDemand", NULL
20926 };
20927
20928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20929 if (obj0) {
20930 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20931 if (!SWIG_IsOK(ecode1)) {
20932 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20933 }
20934 arg1 = static_cast< bool >(val1);
20935 }
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 PyObject *resultobj = 0;
20951 wxConfigBase *result = 0 ;
20952
20953 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20954 {
20955 PyThreadState* __tstate = wxPyBeginAllowThreads();
20956 result = (wxConfigBase *)wxConfigBase::Create();
20957 wxPyEndAllowThreads(__tstate);
20958 if (PyErr_Occurred()) SWIG_fail;
20959 }
20960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20961 return resultobj;
20962 fail:
20963 return NULL;
20964 }
20965
20966
20967 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20968 PyObject *resultobj = 0;
20969
20970 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 wxConfigBase::DontCreateOnDemand();
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 resultobj = SWIG_Py_Void();
20978 return resultobj;
20979 fail:
20980 return NULL;
20981 }
20982
20983
20984 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20985 PyObject *resultobj = 0;
20986 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20987 wxString *arg2 = 0 ;
20988 void *argp1 = 0 ;
20989 int res1 = 0 ;
20990 bool temp2 = false ;
20991 PyObject * obj0 = 0 ;
20992 PyObject * obj1 = 0 ;
20993 char * kwnames[] = {
20994 (char *) "self",(char *) "path", NULL
20995 };
20996
20997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20999 if (!SWIG_IsOK(res1)) {
21000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21001 }
21002 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21003 {
21004 arg2 = wxString_in_helper(obj1);
21005 if (arg2 == NULL) SWIG_fail;
21006 temp2 = true;
21007 }
21008 {
21009 PyThreadState* __tstate = wxPyBeginAllowThreads();
21010 (arg1)->SetPath((wxString const &)*arg2);
21011 wxPyEndAllowThreads(__tstate);
21012 if (PyErr_Occurred()) SWIG_fail;
21013 }
21014 resultobj = SWIG_Py_Void();
21015 {
21016 if (temp2)
21017 delete arg2;
21018 }
21019 return resultobj;
21020 fail:
21021 {
21022 if (temp2)
21023 delete arg2;
21024 }
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *resultobj = 0;
21031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21032 wxString *result = 0 ;
21033 void *argp1 = 0 ;
21034 int res1 = 0 ;
21035 PyObject *swig_obj[1] ;
21036
21037 if (!args) SWIG_fail;
21038 swig_obj[0] = args;
21039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21040 if (!SWIG_IsOK(res1)) {
21041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21042 }
21043 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21044 {
21045 PyThreadState* __tstate = wxPyBeginAllowThreads();
21046 {
21047 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21048 result = (wxString *) &_result_ref;
21049 }
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 {
21054 #if wxUSE_UNICODE
21055 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21056 #else
21057 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21058 #endif
21059 }
21060 return resultobj;
21061 fail:
21062 return NULL;
21063 }
21064
21065
21066 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21067 PyObject *resultobj = 0;
21068 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21069 PyObject *result = 0 ;
21070 void *argp1 = 0 ;
21071 int res1 = 0 ;
21072 PyObject *swig_obj[1] ;
21073
21074 if (!args) SWIG_fail;
21075 swig_obj[0] = args;
21076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21077 if (!SWIG_IsOK(res1)) {
21078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21079 }
21080 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21081 {
21082 PyThreadState* __tstate = wxPyBeginAllowThreads();
21083 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21084 wxPyEndAllowThreads(__tstate);
21085 if (PyErr_Occurred()) SWIG_fail;
21086 }
21087 resultobj = result;
21088 return resultobj;
21089 fail:
21090 return NULL;
21091 }
21092
21093
21094 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21095 PyObject *resultobj = 0;
21096 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21097 long arg2 ;
21098 PyObject *result = 0 ;
21099 void *argp1 = 0 ;
21100 int res1 = 0 ;
21101 long val2 ;
21102 int ecode2 = 0 ;
21103 PyObject * obj0 = 0 ;
21104 PyObject * obj1 = 0 ;
21105 char * kwnames[] = {
21106 (char *) "self",(char *) "index", NULL
21107 };
21108
21109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21111 if (!SWIG_IsOK(res1)) {
21112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21113 }
21114 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21115 ecode2 = SWIG_AsVal_long(obj1, &val2);
21116 if (!SWIG_IsOK(ecode2)) {
21117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21118 }
21119 arg2 = static_cast< long >(val2);
21120 {
21121 PyThreadState* __tstate = wxPyBeginAllowThreads();
21122 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21123 wxPyEndAllowThreads(__tstate);
21124 if (PyErr_Occurred()) SWIG_fail;
21125 }
21126 resultobj = result;
21127 return resultobj;
21128 fail:
21129 return NULL;
21130 }
21131
21132
21133 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21134 PyObject *resultobj = 0;
21135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21136 PyObject *result = 0 ;
21137 void *argp1 = 0 ;
21138 int res1 = 0 ;
21139 PyObject *swig_obj[1] ;
21140
21141 if (!args) SWIG_fail;
21142 swig_obj[0] = args;
21143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21144 if (!SWIG_IsOK(res1)) {
21145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21146 }
21147 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21148 {
21149 PyThreadState* __tstate = wxPyBeginAllowThreads();
21150 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 resultobj = result;
21155 return resultobj;
21156 fail:
21157 return NULL;
21158 }
21159
21160
21161 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21162 PyObject *resultobj = 0;
21163 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21164 long arg2 ;
21165 PyObject *result = 0 ;
21166 void *argp1 = 0 ;
21167 int res1 = 0 ;
21168 long val2 ;
21169 int ecode2 = 0 ;
21170 PyObject * obj0 = 0 ;
21171 PyObject * obj1 = 0 ;
21172 char * kwnames[] = {
21173 (char *) "self",(char *) "index", NULL
21174 };
21175
21176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21178 if (!SWIG_IsOK(res1)) {
21179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21180 }
21181 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21182 ecode2 = SWIG_AsVal_long(obj1, &val2);
21183 if (!SWIG_IsOK(ecode2)) {
21184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21185 }
21186 arg2 = static_cast< long >(val2);
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 resultobj = result;
21194 return resultobj;
21195 fail:
21196 return NULL;
21197 }
21198
21199
21200 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21201 PyObject *resultobj = 0;
21202 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21203 bool arg2 = (bool) false ;
21204 size_t result;
21205 void *argp1 = 0 ;
21206 int res1 = 0 ;
21207 bool val2 ;
21208 int ecode2 = 0 ;
21209 PyObject * obj0 = 0 ;
21210 PyObject * obj1 = 0 ;
21211 char * kwnames[] = {
21212 (char *) "self",(char *) "recursive", NULL
21213 };
21214
21215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21217 if (!SWIG_IsOK(res1)) {
21218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21219 }
21220 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21221 if (obj1) {
21222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21223 if (!SWIG_IsOK(ecode2)) {
21224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21225 }
21226 arg2 = static_cast< bool >(val2);
21227 }
21228 {
21229 PyThreadState* __tstate = wxPyBeginAllowThreads();
21230 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21231 wxPyEndAllowThreads(__tstate);
21232 if (PyErr_Occurred()) SWIG_fail;
21233 }
21234 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21235 return resultobj;
21236 fail:
21237 return NULL;
21238 }
21239
21240
21241 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21242 PyObject *resultobj = 0;
21243 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21244 bool arg2 = (bool) false ;
21245 size_t result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 bool val2 ;
21249 int ecode2 = 0 ;
21250 PyObject * obj0 = 0 ;
21251 PyObject * obj1 = 0 ;
21252 char * kwnames[] = {
21253 (char *) "self",(char *) "recursive", NULL
21254 };
21255
21256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21258 if (!SWIG_IsOK(res1)) {
21259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21260 }
21261 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21262 if (obj1) {
21263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21264 if (!SWIG_IsOK(ecode2)) {
21265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21266 }
21267 arg2 = static_cast< bool >(val2);
21268 }
21269 {
21270 PyThreadState* __tstate = wxPyBeginAllowThreads();
21271 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21272 wxPyEndAllowThreads(__tstate);
21273 if (PyErr_Occurred()) SWIG_fail;
21274 }
21275 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21276 return resultobj;
21277 fail:
21278 return NULL;
21279 }
21280
21281
21282 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21283 PyObject *resultobj = 0;
21284 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21285 wxString *arg2 = 0 ;
21286 bool result;
21287 void *argp1 = 0 ;
21288 int res1 = 0 ;
21289 bool temp2 = false ;
21290 PyObject * obj0 = 0 ;
21291 PyObject * obj1 = 0 ;
21292 char * kwnames[] = {
21293 (char *) "self",(char *) "name", NULL
21294 };
21295
21296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21298 if (!SWIG_IsOK(res1)) {
21299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21300 }
21301 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21302 {
21303 arg2 = wxString_in_helper(obj1);
21304 if (arg2 == NULL) SWIG_fail;
21305 temp2 = true;
21306 }
21307 {
21308 PyThreadState* __tstate = wxPyBeginAllowThreads();
21309 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21310 wxPyEndAllowThreads(__tstate);
21311 if (PyErr_Occurred()) SWIG_fail;
21312 }
21313 {
21314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21315 }
21316 {
21317 if (temp2)
21318 delete arg2;
21319 }
21320 return resultobj;
21321 fail:
21322 {
21323 if (temp2)
21324 delete arg2;
21325 }
21326 return NULL;
21327 }
21328
21329
21330 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21331 PyObject *resultobj = 0;
21332 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21333 wxString *arg2 = 0 ;
21334 bool result;
21335 void *argp1 = 0 ;
21336 int res1 = 0 ;
21337 bool temp2 = false ;
21338 PyObject * obj0 = 0 ;
21339 PyObject * obj1 = 0 ;
21340 char * kwnames[] = {
21341 (char *) "self",(char *) "name", NULL
21342 };
21343
21344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21346 if (!SWIG_IsOK(res1)) {
21347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21348 }
21349 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21350 {
21351 arg2 = wxString_in_helper(obj1);
21352 if (arg2 == NULL) SWIG_fail;
21353 temp2 = true;
21354 }
21355 {
21356 PyThreadState* __tstate = wxPyBeginAllowThreads();
21357 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21358 wxPyEndAllowThreads(__tstate);
21359 if (PyErr_Occurred()) SWIG_fail;
21360 }
21361 {
21362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21363 }
21364 {
21365 if (temp2)
21366 delete arg2;
21367 }
21368 return resultobj;
21369 fail:
21370 {
21371 if (temp2)
21372 delete arg2;
21373 }
21374 return NULL;
21375 }
21376
21377
21378 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21379 PyObject *resultobj = 0;
21380 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21381 wxString *arg2 = 0 ;
21382 bool result;
21383 void *argp1 = 0 ;
21384 int res1 = 0 ;
21385 bool temp2 = false ;
21386 PyObject * obj0 = 0 ;
21387 PyObject * obj1 = 0 ;
21388 char * kwnames[] = {
21389 (char *) "self",(char *) "name", NULL
21390 };
21391
21392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21394 if (!SWIG_IsOK(res1)) {
21395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21396 }
21397 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21398 {
21399 arg2 = wxString_in_helper(obj1);
21400 if (arg2 == NULL) SWIG_fail;
21401 temp2 = true;
21402 }
21403 {
21404 PyThreadState* __tstate = wxPyBeginAllowThreads();
21405 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21406 wxPyEndAllowThreads(__tstate);
21407 if (PyErr_Occurred()) SWIG_fail;
21408 }
21409 {
21410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21411 }
21412 {
21413 if (temp2)
21414 delete arg2;
21415 }
21416 return resultobj;
21417 fail:
21418 {
21419 if (temp2)
21420 delete arg2;
21421 }
21422 return NULL;
21423 }
21424
21425
21426 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj = 0;
21428 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21429 wxString *arg2 = 0 ;
21430 wxConfigBase::EntryType result;
21431 void *argp1 = 0 ;
21432 int res1 = 0 ;
21433 bool temp2 = false ;
21434 PyObject * obj0 = 0 ;
21435 PyObject * obj1 = 0 ;
21436 char * kwnames[] = {
21437 (char *) "self",(char *) "name", NULL
21438 };
21439
21440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21444 }
21445 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21446 {
21447 arg2 = wxString_in_helper(obj1);
21448 if (arg2 == NULL) SWIG_fail;
21449 temp2 = true;
21450 }
21451 {
21452 PyThreadState* __tstate = wxPyBeginAllowThreads();
21453 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21454 wxPyEndAllowThreads(__tstate);
21455 if (PyErr_Occurred()) SWIG_fail;
21456 }
21457 resultobj = SWIG_From_int(static_cast< int >(result));
21458 {
21459 if (temp2)
21460 delete arg2;
21461 }
21462 return resultobj;
21463 fail:
21464 {
21465 if (temp2)
21466 delete arg2;
21467 }
21468 return NULL;
21469 }
21470
21471
21472 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21473 PyObject *resultobj = 0;
21474 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21475 wxString *arg2 = 0 ;
21476 wxString const &arg3_defvalue = wxPyEmptyString ;
21477 wxString *arg3 = (wxString *) &arg3_defvalue ;
21478 wxString result;
21479 void *argp1 = 0 ;
21480 int res1 = 0 ;
21481 bool temp2 = false ;
21482 bool temp3 = false ;
21483 PyObject * obj0 = 0 ;
21484 PyObject * obj1 = 0 ;
21485 PyObject * obj2 = 0 ;
21486 char * kwnames[] = {
21487 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21488 };
21489
21490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21492 if (!SWIG_IsOK(res1)) {
21493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21494 }
21495 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21496 {
21497 arg2 = wxString_in_helper(obj1);
21498 if (arg2 == NULL) SWIG_fail;
21499 temp2 = true;
21500 }
21501 if (obj2) {
21502 {
21503 arg3 = wxString_in_helper(obj2);
21504 if (arg3 == NULL) SWIG_fail;
21505 temp3 = true;
21506 }
21507 }
21508 {
21509 PyThreadState* __tstate = wxPyBeginAllowThreads();
21510 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21511 wxPyEndAllowThreads(__tstate);
21512 if (PyErr_Occurred()) SWIG_fail;
21513 }
21514 {
21515 #if wxUSE_UNICODE
21516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21517 #else
21518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21519 #endif
21520 }
21521 {
21522 if (temp2)
21523 delete arg2;
21524 }
21525 {
21526 if (temp3)
21527 delete arg3;
21528 }
21529 return resultobj;
21530 fail:
21531 {
21532 if (temp2)
21533 delete arg2;
21534 }
21535 {
21536 if (temp3)
21537 delete arg3;
21538 }
21539 return NULL;
21540 }
21541
21542
21543 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21544 PyObject *resultobj = 0;
21545 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21546 wxString *arg2 = 0 ;
21547 long arg3 = (long) 0 ;
21548 long result;
21549 void *argp1 = 0 ;
21550 int res1 = 0 ;
21551 bool temp2 = false ;
21552 long val3 ;
21553 int ecode3 = 0 ;
21554 PyObject * obj0 = 0 ;
21555 PyObject * obj1 = 0 ;
21556 PyObject * obj2 = 0 ;
21557 char * kwnames[] = {
21558 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21559 };
21560
21561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21563 if (!SWIG_IsOK(res1)) {
21564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21565 }
21566 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21567 {
21568 arg2 = wxString_in_helper(obj1);
21569 if (arg2 == NULL) SWIG_fail;
21570 temp2 = true;
21571 }
21572 if (obj2) {
21573 ecode3 = SWIG_AsVal_long(obj2, &val3);
21574 if (!SWIG_IsOK(ecode3)) {
21575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21576 }
21577 arg3 = static_cast< long >(val3);
21578 }
21579 {
21580 PyThreadState* __tstate = wxPyBeginAllowThreads();
21581 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21582 wxPyEndAllowThreads(__tstate);
21583 if (PyErr_Occurred()) SWIG_fail;
21584 }
21585 resultobj = SWIG_From_long(static_cast< long >(result));
21586 {
21587 if (temp2)
21588 delete arg2;
21589 }
21590 return resultobj;
21591 fail:
21592 {
21593 if (temp2)
21594 delete arg2;
21595 }
21596 return NULL;
21597 }
21598
21599
21600 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21601 PyObject *resultobj = 0;
21602 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21603 wxString *arg2 = 0 ;
21604 double arg3 = (double) 0.0 ;
21605 double result;
21606 void *argp1 = 0 ;
21607 int res1 = 0 ;
21608 bool temp2 = false ;
21609 double val3 ;
21610 int ecode3 = 0 ;
21611 PyObject * obj0 = 0 ;
21612 PyObject * obj1 = 0 ;
21613 PyObject * obj2 = 0 ;
21614 char * kwnames[] = {
21615 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21616 };
21617
21618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21620 if (!SWIG_IsOK(res1)) {
21621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21622 }
21623 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21624 {
21625 arg2 = wxString_in_helper(obj1);
21626 if (arg2 == NULL) SWIG_fail;
21627 temp2 = true;
21628 }
21629 if (obj2) {
21630 ecode3 = SWIG_AsVal_double(obj2, &val3);
21631 if (!SWIG_IsOK(ecode3)) {
21632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21633 }
21634 arg3 = static_cast< double >(val3);
21635 }
21636 {
21637 PyThreadState* __tstate = wxPyBeginAllowThreads();
21638 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21639 wxPyEndAllowThreads(__tstate);
21640 if (PyErr_Occurred()) SWIG_fail;
21641 }
21642 resultobj = SWIG_From_double(static_cast< double >(result));
21643 {
21644 if (temp2)
21645 delete arg2;
21646 }
21647 return resultobj;
21648 fail:
21649 {
21650 if (temp2)
21651 delete arg2;
21652 }
21653 return NULL;
21654 }
21655
21656
21657 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj = 0;
21659 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21660 wxString *arg2 = 0 ;
21661 bool arg3 = (bool) false ;
21662 bool result;
21663 void *argp1 = 0 ;
21664 int res1 = 0 ;
21665 bool temp2 = false ;
21666 bool val3 ;
21667 int ecode3 = 0 ;
21668 PyObject * obj0 = 0 ;
21669 PyObject * obj1 = 0 ;
21670 PyObject * obj2 = 0 ;
21671 char * kwnames[] = {
21672 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21673 };
21674
21675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21679 }
21680 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21681 {
21682 arg2 = wxString_in_helper(obj1);
21683 if (arg2 == NULL) SWIG_fail;
21684 temp2 = true;
21685 }
21686 if (obj2) {
21687 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21688 if (!SWIG_IsOK(ecode3)) {
21689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21690 }
21691 arg3 = static_cast< bool >(val3);
21692 }
21693 {
21694 PyThreadState* __tstate = wxPyBeginAllowThreads();
21695 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 {
21700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21701 }
21702 {
21703 if (temp2)
21704 delete arg2;
21705 }
21706 return resultobj;
21707 fail:
21708 {
21709 if (temp2)
21710 delete arg2;
21711 }
21712 return NULL;
21713 }
21714
21715
21716 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj = 0;
21718 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21719 wxString *arg2 = 0 ;
21720 wxString *arg3 = 0 ;
21721 bool result;
21722 void *argp1 = 0 ;
21723 int res1 = 0 ;
21724 bool temp2 = false ;
21725 bool temp3 = false ;
21726 PyObject * obj0 = 0 ;
21727 PyObject * obj1 = 0 ;
21728 PyObject * obj2 = 0 ;
21729 char * kwnames[] = {
21730 (char *) "self",(char *) "key",(char *) "value", NULL
21731 };
21732
21733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21735 if (!SWIG_IsOK(res1)) {
21736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21737 }
21738 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21739 {
21740 arg2 = wxString_in_helper(obj1);
21741 if (arg2 == NULL) SWIG_fail;
21742 temp2 = true;
21743 }
21744 {
21745 arg3 = wxString_in_helper(obj2);
21746 if (arg3 == NULL) SWIG_fail;
21747 temp3 = true;
21748 }
21749 {
21750 PyThreadState* __tstate = wxPyBeginAllowThreads();
21751 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21752 wxPyEndAllowThreads(__tstate);
21753 if (PyErr_Occurred()) SWIG_fail;
21754 }
21755 {
21756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21757 }
21758 {
21759 if (temp2)
21760 delete arg2;
21761 }
21762 {
21763 if (temp3)
21764 delete arg3;
21765 }
21766 return resultobj;
21767 fail:
21768 {
21769 if (temp2)
21770 delete arg2;
21771 }
21772 {
21773 if (temp3)
21774 delete arg3;
21775 }
21776 return NULL;
21777 }
21778
21779
21780 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21781 PyObject *resultobj = 0;
21782 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21783 wxString *arg2 = 0 ;
21784 long arg3 ;
21785 bool result;
21786 void *argp1 = 0 ;
21787 int res1 = 0 ;
21788 bool temp2 = false ;
21789 long val3 ;
21790 int ecode3 = 0 ;
21791 PyObject * obj0 = 0 ;
21792 PyObject * obj1 = 0 ;
21793 PyObject * obj2 = 0 ;
21794 char * kwnames[] = {
21795 (char *) "self",(char *) "key",(char *) "value", NULL
21796 };
21797
21798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21800 if (!SWIG_IsOK(res1)) {
21801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21802 }
21803 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21804 {
21805 arg2 = wxString_in_helper(obj1);
21806 if (arg2 == NULL) SWIG_fail;
21807 temp2 = true;
21808 }
21809 ecode3 = SWIG_AsVal_long(obj2, &val3);
21810 if (!SWIG_IsOK(ecode3)) {
21811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21812 }
21813 arg3 = static_cast< long >(val3);
21814 {
21815 PyThreadState* __tstate = wxPyBeginAllowThreads();
21816 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21817 wxPyEndAllowThreads(__tstate);
21818 if (PyErr_Occurred()) SWIG_fail;
21819 }
21820 {
21821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21822 }
21823 {
21824 if (temp2)
21825 delete arg2;
21826 }
21827 return resultobj;
21828 fail:
21829 {
21830 if (temp2)
21831 delete arg2;
21832 }
21833 return NULL;
21834 }
21835
21836
21837 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21838 PyObject *resultobj = 0;
21839 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21840 wxString *arg2 = 0 ;
21841 double arg3 ;
21842 bool result;
21843 void *argp1 = 0 ;
21844 int res1 = 0 ;
21845 bool temp2 = false ;
21846 double val3 ;
21847 int ecode3 = 0 ;
21848 PyObject * obj0 = 0 ;
21849 PyObject * obj1 = 0 ;
21850 PyObject * obj2 = 0 ;
21851 char * kwnames[] = {
21852 (char *) "self",(char *) "key",(char *) "value", NULL
21853 };
21854
21855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21857 if (!SWIG_IsOK(res1)) {
21858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21859 }
21860 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21861 {
21862 arg2 = wxString_in_helper(obj1);
21863 if (arg2 == NULL) SWIG_fail;
21864 temp2 = true;
21865 }
21866 ecode3 = SWIG_AsVal_double(obj2, &val3);
21867 if (!SWIG_IsOK(ecode3)) {
21868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21869 }
21870 arg3 = static_cast< double >(val3);
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21874 wxPyEndAllowThreads(__tstate);
21875 if (PyErr_Occurred()) SWIG_fail;
21876 }
21877 {
21878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21879 }
21880 {
21881 if (temp2)
21882 delete arg2;
21883 }
21884 return resultobj;
21885 fail:
21886 {
21887 if (temp2)
21888 delete arg2;
21889 }
21890 return NULL;
21891 }
21892
21893
21894 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21895 PyObject *resultobj = 0;
21896 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21897 wxString *arg2 = 0 ;
21898 bool arg3 ;
21899 bool result;
21900 void *argp1 = 0 ;
21901 int res1 = 0 ;
21902 bool temp2 = false ;
21903 bool val3 ;
21904 int ecode3 = 0 ;
21905 PyObject * obj0 = 0 ;
21906 PyObject * obj1 = 0 ;
21907 PyObject * obj2 = 0 ;
21908 char * kwnames[] = {
21909 (char *) "self",(char *) "key",(char *) "value", NULL
21910 };
21911
21912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21914 if (!SWIG_IsOK(res1)) {
21915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21916 }
21917 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21918 {
21919 arg2 = wxString_in_helper(obj1);
21920 if (arg2 == NULL) SWIG_fail;
21921 temp2 = true;
21922 }
21923 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21924 if (!SWIG_IsOK(ecode3)) {
21925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21926 }
21927 arg3 = static_cast< bool >(val3);
21928 {
21929 PyThreadState* __tstate = wxPyBeginAllowThreads();
21930 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21931 wxPyEndAllowThreads(__tstate);
21932 if (PyErr_Occurred()) SWIG_fail;
21933 }
21934 {
21935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21936 }
21937 {
21938 if (temp2)
21939 delete arg2;
21940 }
21941 return resultobj;
21942 fail:
21943 {
21944 if (temp2)
21945 delete arg2;
21946 }
21947 return NULL;
21948 }
21949
21950
21951 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21952 PyObject *resultobj = 0;
21953 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21954 bool arg2 = (bool) false ;
21955 bool result;
21956 void *argp1 = 0 ;
21957 int res1 = 0 ;
21958 bool val2 ;
21959 int ecode2 = 0 ;
21960 PyObject * obj0 = 0 ;
21961 PyObject * obj1 = 0 ;
21962 char * kwnames[] = {
21963 (char *) "self",(char *) "currentOnly", NULL
21964 };
21965
21966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21968 if (!SWIG_IsOK(res1)) {
21969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21970 }
21971 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21972 if (obj1) {
21973 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21974 if (!SWIG_IsOK(ecode2)) {
21975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21976 }
21977 arg2 = static_cast< bool >(val2);
21978 }
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (bool)(arg1)->Flush(arg2);
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 {
21986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21987 }
21988 return resultobj;
21989 fail:
21990 return NULL;
21991 }
21992
21993
21994 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21995 PyObject *resultobj = 0;
21996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21997 wxString *arg2 = 0 ;
21998 wxString *arg3 = 0 ;
21999 bool result;
22000 void *argp1 = 0 ;
22001 int res1 = 0 ;
22002 bool temp2 = false ;
22003 bool temp3 = false ;
22004 PyObject * obj0 = 0 ;
22005 PyObject * obj1 = 0 ;
22006 PyObject * obj2 = 0 ;
22007 char * kwnames[] = {
22008 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22009 };
22010
22011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22013 if (!SWIG_IsOK(res1)) {
22014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22015 }
22016 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22017 {
22018 arg2 = wxString_in_helper(obj1);
22019 if (arg2 == NULL) SWIG_fail;
22020 temp2 = true;
22021 }
22022 {
22023 arg3 = wxString_in_helper(obj2);
22024 if (arg3 == NULL) SWIG_fail;
22025 temp3 = true;
22026 }
22027 {
22028 PyThreadState* __tstate = wxPyBeginAllowThreads();
22029 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 {
22034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22035 }
22036 {
22037 if (temp2)
22038 delete arg2;
22039 }
22040 {
22041 if (temp3)
22042 delete arg3;
22043 }
22044 return resultobj;
22045 fail:
22046 {
22047 if (temp2)
22048 delete arg2;
22049 }
22050 {
22051 if (temp3)
22052 delete arg3;
22053 }
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22059 PyObject *resultobj = 0;
22060 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22061 wxString *arg2 = 0 ;
22062 wxString *arg3 = 0 ;
22063 bool result;
22064 void *argp1 = 0 ;
22065 int res1 = 0 ;
22066 bool temp2 = false ;
22067 bool temp3 = false ;
22068 PyObject * obj0 = 0 ;
22069 PyObject * obj1 = 0 ;
22070 PyObject * obj2 = 0 ;
22071 char * kwnames[] = {
22072 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22073 };
22074
22075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22079 }
22080 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22081 {
22082 arg2 = wxString_in_helper(obj1);
22083 if (arg2 == NULL) SWIG_fail;
22084 temp2 = true;
22085 }
22086 {
22087 arg3 = wxString_in_helper(obj2);
22088 if (arg3 == NULL) SWIG_fail;
22089 temp3 = true;
22090 }
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22094 wxPyEndAllowThreads(__tstate);
22095 if (PyErr_Occurred()) SWIG_fail;
22096 }
22097 {
22098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22099 }
22100 {
22101 if (temp2)
22102 delete arg2;
22103 }
22104 {
22105 if (temp3)
22106 delete arg3;
22107 }
22108 return resultobj;
22109 fail:
22110 {
22111 if (temp2)
22112 delete arg2;
22113 }
22114 {
22115 if (temp3)
22116 delete arg3;
22117 }
22118 return NULL;
22119 }
22120
22121
22122 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj = 0;
22124 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22125 wxString *arg2 = 0 ;
22126 bool arg3 = (bool) true ;
22127 bool result;
22128 void *argp1 = 0 ;
22129 int res1 = 0 ;
22130 bool temp2 = false ;
22131 bool val3 ;
22132 int ecode3 = 0 ;
22133 PyObject * obj0 = 0 ;
22134 PyObject * obj1 = 0 ;
22135 PyObject * obj2 = 0 ;
22136 char * kwnames[] = {
22137 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22138 };
22139
22140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22142 if (!SWIG_IsOK(res1)) {
22143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22144 }
22145 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22146 {
22147 arg2 = wxString_in_helper(obj1);
22148 if (arg2 == NULL) SWIG_fail;
22149 temp2 = true;
22150 }
22151 if (obj2) {
22152 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22153 if (!SWIG_IsOK(ecode3)) {
22154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22155 }
22156 arg3 = static_cast< bool >(val3);
22157 }
22158 {
22159 PyThreadState* __tstate = wxPyBeginAllowThreads();
22160 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22161 wxPyEndAllowThreads(__tstate);
22162 if (PyErr_Occurred()) SWIG_fail;
22163 }
22164 {
22165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22166 }
22167 {
22168 if (temp2)
22169 delete arg2;
22170 }
22171 return resultobj;
22172 fail:
22173 {
22174 if (temp2)
22175 delete arg2;
22176 }
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22182 PyObject *resultobj = 0;
22183 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22184 wxString *arg2 = 0 ;
22185 bool result;
22186 void *argp1 = 0 ;
22187 int res1 = 0 ;
22188 bool temp2 = false ;
22189 PyObject * obj0 = 0 ;
22190 PyObject * obj1 = 0 ;
22191 char * kwnames[] = {
22192 (char *) "self",(char *) "key", NULL
22193 };
22194
22195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22197 if (!SWIG_IsOK(res1)) {
22198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22199 }
22200 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22201 {
22202 arg2 = wxString_in_helper(obj1);
22203 if (arg2 == NULL) SWIG_fail;
22204 temp2 = true;
22205 }
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22209 wxPyEndAllowThreads(__tstate);
22210 if (PyErr_Occurred()) SWIG_fail;
22211 }
22212 {
22213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22214 }
22215 {
22216 if (temp2)
22217 delete arg2;
22218 }
22219 return resultobj;
22220 fail:
22221 {
22222 if (temp2)
22223 delete arg2;
22224 }
22225 return NULL;
22226 }
22227
22228
22229 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22230 PyObject *resultobj = 0;
22231 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22232 bool result;
22233 void *argp1 = 0 ;
22234 int res1 = 0 ;
22235 PyObject *swig_obj[1] ;
22236
22237 if (!args) SWIG_fail;
22238 swig_obj[0] = args;
22239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22240 if (!SWIG_IsOK(res1)) {
22241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22242 }
22243 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22244 {
22245 PyThreadState* __tstate = wxPyBeginAllowThreads();
22246 result = (bool)(arg1)->DeleteAll();
22247 wxPyEndAllowThreads(__tstate);
22248 if (PyErr_Occurred()) SWIG_fail;
22249 }
22250 {
22251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22252 }
22253 return resultobj;
22254 fail:
22255 return NULL;
22256 }
22257
22258
22259 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22260 PyObject *resultobj = 0;
22261 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22262 bool arg2 = (bool) true ;
22263 void *argp1 = 0 ;
22264 int res1 = 0 ;
22265 bool val2 ;
22266 int ecode2 = 0 ;
22267 PyObject * obj0 = 0 ;
22268 PyObject * obj1 = 0 ;
22269 char * kwnames[] = {
22270 (char *) "self",(char *) "doIt", NULL
22271 };
22272
22273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22275 if (!SWIG_IsOK(res1)) {
22276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22277 }
22278 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22279 if (obj1) {
22280 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22281 if (!SWIG_IsOK(ecode2)) {
22282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22283 }
22284 arg2 = static_cast< bool >(val2);
22285 }
22286 {
22287 PyThreadState* __tstate = wxPyBeginAllowThreads();
22288 (arg1)->SetExpandEnvVars(arg2);
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 resultobj = SWIG_Py_Void();
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22300 PyObject *resultobj = 0;
22301 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22302 bool result;
22303 void *argp1 = 0 ;
22304 int res1 = 0 ;
22305 PyObject *swig_obj[1] ;
22306
22307 if (!args) SWIG_fail;
22308 swig_obj[0] = args;
22309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22310 if (!SWIG_IsOK(res1)) {
22311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22312 }
22313 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22314 {
22315 PyThreadState* __tstate = wxPyBeginAllowThreads();
22316 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22317 wxPyEndAllowThreads(__tstate);
22318 if (PyErr_Occurred()) SWIG_fail;
22319 }
22320 {
22321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22322 }
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22330 PyObject *resultobj = 0;
22331 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22332 bool arg2 = (bool) true ;
22333 void *argp1 = 0 ;
22334 int res1 = 0 ;
22335 bool val2 ;
22336 int ecode2 = 0 ;
22337 PyObject * obj0 = 0 ;
22338 PyObject * obj1 = 0 ;
22339 char * kwnames[] = {
22340 (char *) "self",(char *) "doIt", NULL
22341 };
22342
22343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22345 if (!SWIG_IsOK(res1)) {
22346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22347 }
22348 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22349 if (obj1) {
22350 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22351 if (!SWIG_IsOK(ecode2)) {
22352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22353 }
22354 arg2 = static_cast< bool >(val2);
22355 }
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 (arg1)->SetRecordDefaults(arg2);
22359 wxPyEndAllowThreads(__tstate);
22360 if (PyErr_Occurred()) SWIG_fail;
22361 }
22362 resultobj = SWIG_Py_Void();
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22370 PyObject *resultobj = 0;
22371 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22372 bool result;
22373 void *argp1 = 0 ;
22374 int res1 = 0 ;
22375 PyObject *swig_obj[1] ;
22376
22377 if (!args) SWIG_fail;
22378 swig_obj[0] = args;
22379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22380 if (!SWIG_IsOK(res1)) {
22381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22382 }
22383 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22384 {
22385 PyThreadState* __tstate = wxPyBeginAllowThreads();
22386 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22387 wxPyEndAllowThreads(__tstate);
22388 if (PyErr_Occurred()) SWIG_fail;
22389 }
22390 {
22391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22392 }
22393 return resultobj;
22394 fail:
22395 return NULL;
22396 }
22397
22398
22399 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22400 PyObject *resultobj = 0;
22401 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22402 wxString *arg2 = 0 ;
22403 wxString result;
22404 void *argp1 = 0 ;
22405 int res1 = 0 ;
22406 bool temp2 = false ;
22407 PyObject * obj0 = 0 ;
22408 PyObject * obj1 = 0 ;
22409 char * kwnames[] = {
22410 (char *) "self",(char *) "str", NULL
22411 };
22412
22413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22415 if (!SWIG_IsOK(res1)) {
22416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22417 }
22418 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22419 {
22420 arg2 = wxString_in_helper(obj1);
22421 if (arg2 == NULL) SWIG_fail;
22422 temp2 = true;
22423 }
22424 {
22425 PyThreadState* __tstate = wxPyBeginAllowThreads();
22426 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22427 wxPyEndAllowThreads(__tstate);
22428 if (PyErr_Occurred()) SWIG_fail;
22429 }
22430 {
22431 #if wxUSE_UNICODE
22432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22433 #else
22434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22435 #endif
22436 }
22437 {
22438 if (temp2)
22439 delete arg2;
22440 }
22441 return resultobj;
22442 fail:
22443 {
22444 if (temp2)
22445 delete arg2;
22446 }
22447 return NULL;
22448 }
22449
22450
22451 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22452 PyObject *resultobj = 0;
22453 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22454 wxString result;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 PyObject *swig_obj[1] ;
22458
22459 if (!args) SWIG_fail;
22460 swig_obj[0] = args;
22461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22462 if (!SWIG_IsOK(res1)) {
22463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22464 }
22465 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22466 {
22467 PyThreadState* __tstate = wxPyBeginAllowThreads();
22468 result = ((wxConfigBase const *)arg1)->GetAppName();
22469 wxPyEndAllowThreads(__tstate);
22470 if (PyErr_Occurred()) SWIG_fail;
22471 }
22472 {
22473 #if wxUSE_UNICODE
22474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22475 #else
22476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22477 #endif
22478 }
22479 return resultobj;
22480 fail:
22481 return NULL;
22482 }
22483
22484
22485 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22486 PyObject *resultobj = 0;
22487 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22488 wxString result;
22489 void *argp1 = 0 ;
22490 int res1 = 0 ;
22491 PyObject *swig_obj[1] ;
22492
22493 if (!args) SWIG_fail;
22494 swig_obj[0] = args;
22495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22496 if (!SWIG_IsOK(res1)) {
22497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22498 }
22499 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22500 {
22501 PyThreadState* __tstate = wxPyBeginAllowThreads();
22502 result = ((wxConfigBase const *)arg1)->GetVendorName();
22503 wxPyEndAllowThreads(__tstate);
22504 if (PyErr_Occurred()) SWIG_fail;
22505 }
22506 {
22507 #if wxUSE_UNICODE
22508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22509 #else
22510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22511 #endif
22512 }
22513 return resultobj;
22514 fail:
22515 return NULL;
22516 }
22517
22518
22519 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22520 PyObject *resultobj = 0;
22521 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22522 wxString *arg2 = 0 ;
22523 void *argp1 = 0 ;
22524 int res1 = 0 ;
22525 bool temp2 = false ;
22526 PyObject * obj0 = 0 ;
22527 PyObject * obj1 = 0 ;
22528 char * kwnames[] = {
22529 (char *) "self",(char *) "appName", NULL
22530 };
22531
22532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22534 if (!SWIG_IsOK(res1)) {
22535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22536 }
22537 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22538 {
22539 arg2 = wxString_in_helper(obj1);
22540 if (arg2 == NULL) SWIG_fail;
22541 temp2 = true;
22542 }
22543 {
22544 PyThreadState* __tstate = wxPyBeginAllowThreads();
22545 (arg1)->SetAppName((wxString const &)*arg2);
22546 wxPyEndAllowThreads(__tstate);
22547 if (PyErr_Occurred()) SWIG_fail;
22548 }
22549 resultobj = SWIG_Py_Void();
22550 {
22551 if (temp2)
22552 delete arg2;
22553 }
22554 return resultobj;
22555 fail:
22556 {
22557 if (temp2)
22558 delete arg2;
22559 }
22560 return NULL;
22561 }
22562
22563
22564 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22565 PyObject *resultobj = 0;
22566 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22567 wxString *arg2 = 0 ;
22568 void *argp1 = 0 ;
22569 int res1 = 0 ;
22570 bool temp2 = false ;
22571 PyObject * obj0 = 0 ;
22572 PyObject * obj1 = 0 ;
22573 char * kwnames[] = {
22574 (char *) "self",(char *) "vendorName", NULL
22575 };
22576
22577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22579 if (!SWIG_IsOK(res1)) {
22580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22581 }
22582 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22583 {
22584 arg2 = wxString_in_helper(obj1);
22585 if (arg2 == NULL) SWIG_fail;
22586 temp2 = true;
22587 }
22588 {
22589 PyThreadState* __tstate = wxPyBeginAllowThreads();
22590 (arg1)->SetVendorName((wxString const &)*arg2);
22591 wxPyEndAllowThreads(__tstate);
22592 if (PyErr_Occurred()) SWIG_fail;
22593 }
22594 resultobj = SWIG_Py_Void();
22595 {
22596 if (temp2)
22597 delete arg2;
22598 }
22599 return resultobj;
22600 fail:
22601 {
22602 if (temp2)
22603 delete arg2;
22604 }
22605 return NULL;
22606 }
22607
22608
22609 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22610 PyObject *resultobj = 0;
22611 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22612 long arg2 ;
22613 void *argp1 = 0 ;
22614 int res1 = 0 ;
22615 long val2 ;
22616 int ecode2 = 0 ;
22617 PyObject * obj0 = 0 ;
22618 PyObject * obj1 = 0 ;
22619 char * kwnames[] = {
22620 (char *) "self",(char *) "style", NULL
22621 };
22622
22623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22625 if (!SWIG_IsOK(res1)) {
22626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22627 }
22628 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22629 ecode2 = SWIG_AsVal_long(obj1, &val2);
22630 if (!SWIG_IsOK(ecode2)) {
22631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22632 }
22633 arg2 = static_cast< long >(val2);
22634 {
22635 PyThreadState* __tstate = wxPyBeginAllowThreads();
22636 (arg1)->SetStyle(arg2);
22637 wxPyEndAllowThreads(__tstate);
22638 if (PyErr_Occurred()) SWIG_fail;
22639 }
22640 resultobj = SWIG_Py_Void();
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22648 PyObject *resultobj = 0;
22649 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22650 long result;
22651 void *argp1 = 0 ;
22652 int res1 = 0 ;
22653 PyObject *swig_obj[1] ;
22654
22655 if (!args) SWIG_fail;
22656 swig_obj[0] = args;
22657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22658 if (!SWIG_IsOK(res1)) {
22659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22660 }
22661 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22662 {
22663 PyThreadState* __tstate = wxPyBeginAllowThreads();
22664 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22665 wxPyEndAllowThreads(__tstate);
22666 if (PyErr_Occurred()) SWIG_fail;
22667 }
22668 resultobj = SWIG_From_long(static_cast< long >(result));
22669 return resultobj;
22670 fail:
22671 return NULL;
22672 }
22673
22674
22675 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22676 PyObject *obj;
22677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22678 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22679 return SWIG_Py_Void();
22680 }
22681
22682 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22683 PyObject *resultobj = 0;
22684 wxString const &arg1_defvalue = wxPyEmptyString ;
22685 wxString *arg1 = (wxString *) &arg1_defvalue ;
22686 wxString const &arg2_defvalue = wxPyEmptyString ;
22687 wxString *arg2 = (wxString *) &arg2_defvalue ;
22688 wxString const &arg3_defvalue = wxPyEmptyString ;
22689 wxString *arg3 = (wxString *) &arg3_defvalue ;
22690 wxString const &arg4_defvalue = wxPyEmptyString ;
22691 wxString *arg4 = (wxString *) &arg4_defvalue ;
22692 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22693 wxConfig *result = 0 ;
22694 bool temp1 = false ;
22695 bool temp2 = false ;
22696 bool temp3 = false ;
22697 bool temp4 = false ;
22698 long val5 ;
22699 int ecode5 = 0 ;
22700 PyObject * obj0 = 0 ;
22701 PyObject * obj1 = 0 ;
22702 PyObject * obj2 = 0 ;
22703 PyObject * obj3 = 0 ;
22704 PyObject * obj4 = 0 ;
22705 char * kwnames[] = {
22706 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22707 };
22708
22709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22710 if (obj0) {
22711 {
22712 arg1 = wxString_in_helper(obj0);
22713 if (arg1 == NULL) SWIG_fail;
22714 temp1 = true;
22715 }
22716 }
22717 if (obj1) {
22718 {
22719 arg2 = wxString_in_helper(obj1);
22720 if (arg2 == NULL) SWIG_fail;
22721 temp2 = true;
22722 }
22723 }
22724 if (obj2) {
22725 {
22726 arg3 = wxString_in_helper(obj2);
22727 if (arg3 == NULL) SWIG_fail;
22728 temp3 = true;
22729 }
22730 }
22731 if (obj3) {
22732 {
22733 arg4 = wxString_in_helper(obj3);
22734 if (arg4 == NULL) SWIG_fail;
22735 temp4 = true;
22736 }
22737 }
22738 if (obj4) {
22739 ecode5 = SWIG_AsVal_long(obj4, &val5);
22740 if (!SWIG_IsOK(ecode5)) {
22741 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22742 }
22743 arg5 = static_cast< long >(val5);
22744 }
22745 {
22746 PyThreadState* __tstate = wxPyBeginAllowThreads();
22747 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22752 {
22753 if (temp1)
22754 delete arg1;
22755 }
22756 {
22757 if (temp2)
22758 delete arg2;
22759 }
22760 {
22761 if (temp3)
22762 delete arg3;
22763 }
22764 {
22765 if (temp4)
22766 delete arg4;
22767 }
22768 return resultobj;
22769 fail:
22770 {
22771 if (temp1)
22772 delete arg1;
22773 }
22774 {
22775 if (temp2)
22776 delete arg2;
22777 }
22778 {
22779 if (temp3)
22780 delete arg3;
22781 }
22782 {
22783 if (temp4)
22784 delete arg4;
22785 }
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 PyObject *resultobj = 0;
22792 wxConfig *arg1 = (wxConfig *) 0 ;
22793 void *argp1 = 0 ;
22794 int res1 = 0 ;
22795 PyObject *swig_obj[1] ;
22796
22797 if (!args) SWIG_fail;
22798 swig_obj[0] = args;
22799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22800 if (!SWIG_IsOK(res1)) {
22801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22802 }
22803 arg1 = reinterpret_cast< wxConfig * >(argp1);
22804 {
22805 PyThreadState* __tstate = wxPyBeginAllowThreads();
22806 delete arg1;
22807
22808 wxPyEndAllowThreads(__tstate);
22809 if (PyErr_Occurred()) SWIG_fail;
22810 }
22811 resultobj = SWIG_Py_Void();
22812 return resultobj;
22813 fail:
22814 return NULL;
22815 }
22816
22817
22818 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22819 PyObject *obj;
22820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22821 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22822 return SWIG_Py_Void();
22823 }
22824
22825 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22826 return SWIG_Python_InitShadowInstance(args);
22827 }
22828
22829 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22830 PyObject *resultobj = 0;
22831 wxString const &arg1_defvalue = wxPyEmptyString ;
22832 wxString *arg1 = (wxString *) &arg1_defvalue ;
22833 wxString const &arg2_defvalue = wxPyEmptyString ;
22834 wxString *arg2 = (wxString *) &arg2_defvalue ;
22835 wxString const &arg3_defvalue = wxPyEmptyString ;
22836 wxString *arg3 = (wxString *) &arg3_defvalue ;
22837 wxString const &arg4_defvalue = wxPyEmptyString ;
22838 wxString *arg4 = (wxString *) &arg4_defvalue ;
22839 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22840 wxFileConfig *result = 0 ;
22841 bool temp1 = false ;
22842 bool temp2 = false ;
22843 bool temp3 = false ;
22844 bool temp4 = false ;
22845 long val5 ;
22846 int ecode5 = 0 ;
22847 PyObject * obj0 = 0 ;
22848 PyObject * obj1 = 0 ;
22849 PyObject * obj2 = 0 ;
22850 PyObject * obj3 = 0 ;
22851 PyObject * obj4 = 0 ;
22852 char * kwnames[] = {
22853 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22854 };
22855
22856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22857 if (obj0) {
22858 {
22859 arg1 = wxString_in_helper(obj0);
22860 if (arg1 == NULL) SWIG_fail;
22861 temp1 = true;
22862 }
22863 }
22864 if (obj1) {
22865 {
22866 arg2 = wxString_in_helper(obj1);
22867 if (arg2 == NULL) SWIG_fail;
22868 temp2 = true;
22869 }
22870 }
22871 if (obj2) {
22872 {
22873 arg3 = wxString_in_helper(obj2);
22874 if (arg3 == NULL) SWIG_fail;
22875 temp3 = true;
22876 }
22877 }
22878 if (obj3) {
22879 {
22880 arg4 = wxString_in_helper(obj3);
22881 if (arg4 == NULL) SWIG_fail;
22882 temp4 = true;
22883 }
22884 }
22885 if (obj4) {
22886 ecode5 = SWIG_AsVal_long(obj4, &val5);
22887 if (!SWIG_IsOK(ecode5)) {
22888 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22889 }
22890 arg5 = static_cast< long >(val5);
22891 }
22892 {
22893 PyThreadState* __tstate = wxPyBeginAllowThreads();
22894 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22895 wxPyEndAllowThreads(__tstate);
22896 if (PyErr_Occurred()) SWIG_fail;
22897 }
22898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22899 {
22900 if (temp1)
22901 delete arg1;
22902 }
22903 {
22904 if (temp2)
22905 delete arg2;
22906 }
22907 {
22908 if (temp3)
22909 delete arg3;
22910 }
22911 {
22912 if (temp4)
22913 delete arg4;
22914 }
22915 return resultobj;
22916 fail:
22917 {
22918 if (temp1)
22919 delete arg1;
22920 }
22921 {
22922 if (temp2)
22923 delete arg2;
22924 }
22925 {
22926 if (temp3)
22927 delete arg3;
22928 }
22929 {
22930 if (temp4)
22931 delete arg4;
22932 }
22933 return NULL;
22934 }
22935
22936
22937 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22938 PyObject *resultobj = 0;
22939 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22940 void *argp1 = 0 ;
22941 int res1 = 0 ;
22942 PyObject *swig_obj[1] ;
22943
22944 if (!args) SWIG_fail;
22945 swig_obj[0] = args;
22946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22947 if (!SWIG_IsOK(res1)) {
22948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22949 }
22950 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22951 {
22952 PyThreadState* __tstate = wxPyBeginAllowThreads();
22953 delete arg1;
22954
22955 wxPyEndAllowThreads(__tstate);
22956 if (PyErr_Occurred()) SWIG_fail;
22957 }
22958 resultobj = SWIG_Py_Void();
22959 return resultobj;
22960 fail:
22961 return NULL;
22962 }
22963
22964
22965 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22966 PyObject *obj;
22967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22968 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22969 return SWIG_Py_Void();
22970 }
22971
22972 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22973 return SWIG_Python_InitShadowInstance(args);
22974 }
22975
22976 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22977 PyObject *resultobj = 0;
22978 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22979 wxString *arg2 = 0 ;
22980 wxConfigPathChanger *result = 0 ;
22981 void *argp1 = 0 ;
22982 int res1 = 0 ;
22983 bool temp2 = false ;
22984 PyObject * obj0 = 0 ;
22985 PyObject * obj1 = 0 ;
22986 char * kwnames[] = {
22987 (char *) "config",(char *) "entry", NULL
22988 };
22989
22990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22992 if (!SWIG_IsOK(res1)) {
22993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22994 }
22995 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22996 {
22997 arg2 = wxString_in_helper(obj1);
22998 if (arg2 == NULL) SWIG_fail;
22999 temp2 = true;
23000 }
23001 {
23002 PyThreadState* __tstate = wxPyBeginAllowThreads();
23003 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23004 wxPyEndAllowThreads(__tstate);
23005 if (PyErr_Occurred()) SWIG_fail;
23006 }
23007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23008 {
23009 if (temp2)
23010 delete arg2;
23011 }
23012 return resultobj;
23013 fail:
23014 {
23015 if (temp2)
23016 delete arg2;
23017 }
23018 return NULL;
23019 }
23020
23021
23022 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23023 PyObject *resultobj = 0;
23024 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23025 void *argp1 = 0 ;
23026 int res1 = 0 ;
23027 PyObject *swig_obj[1] ;
23028
23029 if (!args) SWIG_fail;
23030 swig_obj[0] = args;
23031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23032 if (!SWIG_IsOK(res1)) {
23033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23034 }
23035 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23036 {
23037 PyThreadState* __tstate = wxPyBeginAllowThreads();
23038 delete arg1;
23039
23040 wxPyEndAllowThreads(__tstate);
23041 if (PyErr_Occurred()) SWIG_fail;
23042 }
23043 resultobj = SWIG_Py_Void();
23044 return resultobj;
23045 fail:
23046 return NULL;
23047 }
23048
23049
23050 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23051 PyObject *resultobj = 0;
23052 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23053 wxString *result = 0 ;
23054 void *argp1 = 0 ;
23055 int res1 = 0 ;
23056 PyObject *swig_obj[1] ;
23057
23058 if (!args) SWIG_fail;
23059 swig_obj[0] = args;
23060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23061 if (!SWIG_IsOK(res1)) {
23062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23063 }
23064 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23065 {
23066 PyThreadState* __tstate = wxPyBeginAllowThreads();
23067 {
23068 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23069 result = (wxString *) &_result_ref;
23070 }
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 {
23075 #if wxUSE_UNICODE
23076 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23077 #else
23078 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23079 #endif
23080 }
23081 return resultobj;
23082 fail:
23083 return NULL;
23084 }
23085
23086
23087 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23088 PyObject *obj;
23089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23090 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23091 return SWIG_Py_Void();
23092 }
23093
23094 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23095 return SWIG_Python_InitShadowInstance(args);
23096 }
23097
23098 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj = 0;
23100 wxString *arg1 = 0 ;
23101 wxString result;
23102 bool temp1 = false ;
23103 PyObject * obj0 = 0 ;
23104 char * kwnames[] = {
23105 (char *) "sz", NULL
23106 };
23107
23108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23109 {
23110 arg1 = wxString_in_helper(obj0);
23111 if (arg1 == NULL) SWIG_fail;
23112 temp1 = true;
23113 }
23114 {
23115 PyThreadState* __tstate = wxPyBeginAllowThreads();
23116 result = wxExpandEnvVars((wxString const &)*arg1);
23117 wxPyEndAllowThreads(__tstate);
23118 if (PyErr_Occurred()) SWIG_fail;
23119 }
23120 {
23121 #if wxUSE_UNICODE
23122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23123 #else
23124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23125 #endif
23126 }
23127 {
23128 if (temp1)
23129 delete arg1;
23130 }
23131 return resultobj;
23132 fail:
23133 {
23134 if (temp1)
23135 delete arg1;
23136 }
23137 return NULL;
23138 }
23139
23140
23141 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23142 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23143 return 1;
23144 }
23145
23146
23147 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23148 PyObject *pyobj = 0;
23149
23150 {
23151 #if wxUSE_UNICODE
23152 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23153 #else
23154 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23155 #endif
23156 }
23157 return pyobj;
23158 }
23159
23160
23161 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23162 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23163 return 1;
23164 }
23165
23166
23167 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23168 PyObject *pyobj = 0;
23169
23170 {
23171 #if wxUSE_UNICODE
23172 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23173 #else
23174 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23175 #endif
23176 }
23177 return pyobj;
23178 }
23179
23180
23181 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23182 PyObject *resultobj = 0;
23183 wxDateTime::Country arg1 ;
23184 int val1 ;
23185 int ecode1 = 0 ;
23186 PyObject * obj0 = 0 ;
23187 char * kwnames[] = {
23188 (char *) "country", NULL
23189 };
23190
23191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23192 ecode1 = SWIG_AsVal_int(obj0, &val1);
23193 if (!SWIG_IsOK(ecode1)) {
23194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23195 }
23196 arg1 = static_cast< wxDateTime::Country >(val1);
23197 {
23198 PyThreadState* __tstate = wxPyBeginAllowThreads();
23199 wxDateTime::SetCountry(arg1);
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 resultobj = SWIG_Py_Void();
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23211 PyObject *resultobj = 0;
23212 wxDateTime::Country result;
23213
23214 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23215 {
23216 PyThreadState* __tstate = wxPyBeginAllowThreads();
23217 result = (wxDateTime::Country)wxDateTime::GetCountry();
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 resultobj = SWIG_From_int(static_cast< int >(result));
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23229 PyObject *resultobj = 0;
23230 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23231 bool result;
23232 int val1 ;
23233 int ecode1 = 0 ;
23234 PyObject * obj0 = 0 ;
23235 char * kwnames[] = {
23236 (char *) "country", NULL
23237 };
23238
23239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23240 if (obj0) {
23241 ecode1 = SWIG_AsVal_int(obj0, &val1);
23242 if (!SWIG_IsOK(ecode1)) {
23243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23244 }
23245 arg1 = static_cast< wxDateTime::Country >(val1);
23246 }
23247 {
23248 PyThreadState* __tstate = wxPyBeginAllowThreads();
23249 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23250 wxPyEndAllowThreads(__tstate);
23251 if (PyErr_Occurred()) SWIG_fail;
23252 }
23253 {
23254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23255 }
23256 return resultobj;
23257 fail:
23258 return NULL;
23259 }
23260
23261
23262 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23263 PyObject *resultobj = 0;
23264 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23265 int result;
23266 int val1 ;
23267 int ecode1 = 0 ;
23268 PyObject * obj0 = 0 ;
23269 char * kwnames[] = {
23270 (char *) "cal", NULL
23271 };
23272
23273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23274 if (obj0) {
23275 ecode1 = SWIG_AsVal_int(obj0, &val1);
23276 if (!SWIG_IsOK(ecode1)) {
23277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23278 }
23279 arg1 = static_cast< wxDateTime::Calendar >(val1);
23280 }
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 result = (int)wxDateTime::GetCurrentYear(arg1);
23284 wxPyEndAllowThreads(__tstate);
23285 if (PyErr_Occurred()) SWIG_fail;
23286 }
23287 resultobj = SWIG_From_int(static_cast< int >(result));
23288 return resultobj;
23289 fail:
23290 return NULL;
23291 }
23292
23293
23294 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23295 PyObject *resultobj = 0;
23296 int arg1 ;
23297 int result;
23298 int val1 ;
23299 int ecode1 = 0 ;
23300 PyObject * obj0 = 0 ;
23301 char * kwnames[] = {
23302 (char *) "year", NULL
23303 };
23304
23305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23306 ecode1 = SWIG_AsVal_int(obj0, &val1);
23307 if (!SWIG_IsOK(ecode1)) {
23308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23309 }
23310 arg1 = static_cast< int >(val1);
23311 {
23312 PyThreadState* __tstate = wxPyBeginAllowThreads();
23313 result = (int)wxDateTime::ConvertYearToBC(arg1);
23314 wxPyEndAllowThreads(__tstate);
23315 if (PyErr_Occurred()) SWIG_fail;
23316 }
23317 resultobj = SWIG_From_int(static_cast< int >(result));
23318 return resultobj;
23319 fail:
23320 return NULL;
23321 }
23322
23323
23324 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23325 PyObject *resultobj = 0;
23326 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23327 wxDateTime::Month result;
23328 int val1 ;
23329 int ecode1 = 0 ;
23330 PyObject * obj0 = 0 ;
23331 char * kwnames[] = {
23332 (char *) "cal", NULL
23333 };
23334
23335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23336 if (obj0) {
23337 ecode1 = SWIG_AsVal_int(obj0, &val1);
23338 if (!SWIG_IsOK(ecode1)) {
23339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23340 }
23341 arg1 = static_cast< wxDateTime::Calendar >(val1);
23342 }
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 resultobj = SWIG_From_int(static_cast< int >(result));
23350 return resultobj;
23351 fail:
23352 return NULL;
23353 }
23354
23355
23356 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23357 PyObject *resultobj = 0;
23358 int arg1 = (int) wxDateTime::Inv_Year ;
23359 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23360 bool result;
23361 int val1 ;
23362 int ecode1 = 0 ;
23363 int val2 ;
23364 int ecode2 = 0 ;
23365 PyObject * obj0 = 0 ;
23366 PyObject * obj1 = 0 ;
23367 char * kwnames[] = {
23368 (char *) "year",(char *) "cal", NULL
23369 };
23370
23371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23372 if (obj0) {
23373 ecode1 = SWIG_AsVal_int(obj0, &val1);
23374 if (!SWIG_IsOK(ecode1)) {
23375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23376 }
23377 arg1 = static_cast< int >(val1);
23378 }
23379 if (obj1) {
23380 ecode2 = SWIG_AsVal_int(obj1, &val2);
23381 if (!SWIG_IsOK(ecode2)) {
23382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23383 }
23384 arg2 = static_cast< wxDateTime::Calendar >(val2);
23385 }
23386 {
23387 PyThreadState* __tstate = wxPyBeginAllowThreads();
23388 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23389 wxPyEndAllowThreads(__tstate);
23390 if (PyErr_Occurred()) SWIG_fail;
23391 }
23392 {
23393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23394 }
23395 return resultobj;
23396 fail:
23397 return NULL;
23398 }
23399
23400
23401 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23402 PyObject *resultobj = 0;
23403 int arg1 = (int) wxDateTime::Inv_Year ;
23404 int result;
23405 int val1 ;
23406 int ecode1 = 0 ;
23407 PyObject * obj0 = 0 ;
23408 char * kwnames[] = {
23409 (char *) "year", NULL
23410 };
23411
23412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23413 if (obj0) {
23414 ecode1 = SWIG_AsVal_int(obj0, &val1);
23415 if (!SWIG_IsOK(ecode1)) {
23416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23417 }
23418 arg1 = static_cast< int >(val1);
23419 }
23420 {
23421 PyThreadState* __tstate = wxPyBeginAllowThreads();
23422 result = (int)wxDateTime::GetCentury(arg1);
23423 wxPyEndAllowThreads(__tstate);
23424 if (PyErr_Occurred()) SWIG_fail;
23425 }
23426 resultobj = SWIG_From_int(static_cast< int >(result));
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj = 0;
23435 int arg1 ;
23436 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23437 int result;
23438 int val1 ;
23439 int ecode1 = 0 ;
23440 int val2 ;
23441 int ecode2 = 0 ;
23442 PyObject * obj0 = 0 ;
23443 PyObject * obj1 = 0 ;
23444 char * kwnames[] = {
23445 (char *) "year",(char *) "cal", NULL
23446 };
23447
23448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23449 ecode1 = SWIG_AsVal_int(obj0, &val1);
23450 if (!SWIG_IsOK(ecode1)) {
23451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23452 }
23453 arg1 = static_cast< int >(val1);
23454 if (obj1) {
23455 ecode2 = SWIG_AsVal_int(obj1, &val2);
23456 if (!SWIG_IsOK(ecode2)) {
23457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23458 }
23459 arg2 = static_cast< wxDateTime::Calendar >(val2);
23460 }
23461 {
23462 PyThreadState* __tstate = wxPyBeginAllowThreads();
23463 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23464 wxPyEndAllowThreads(__tstate);
23465 if (PyErr_Occurred()) SWIG_fail;
23466 }
23467 resultobj = SWIG_From_int(static_cast< int >(result));
23468 return resultobj;
23469 fail:
23470 return NULL;
23471 }
23472
23473
23474 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23475 PyObject *resultobj = 0;
23476 wxDateTime::Month arg1 ;
23477 int arg2 = (int) wxDateTime::Inv_Year ;
23478 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23479 int result;
23480 int val1 ;
23481 int ecode1 = 0 ;
23482 int val2 ;
23483 int ecode2 = 0 ;
23484 int val3 ;
23485 int ecode3 = 0 ;
23486 PyObject * obj0 = 0 ;
23487 PyObject * obj1 = 0 ;
23488 PyObject * obj2 = 0 ;
23489 char * kwnames[] = {
23490 (char *) "month",(char *) "year",(char *) "cal", NULL
23491 };
23492
23493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23494 ecode1 = SWIG_AsVal_int(obj0, &val1);
23495 if (!SWIG_IsOK(ecode1)) {
23496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23497 }
23498 arg1 = static_cast< wxDateTime::Month >(val1);
23499 if (obj1) {
23500 ecode2 = SWIG_AsVal_int(obj1, &val2);
23501 if (!SWIG_IsOK(ecode2)) {
23502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23503 }
23504 arg2 = static_cast< int >(val2);
23505 }
23506 if (obj2) {
23507 ecode3 = SWIG_AsVal_int(obj2, &val3);
23508 if (!SWIG_IsOK(ecode3)) {
23509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23510 }
23511 arg3 = static_cast< wxDateTime::Calendar >(val3);
23512 }
23513 {
23514 PyThreadState* __tstate = wxPyBeginAllowThreads();
23515 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 resultobj = SWIG_From_int(static_cast< int >(result));
23520 return resultobj;
23521 fail:
23522 return NULL;
23523 }
23524
23525
23526 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23527 PyObject *resultobj = 0;
23528 wxDateTime::Month arg1 ;
23529 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23530 wxString result;
23531 int val1 ;
23532 int ecode1 = 0 ;
23533 int val2 ;
23534 int ecode2 = 0 ;
23535 PyObject * obj0 = 0 ;
23536 PyObject * obj1 = 0 ;
23537 char * kwnames[] = {
23538 (char *) "month",(char *) "flags", NULL
23539 };
23540
23541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23542 ecode1 = SWIG_AsVal_int(obj0, &val1);
23543 if (!SWIG_IsOK(ecode1)) {
23544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23545 }
23546 arg1 = static_cast< wxDateTime::Month >(val1);
23547 if (obj1) {
23548 ecode2 = SWIG_AsVal_int(obj1, &val2);
23549 if (!SWIG_IsOK(ecode2)) {
23550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23551 }
23552 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23553 }
23554 {
23555 PyThreadState* __tstate = wxPyBeginAllowThreads();
23556 result = wxDateTime::GetMonthName(arg1,arg2);
23557 wxPyEndAllowThreads(__tstate);
23558 if (PyErr_Occurred()) SWIG_fail;
23559 }
23560 {
23561 #if wxUSE_UNICODE
23562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23563 #else
23564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23565 #endif
23566 }
23567 return resultobj;
23568 fail:
23569 return NULL;
23570 }
23571
23572
23573 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23574 PyObject *resultobj = 0;
23575 wxDateTime::WeekDay arg1 ;
23576 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23577 wxString result;
23578 int val1 ;
23579 int ecode1 = 0 ;
23580 int val2 ;
23581 int ecode2 = 0 ;
23582 PyObject * obj0 = 0 ;
23583 PyObject * obj1 = 0 ;
23584 char * kwnames[] = {
23585 (char *) "weekday",(char *) "flags", NULL
23586 };
23587
23588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23589 ecode1 = SWIG_AsVal_int(obj0, &val1);
23590 if (!SWIG_IsOK(ecode1)) {
23591 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23592 }
23593 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23594 if (obj1) {
23595 ecode2 = SWIG_AsVal_int(obj1, &val2);
23596 if (!SWIG_IsOK(ecode2)) {
23597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23598 }
23599 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23600 }
23601 {
23602 PyThreadState* __tstate = wxPyBeginAllowThreads();
23603 result = wxDateTime::GetWeekDayName(arg1,arg2);
23604 wxPyEndAllowThreads(__tstate);
23605 if (PyErr_Occurred()) SWIG_fail;
23606 }
23607 {
23608 #if wxUSE_UNICODE
23609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23610 #else
23611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23612 #endif
23613 }
23614 return resultobj;
23615 fail:
23616 return NULL;
23617 }
23618
23619
23620 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23621 PyObject *resultobj = 0;
23622 PyObject *result = 0 ;
23623
23624 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = (PyObject *)wxDateTime_GetAmPmStrings();
23628 wxPyEndAllowThreads(__tstate);
23629 if (PyErr_Occurred()) SWIG_fail;
23630 }
23631 resultobj = result;
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj = 0;
23640 int arg1 = (int) wxDateTime::Inv_Year ;
23641 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23642 bool result;
23643 int val1 ;
23644 int ecode1 = 0 ;
23645 int val2 ;
23646 int ecode2 = 0 ;
23647 PyObject * obj0 = 0 ;
23648 PyObject * obj1 = 0 ;
23649 char * kwnames[] = {
23650 (char *) "year",(char *) "country", NULL
23651 };
23652
23653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23654 if (obj0) {
23655 ecode1 = SWIG_AsVal_int(obj0, &val1);
23656 if (!SWIG_IsOK(ecode1)) {
23657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23658 }
23659 arg1 = static_cast< int >(val1);
23660 }
23661 if (obj1) {
23662 ecode2 = SWIG_AsVal_int(obj1, &val2);
23663 if (!SWIG_IsOK(ecode2)) {
23664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23665 }
23666 arg2 = static_cast< wxDateTime::Country >(val2);
23667 }
23668 {
23669 PyThreadState* __tstate = wxPyBeginAllowThreads();
23670 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23671 wxPyEndAllowThreads(__tstate);
23672 if (PyErr_Occurred()) SWIG_fail;
23673 }
23674 {
23675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23676 }
23677 return resultobj;
23678 fail:
23679 return NULL;
23680 }
23681
23682
23683 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23684 PyObject *resultobj = 0;
23685 int arg1 = (int) wxDateTime::Inv_Year ;
23686 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23687 wxDateTime result;
23688 int val1 ;
23689 int ecode1 = 0 ;
23690 int val2 ;
23691 int ecode2 = 0 ;
23692 PyObject * obj0 = 0 ;
23693 PyObject * obj1 = 0 ;
23694 char * kwnames[] = {
23695 (char *) "year",(char *) "country", NULL
23696 };
23697
23698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23699 if (obj0) {
23700 ecode1 = SWIG_AsVal_int(obj0, &val1);
23701 if (!SWIG_IsOK(ecode1)) {
23702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23703 }
23704 arg1 = static_cast< int >(val1);
23705 }
23706 if (obj1) {
23707 ecode2 = SWIG_AsVal_int(obj1, &val2);
23708 if (!SWIG_IsOK(ecode2)) {
23709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23710 }
23711 arg2 = static_cast< wxDateTime::Country >(val2);
23712 }
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = wxDateTime::GetBeginDST(arg1,arg2);
23716 wxPyEndAllowThreads(__tstate);
23717 if (PyErr_Occurred()) SWIG_fail;
23718 }
23719 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23720 return resultobj;
23721 fail:
23722 return NULL;
23723 }
23724
23725
23726 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23727 PyObject *resultobj = 0;
23728 int arg1 = (int) wxDateTime::Inv_Year ;
23729 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23730 wxDateTime result;
23731 int val1 ;
23732 int ecode1 = 0 ;
23733 int val2 ;
23734 int ecode2 = 0 ;
23735 PyObject * obj0 = 0 ;
23736 PyObject * obj1 = 0 ;
23737 char * kwnames[] = {
23738 (char *) "year",(char *) "country", NULL
23739 };
23740
23741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23742 if (obj0) {
23743 ecode1 = SWIG_AsVal_int(obj0, &val1);
23744 if (!SWIG_IsOK(ecode1)) {
23745 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23746 }
23747 arg1 = static_cast< int >(val1);
23748 }
23749 if (obj1) {
23750 ecode2 = SWIG_AsVal_int(obj1, &val2);
23751 if (!SWIG_IsOK(ecode2)) {
23752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23753 }
23754 arg2 = static_cast< wxDateTime::Country >(val2);
23755 }
23756 {
23757 PyThreadState* __tstate = wxPyBeginAllowThreads();
23758 result = wxDateTime::GetEndDST(arg1,arg2);
23759 wxPyEndAllowThreads(__tstate);
23760 if (PyErr_Occurred()) SWIG_fail;
23761 }
23762 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23763 return resultobj;
23764 fail:
23765 return NULL;
23766 }
23767
23768
23769 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23770 PyObject *resultobj = 0;
23771 wxDateTime result;
23772
23773 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = wxDateTime::Now();
23777 wxPyEndAllowThreads(__tstate);
23778 if (PyErr_Occurred()) SWIG_fail;
23779 }
23780 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23781 return resultobj;
23782 fail:
23783 return NULL;
23784 }
23785
23786
23787 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23788 PyObject *resultobj = 0;
23789 wxDateTime result;
23790
23791 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23792 {
23793 PyThreadState* __tstate = wxPyBeginAllowThreads();
23794 result = wxDateTime::UNow();
23795 wxPyEndAllowThreads(__tstate);
23796 if (PyErr_Occurred()) SWIG_fail;
23797 }
23798 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23799 return resultobj;
23800 fail:
23801 return NULL;
23802 }
23803
23804
23805 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23806 PyObject *resultobj = 0;
23807 wxDateTime result;
23808
23809 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23810 {
23811 PyThreadState* __tstate = wxPyBeginAllowThreads();
23812 result = wxDateTime::Today();
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23824 PyObject *resultobj = 0;
23825 wxDateTime *result = 0 ;
23826
23827 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 result = (wxDateTime *)new wxDateTime();
23831 wxPyEndAllowThreads(__tstate);
23832 if (PyErr_Occurred()) SWIG_fail;
23833 }
23834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23835 return resultobj;
23836 fail:
23837 return NULL;
23838 }
23839
23840
23841 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23842 PyObject *resultobj = 0;
23843 time_t arg1 ;
23844 wxDateTime *result = 0 ;
23845 unsigned int val1 ;
23846 int ecode1 = 0 ;
23847 PyObject * obj0 = 0 ;
23848 char * kwnames[] = {
23849 (char *) "timet", NULL
23850 };
23851
23852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23853 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23854 if (!SWIG_IsOK(ecode1)) {
23855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23856 }
23857 arg1 = static_cast< time_t >(val1);
23858 {
23859 PyThreadState* __tstate = wxPyBeginAllowThreads();
23860 result = (wxDateTime *)new wxDateTime(arg1);
23861 wxPyEndAllowThreads(__tstate);
23862 if (PyErr_Occurred()) SWIG_fail;
23863 }
23864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23865 return resultobj;
23866 fail:
23867 return NULL;
23868 }
23869
23870
23871 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23872 PyObject *resultobj = 0;
23873 double arg1 ;
23874 wxDateTime *result = 0 ;
23875 double val1 ;
23876 int ecode1 = 0 ;
23877 PyObject * obj0 = 0 ;
23878 char * kwnames[] = {
23879 (char *) "jdn", NULL
23880 };
23881
23882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23883 ecode1 = SWIG_AsVal_double(obj0, &val1);
23884 if (!SWIG_IsOK(ecode1)) {
23885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23886 }
23887 arg1 = static_cast< double >(val1);
23888 {
23889 PyThreadState* __tstate = wxPyBeginAllowThreads();
23890 result = (wxDateTime *)new wxDateTime(arg1);
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23902 PyObject *resultobj = 0;
23903 int arg1 ;
23904 int arg2 = (int) 0 ;
23905 int arg3 = (int) 0 ;
23906 int arg4 = (int) 0 ;
23907 wxDateTime *result = 0 ;
23908 int val1 ;
23909 int ecode1 = 0 ;
23910 int val2 ;
23911 int ecode2 = 0 ;
23912 int val3 ;
23913 int ecode3 = 0 ;
23914 int val4 ;
23915 int ecode4 = 0 ;
23916 PyObject * obj0 = 0 ;
23917 PyObject * obj1 = 0 ;
23918 PyObject * obj2 = 0 ;
23919 PyObject * obj3 = 0 ;
23920 char * kwnames[] = {
23921 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23922 };
23923
23924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23925 ecode1 = SWIG_AsVal_int(obj0, &val1);
23926 if (!SWIG_IsOK(ecode1)) {
23927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23928 }
23929 arg1 = static_cast< int >(val1);
23930 if (obj1) {
23931 ecode2 = SWIG_AsVal_int(obj1, &val2);
23932 if (!SWIG_IsOK(ecode2)) {
23933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23934 }
23935 arg2 = static_cast< int >(val2);
23936 }
23937 if (obj2) {
23938 ecode3 = SWIG_AsVal_int(obj2, &val3);
23939 if (!SWIG_IsOK(ecode3)) {
23940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23941 }
23942 arg3 = static_cast< int >(val3);
23943 }
23944 if (obj3) {
23945 ecode4 = SWIG_AsVal_int(obj3, &val4);
23946 if (!SWIG_IsOK(ecode4)) {
23947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23948 }
23949 arg4 = static_cast< int >(val4);
23950 }
23951 {
23952 PyThreadState* __tstate = wxPyBeginAllowThreads();
23953 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23954 wxPyEndAllowThreads(__tstate);
23955 if (PyErr_Occurred()) SWIG_fail;
23956 }
23957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23958 return resultobj;
23959 fail:
23960 return NULL;
23961 }
23962
23963
23964 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23965 PyObject *resultobj = 0;
23966 int arg1 ;
23967 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23968 int arg3 = (int) wxDateTime::Inv_Year ;
23969 int arg4 = (int) 0 ;
23970 int arg5 = (int) 0 ;
23971 int arg6 = (int) 0 ;
23972 int arg7 = (int) 0 ;
23973 wxDateTime *result = 0 ;
23974 int val1 ;
23975 int ecode1 = 0 ;
23976 int val2 ;
23977 int ecode2 = 0 ;
23978 int val3 ;
23979 int ecode3 = 0 ;
23980 int val4 ;
23981 int ecode4 = 0 ;
23982 int val5 ;
23983 int ecode5 = 0 ;
23984 int val6 ;
23985 int ecode6 = 0 ;
23986 int val7 ;
23987 int ecode7 = 0 ;
23988 PyObject * obj0 = 0 ;
23989 PyObject * obj1 = 0 ;
23990 PyObject * obj2 = 0 ;
23991 PyObject * obj3 = 0 ;
23992 PyObject * obj4 = 0 ;
23993 PyObject * obj5 = 0 ;
23994 PyObject * obj6 = 0 ;
23995 char * kwnames[] = {
23996 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23997 };
23998
23999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24000 ecode1 = SWIG_AsVal_int(obj0, &val1);
24001 if (!SWIG_IsOK(ecode1)) {
24002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24003 }
24004 arg1 = static_cast< int >(val1);
24005 if (obj1) {
24006 ecode2 = SWIG_AsVal_int(obj1, &val2);
24007 if (!SWIG_IsOK(ecode2)) {
24008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24009 }
24010 arg2 = static_cast< wxDateTime::Month >(val2);
24011 }
24012 if (obj2) {
24013 ecode3 = SWIG_AsVal_int(obj2, &val3);
24014 if (!SWIG_IsOK(ecode3)) {
24015 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24016 }
24017 arg3 = static_cast< int >(val3);
24018 }
24019 if (obj3) {
24020 ecode4 = SWIG_AsVal_int(obj3, &val4);
24021 if (!SWIG_IsOK(ecode4)) {
24022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24023 }
24024 arg4 = static_cast< int >(val4);
24025 }
24026 if (obj4) {
24027 ecode5 = SWIG_AsVal_int(obj4, &val5);
24028 if (!SWIG_IsOK(ecode5)) {
24029 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24030 }
24031 arg5 = static_cast< int >(val5);
24032 }
24033 if (obj5) {
24034 ecode6 = SWIG_AsVal_int(obj5, &val6);
24035 if (!SWIG_IsOK(ecode6)) {
24036 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24037 }
24038 arg6 = static_cast< int >(val6);
24039 }
24040 if (obj6) {
24041 ecode7 = SWIG_AsVal_int(obj6, &val7);
24042 if (!SWIG_IsOK(ecode7)) {
24043 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24044 }
24045 arg7 = static_cast< int >(val7);
24046 }
24047 {
24048 PyThreadState* __tstate = wxPyBeginAllowThreads();
24049 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj = 0;
24062 wxDateTime *arg1 = 0 ;
24063 wxDateTime *result = 0 ;
24064 void *argp1 = 0 ;
24065 int res1 = 0 ;
24066 PyObject * obj0 = 0 ;
24067 char * kwnames[] = {
24068 (char *) "date", NULL
24069 };
24070
24071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24072 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24073 if (!SWIG_IsOK(res1)) {
24074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24075 }
24076 if (!argp1) {
24077 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24078 }
24079 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24083 wxPyEndAllowThreads(__tstate);
24084 if (PyErr_Occurred()) SWIG_fail;
24085 }
24086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24087 return resultobj;
24088 fail:
24089 return NULL;
24090 }
24091
24092
24093 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24094 PyObject *resultobj = 0;
24095 wxDateTime *arg1 = (wxDateTime *) 0 ;
24096 void *argp1 = 0 ;
24097 int res1 = 0 ;
24098 PyObject *swig_obj[1] ;
24099
24100 if (!args) SWIG_fail;
24101 swig_obj[0] = args;
24102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24103 if (!SWIG_IsOK(res1)) {
24104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24105 }
24106 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24107 {
24108 PyThreadState* __tstate = wxPyBeginAllowThreads();
24109 delete arg1;
24110
24111 wxPyEndAllowThreads(__tstate);
24112 if (PyErr_Occurred()) SWIG_fail;
24113 }
24114 resultobj = SWIG_Py_Void();
24115 return resultobj;
24116 fail:
24117 return NULL;
24118 }
24119
24120
24121 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24122 PyObject *resultobj = 0;
24123 wxDateTime *arg1 = (wxDateTime *) 0 ;
24124 wxDateTime *result = 0 ;
24125 void *argp1 = 0 ;
24126 int res1 = 0 ;
24127 PyObject *swig_obj[1] ;
24128
24129 if (!args) SWIG_fail;
24130 swig_obj[0] = args;
24131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24132 if (!SWIG_IsOK(res1)) {
24133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24134 }
24135 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24136 {
24137 PyThreadState* __tstate = wxPyBeginAllowThreads();
24138 {
24139 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24140 result = (wxDateTime *) &_result_ref;
24141 }
24142 wxPyEndAllowThreads(__tstate);
24143 if (PyErr_Occurred()) SWIG_fail;
24144 }
24145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24146 return resultobj;
24147 fail:
24148 return NULL;
24149 }
24150
24151
24152 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24153 PyObject *resultobj = 0;
24154 wxDateTime *arg1 = (wxDateTime *) 0 ;
24155 time_t arg2 ;
24156 wxDateTime *result = 0 ;
24157 void *argp1 = 0 ;
24158 int res1 = 0 ;
24159 unsigned int val2 ;
24160 int ecode2 = 0 ;
24161 PyObject * obj0 = 0 ;
24162 PyObject * obj1 = 0 ;
24163 char * kwnames[] = {
24164 (char *) "self",(char *) "timet", NULL
24165 };
24166
24167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24169 if (!SWIG_IsOK(res1)) {
24170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24171 }
24172 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24173 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24174 if (!SWIG_IsOK(ecode2)) {
24175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24176 }
24177 arg2 = static_cast< time_t >(val2);
24178 {
24179 PyThreadState* __tstate = wxPyBeginAllowThreads();
24180 {
24181 wxDateTime &_result_ref = (arg1)->Set(arg2);
24182 result = (wxDateTime *) &_result_ref;
24183 }
24184 wxPyEndAllowThreads(__tstate);
24185 if (PyErr_Occurred()) SWIG_fail;
24186 }
24187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24188 return resultobj;
24189 fail:
24190 return NULL;
24191 }
24192
24193
24194 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24195 PyObject *resultobj = 0;
24196 wxDateTime *arg1 = (wxDateTime *) 0 ;
24197 double arg2 ;
24198 wxDateTime *result = 0 ;
24199 void *argp1 = 0 ;
24200 int res1 = 0 ;
24201 double val2 ;
24202 int ecode2 = 0 ;
24203 PyObject * obj0 = 0 ;
24204 PyObject * obj1 = 0 ;
24205 char * kwnames[] = {
24206 (char *) "self",(char *) "jdn", NULL
24207 };
24208
24209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24211 if (!SWIG_IsOK(res1)) {
24212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24213 }
24214 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24215 ecode2 = SWIG_AsVal_double(obj1, &val2);
24216 if (!SWIG_IsOK(ecode2)) {
24217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24218 }
24219 arg2 = static_cast< double >(val2);
24220 {
24221 PyThreadState* __tstate = wxPyBeginAllowThreads();
24222 {
24223 wxDateTime &_result_ref = (arg1)->Set(arg2);
24224 result = (wxDateTime *) &_result_ref;
24225 }
24226 wxPyEndAllowThreads(__tstate);
24227 if (PyErr_Occurred()) SWIG_fail;
24228 }
24229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24230 return resultobj;
24231 fail:
24232 return NULL;
24233 }
24234
24235
24236 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24237 PyObject *resultobj = 0;
24238 wxDateTime *arg1 = (wxDateTime *) 0 ;
24239 int arg2 ;
24240 int arg3 = (int) 0 ;
24241 int arg4 = (int) 0 ;
24242 int arg5 = (int) 0 ;
24243 wxDateTime *result = 0 ;
24244 void *argp1 = 0 ;
24245 int res1 = 0 ;
24246 int val2 ;
24247 int ecode2 = 0 ;
24248 int val3 ;
24249 int ecode3 = 0 ;
24250 int val4 ;
24251 int ecode4 = 0 ;
24252 int val5 ;
24253 int ecode5 = 0 ;
24254 PyObject * obj0 = 0 ;
24255 PyObject * obj1 = 0 ;
24256 PyObject * obj2 = 0 ;
24257 PyObject * obj3 = 0 ;
24258 PyObject * obj4 = 0 ;
24259 char * kwnames[] = {
24260 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24261 };
24262
24263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24265 if (!SWIG_IsOK(res1)) {
24266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24267 }
24268 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24269 ecode2 = SWIG_AsVal_int(obj1, &val2);
24270 if (!SWIG_IsOK(ecode2)) {
24271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24272 }
24273 arg2 = static_cast< int >(val2);
24274 if (obj2) {
24275 ecode3 = SWIG_AsVal_int(obj2, &val3);
24276 if (!SWIG_IsOK(ecode3)) {
24277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24278 }
24279 arg3 = static_cast< int >(val3);
24280 }
24281 if (obj3) {
24282 ecode4 = SWIG_AsVal_int(obj3, &val4);
24283 if (!SWIG_IsOK(ecode4)) {
24284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24285 }
24286 arg4 = static_cast< int >(val4);
24287 }
24288 if (obj4) {
24289 ecode5 = SWIG_AsVal_int(obj4, &val5);
24290 if (!SWIG_IsOK(ecode5)) {
24291 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24292 }
24293 arg5 = static_cast< int >(val5);
24294 }
24295 {
24296 PyThreadState* __tstate = wxPyBeginAllowThreads();
24297 {
24298 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24299 result = (wxDateTime *) &_result_ref;
24300 }
24301 wxPyEndAllowThreads(__tstate);
24302 if (PyErr_Occurred()) SWIG_fail;
24303 }
24304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj = 0;
24313 wxDateTime *arg1 = (wxDateTime *) 0 ;
24314 int arg2 ;
24315 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24316 int arg4 = (int) wxDateTime::Inv_Year ;
24317 int arg5 = (int) 0 ;
24318 int arg6 = (int) 0 ;
24319 int arg7 = (int) 0 ;
24320 int arg8 = (int) 0 ;
24321 wxDateTime *result = 0 ;
24322 void *argp1 = 0 ;
24323 int res1 = 0 ;
24324 int val2 ;
24325 int ecode2 = 0 ;
24326 int val3 ;
24327 int ecode3 = 0 ;
24328 int val4 ;
24329 int ecode4 = 0 ;
24330 int val5 ;
24331 int ecode5 = 0 ;
24332 int val6 ;
24333 int ecode6 = 0 ;
24334 int val7 ;
24335 int ecode7 = 0 ;
24336 int val8 ;
24337 int ecode8 = 0 ;
24338 PyObject * obj0 = 0 ;
24339 PyObject * obj1 = 0 ;
24340 PyObject * obj2 = 0 ;
24341 PyObject * obj3 = 0 ;
24342 PyObject * obj4 = 0 ;
24343 PyObject * obj5 = 0 ;
24344 PyObject * obj6 = 0 ;
24345 PyObject * obj7 = 0 ;
24346 char * kwnames[] = {
24347 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24348 };
24349
24350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24352 if (!SWIG_IsOK(res1)) {
24353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24354 }
24355 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24356 ecode2 = SWIG_AsVal_int(obj1, &val2);
24357 if (!SWIG_IsOK(ecode2)) {
24358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24359 }
24360 arg2 = static_cast< int >(val2);
24361 if (obj2) {
24362 ecode3 = SWIG_AsVal_int(obj2, &val3);
24363 if (!SWIG_IsOK(ecode3)) {
24364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24365 }
24366 arg3 = static_cast< wxDateTime::Month >(val3);
24367 }
24368 if (obj3) {
24369 ecode4 = SWIG_AsVal_int(obj3, &val4);
24370 if (!SWIG_IsOK(ecode4)) {
24371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24372 }
24373 arg4 = static_cast< int >(val4);
24374 }
24375 if (obj4) {
24376 ecode5 = SWIG_AsVal_int(obj4, &val5);
24377 if (!SWIG_IsOK(ecode5)) {
24378 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24379 }
24380 arg5 = static_cast< int >(val5);
24381 }
24382 if (obj5) {
24383 ecode6 = SWIG_AsVal_int(obj5, &val6);
24384 if (!SWIG_IsOK(ecode6)) {
24385 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24386 }
24387 arg6 = static_cast< int >(val6);
24388 }
24389 if (obj6) {
24390 ecode7 = SWIG_AsVal_int(obj6, &val7);
24391 if (!SWIG_IsOK(ecode7)) {
24392 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24393 }
24394 arg7 = static_cast< int >(val7);
24395 }
24396 if (obj7) {
24397 ecode8 = SWIG_AsVal_int(obj7, &val8);
24398 if (!SWIG_IsOK(ecode8)) {
24399 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24400 }
24401 arg8 = static_cast< int >(val8);
24402 }
24403 {
24404 PyThreadState* __tstate = wxPyBeginAllowThreads();
24405 {
24406 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24407 result = (wxDateTime *) &_result_ref;
24408 }
24409 wxPyEndAllowThreads(__tstate);
24410 if (PyErr_Occurred()) SWIG_fail;
24411 }
24412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24420 PyObject *resultobj = 0;
24421 wxDateTime *arg1 = (wxDateTime *) 0 ;
24422 wxDateTime *result = 0 ;
24423 void *argp1 = 0 ;
24424 int res1 = 0 ;
24425 PyObject *swig_obj[1] ;
24426
24427 if (!args) SWIG_fail;
24428 swig_obj[0] = args;
24429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24430 if (!SWIG_IsOK(res1)) {
24431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24432 }
24433 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24434 {
24435 PyThreadState* __tstate = wxPyBeginAllowThreads();
24436 {
24437 wxDateTime &_result_ref = (arg1)->ResetTime();
24438 result = (wxDateTime *) &_result_ref;
24439 }
24440 wxPyEndAllowThreads(__tstate);
24441 if (PyErr_Occurred()) SWIG_fail;
24442 }
24443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24444 return resultobj;
24445 fail:
24446 return NULL;
24447 }
24448
24449
24450 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24451 PyObject *resultobj = 0;
24452 wxDateTime *arg1 = (wxDateTime *) 0 ;
24453 int arg2 ;
24454 wxDateTime *result = 0 ;
24455 void *argp1 = 0 ;
24456 int res1 = 0 ;
24457 int val2 ;
24458 int ecode2 = 0 ;
24459 PyObject * obj0 = 0 ;
24460 PyObject * obj1 = 0 ;
24461 char * kwnames[] = {
24462 (char *) "self",(char *) "year", NULL
24463 };
24464
24465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24467 if (!SWIG_IsOK(res1)) {
24468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24469 }
24470 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24471 ecode2 = SWIG_AsVal_int(obj1, &val2);
24472 if (!SWIG_IsOK(ecode2)) {
24473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24474 }
24475 arg2 = static_cast< int >(val2);
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 {
24479 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24480 result = (wxDateTime *) &_result_ref;
24481 }
24482 wxPyEndAllowThreads(__tstate);
24483 if (PyErr_Occurred()) SWIG_fail;
24484 }
24485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24486 return resultobj;
24487 fail:
24488 return NULL;
24489 }
24490
24491
24492 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24493 PyObject *resultobj = 0;
24494 wxDateTime *arg1 = (wxDateTime *) 0 ;
24495 wxDateTime::Month arg2 ;
24496 wxDateTime *result = 0 ;
24497 void *argp1 = 0 ;
24498 int res1 = 0 ;
24499 int val2 ;
24500 int ecode2 = 0 ;
24501 PyObject * obj0 = 0 ;
24502 PyObject * obj1 = 0 ;
24503 char * kwnames[] = {
24504 (char *) "self",(char *) "month", NULL
24505 };
24506
24507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24509 if (!SWIG_IsOK(res1)) {
24510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24511 }
24512 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24513 ecode2 = SWIG_AsVal_int(obj1, &val2);
24514 if (!SWIG_IsOK(ecode2)) {
24515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24516 }
24517 arg2 = static_cast< wxDateTime::Month >(val2);
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 {
24521 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24522 result = (wxDateTime *) &_result_ref;
24523 }
24524 wxPyEndAllowThreads(__tstate);
24525 if (PyErr_Occurred()) SWIG_fail;
24526 }
24527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24528 return resultobj;
24529 fail:
24530 return NULL;
24531 }
24532
24533
24534 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24535 PyObject *resultobj = 0;
24536 wxDateTime *arg1 = (wxDateTime *) 0 ;
24537 int arg2 ;
24538 wxDateTime *result = 0 ;
24539 void *argp1 = 0 ;
24540 int res1 = 0 ;
24541 int val2 ;
24542 int ecode2 = 0 ;
24543 PyObject * obj0 = 0 ;
24544 PyObject * obj1 = 0 ;
24545 char * kwnames[] = {
24546 (char *) "self",(char *) "day", NULL
24547 };
24548
24549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24551 if (!SWIG_IsOK(res1)) {
24552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24553 }
24554 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24555 ecode2 = SWIG_AsVal_int(obj1, &val2);
24556 if (!SWIG_IsOK(ecode2)) {
24557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24558 }
24559 arg2 = static_cast< int >(val2);
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 {
24563 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24564 result = (wxDateTime *) &_result_ref;
24565 }
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj = 0;
24578 wxDateTime *arg1 = (wxDateTime *) 0 ;
24579 int arg2 ;
24580 wxDateTime *result = 0 ;
24581 void *argp1 = 0 ;
24582 int res1 = 0 ;
24583 int val2 ;
24584 int ecode2 = 0 ;
24585 PyObject * obj0 = 0 ;
24586 PyObject * obj1 = 0 ;
24587 char * kwnames[] = {
24588 (char *) "self",(char *) "hour", NULL
24589 };
24590
24591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24593 if (!SWIG_IsOK(res1)) {
24594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24595 }
24596 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24597 ecode2 = SWIG_AsVal_int(obj1, &val2);
24598 if (!SWIG_IsOK(ecode2)) {
24599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24600 }
24601 arg2 = static_cast< int >(val2);
24602 {
24603 PyThreadState* __tstate = wxPyBeginAllowThreads();
24604 {
24605 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24606 result = (wxDateTime *) &_result_ref;
24607 }
24608 wxPyEndAllowThreads(__tstate);
24609 if (PyErr_Occurred()) SWIG_fail;
24610 }
24611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj = 0;
24620 wxDateTime *arg1 = (wxDateTime *) 0 ;
24621 int arg2 ;
24622 wxDateTime *result = 0 ;
24623 void *argp1 = 0 ;
24624 int res1 = 0 ;
24625 int val2 ;
24626 int ecode2 = 0 ;
24627 PyObject * obj0 = 0 ;
24628 PyObject * obj1 = 0 ;
24629 char * kwnames[] = {
24630 (char *) "self",(char *) "minute", NULL
24631 };
24632
24633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24635 if (!SWIG_IsOK(res1)) {
24636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24637 }
24638 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24639 ecode2 = SWIG_AsVal_int(obj1, &val2);
24640 if (!SWIG_IsOK(ecode2)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24642 }
24643 arg2 = static_cast< int >(val2);
24644 {
24645 PyThreadState* __tstate = wxPyBeginAllowThreads();
24646 {
24647 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24648 result = (wxDateTime *) &_result_ref;
24649 }
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj = 0;
24662 wxDateTime *arg1 = (wxDateTime *) 0 ;
24663 int arg2 ;
24664 wxDateTime *result = 0 ;
24665 void *argp1 = 0 ;
24666 int res1 = 0 ;
24667 int val2 ;
24668 int ecode2 = 0 ;
24669 PyObject * obj0 = 0 ;
24670 PyObject * obj1 = 0 ;
24671 char * kwnames[] = {
24672 (char *) "self",(char *) "second", NULL
24673 };
24674
24675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24677 if (!SWIG_IsOK(res1)) {
24678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24679 }
24680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24681 ecode2 = SWIG_AsVal_int(obj1, &val2);
24682 if (!SWIG_IsOK(ecode2)) {
24683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24684 }
24685 arg2 = static_cast< int >(val2);
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 {
24689 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24690 result = (wxDateTime *) &_result_ref;
24691 }
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24703 PyObject *resultobj = 0;
24704 wxDateTime *arg1 = (wxDateTime *) 0 ;
24705 int arg2 ;
24706 wxDateTime *result = 0 ;
24707 void *argp1 = 0 ;
24708 int res1 = 0 ;
24709 int val2 ;
24710 int ecode2 = 0 ;
24711 PyObject * obj0 = 0 ;
24712 PyObject * obj1 = 0 ;
24713 char * kwnames[] = {
24714 (char *) "self",(char *) "millisecond", NULL
24715 };
24716
24717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24719 if (!SWIG_IsOK(res1)) {
24720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24721 }
24722 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24723 ecode2 = SWIG_AsVal_int(obj1, &val2);
24724 if (!SWIG_IsOK(ecode2)) {
24725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24726 }
24727 arg2 = static_cast< int >(val2);
24728 {
24729 PyThreadState* __tstate = wxPyBeginAllowThreads();
24730 {
24731 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24732 result = (wxDateTime *) &_result_ref;
24733 }
24734 wxPyEndAllowThreads(__tstate);
24735 if (PyErr_Occurred()) SWIG_fail;
24736 }
24737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24745 PyObject *resultobj = 0;
24746 wxDateTime *arg1 = (wxDateTime *) 0 ;
24747 wxDateTime::WeekDay arg2 ;
24748 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24749 wxDateTime *result = 0 ;
24750 void *argp1 = 0 ;
24751 int res1 = 0 ;
24752 int val2 ;
24753 int ecode2 = 0 ;
24754 int val3 ;
24755 int ecode3 = 0 ;
24756 PyObject * obj0 = 0 ;
24757 PyObject * obj1 = 0 ;
24758 PyObject * obj2 = 0 ;
24759 char * kwnames[] = {
24760 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24761 };
24762
24763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24767 }
24768 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24769 ecode2 = SWIG_AsVal_int(obj1, &val2);
24770 if (!SWIG_IsOK(ecode2)) {
24771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24772 }
24773 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24774 if (obj2) {
24775 ecode3 = SWIG_AsVal_int(obj2, &val3);
24776 if (!SWIG_IsOK(ecode3)) {
24777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24778 }
24779 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24780 }
24781 {
24782 PyThreadState* __tstate = wxPyBeginAllowThreads();
24783 {
24784 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24785 result = (wxDateTime *) &_result_ref;
24786 }
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24798 PyObject *resultobj = 0;
24799 wxDateTime *arg1 = (wxDateTime *) 0 ;
24800 wxDateTime::WeekDay arg2 ;
24801 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24802 wxDateTime result;
24803 void *argp1 = 0 ;
24804 int res1 = 0 ;
24805 int val2 ;
24806 int ecode2 = 0 ;
24807 int val3 ;
24808 int ecode3 = 0 ;
24809 PyObject * obj0 = 0 ;
24810 PyObject * obj1 = 0 ;
24811 PyObject * obj2 = 0 ;
24812 char * kwnames[] = {
24813 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24814 };
24815
24816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24818 if (!SWIG_IsOK(res1)) {
24819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24820 }
24821 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24822 ecode2 = SWIG_AsVal_int(obj1, &val2);
24823 if (!SWIG_IsOK(ecode2)) {
24824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24825 }
24826 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24827 if (obj2) {
24828 ecode3 = SWIG_AsVal_int(obj2, &val3);
24829 if (!SWIG_IsOK(ecode3)) {
24830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24831 }
24832 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24833 }
24834 {
24835 PyThreadState* __tstate = wxPyBeginAllowThreads();
24836 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24837 wxPyEndAllowThreads(__tstate);
24838 if (PyErr_Occurred()) SWIG_fail;
24839 }
24840 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24841 return resultobj;
24842 fail:
24843 return NULL;
24844 }
24845
24846
24847 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24848 PyObject *resultobj = 0;
24849 wxDateTime *arg1 = (wxDateTime *) 0 ;
24850 wxDateTime::WeekDay arg2 ;
24851 wxDateTime *result = 0 ;
24852 void *argp1 = 0 ;
24853 int res1 = 0 ;
24854 int val2 ;
24855 int ecode2 = 0 ;
24856 PyObject * obj0 = 0 ;
24857 PyObject * obj1 = 0 ;
24858 char * kwnames[] = {
24859 (char *) "self",(char *) "weekday", NULL
24860 };
24861
24862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24864 if (!SWIG_IsOK(res1)) {
24865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24866 }
24867 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24868 ecode2 = SWIG_AsVal_int(obj1, &val2);
24869 if (!SWIG_IsOK(ecode2)) {
24870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24871 }
24872 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24873 {
24874 PyThreadState* __tstate = wxPyBeginAllowThreads();
24875 {
24876 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24877 result = (wxDateTime *) &_result_ref;
24878 }
24879 wxPyEndAllowThreads(__tstate);
24880 if (PyErr_Occurred()) SWIG_fail;
24881 }
24882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24883 return resultobj;
24884 fail:
24885 return NULL;
24886 }
24887
24888
24889 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24890 PyObject *resultobj = 0;
24891 wxDateTime *arg1 = (wxDateTime *) 0 ;
24892 wxDateTime::WeekDay arg2 ;
24893 wxDateTime result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 int val2 ;
24897 int ecode2 = 0 ;
24898 PyObject * obj0 = 0 ;
24899 PyObject * obj1 = 0 ;
24900 char * kwnames[] = {
24901 (char *) "self",(char *) "weekday", NULL
24902 };
24903
24904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24906 if (!SWIG_IsOK(res1)) {
24907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24908 }
24909 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24910 ecode2 = SWIG_AsVal_int(obj1, &val2);
24911 if (!SWIG_IsOK(ecode2)) {
24912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24913 }
24914 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24915 {
24916 PyThreadState* __tstate = wxPyBeginAllowThreads();
24917 result = (arg1)->GetNextWeekDay(arg2);
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = 0;
24930 wxDateTime *arg1 = (wxDateTime *) 0 ;
24931 wxDateTime::WeekDay arg2 ;
24932 wxDateTime *result = 0 ;
24933 void *argp1 = 0 ;
24934 int res1 = 0 ;
24935 int val2 ;
24936 int ecode2 = 0 ;
24937 PyObject * obj0 = 0 ;
24938 PyObject * obj1 = 0 ;
24939 char * kwnames[] = {
24940 (char *) "self",(char *) "weekday", NULL
24941 };
24942
24943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24947 }
24948 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24949 ecode2 = SWIG_AsVal_int(obj1, &val2);
24950 if (!SWIG_IsOK(ecode2)) {
24951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24952 }
24953 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 {
24957 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24958 result = (wxDateTime *) &_result_ref;
24959 }
24960 wxPyEndAllowThreads(__tstate);
24961 if (PyErr_Occurred()) SWIG_fail;
24962 }
24963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24971 PyObject *resultobj = 0;
24972 wxDateTime *arg1 = (wxDateTime *) 0 ;
24973 wxDateTime::WeekDay arg2 ;
24974 wxDateTime result;
24975 void *argp1 = 0 ;
24976 int res1 = 0 ;
24977 int val2 ;
24978 int ecode2 = 0 ;
24979 PyObject * obj0 = 0 ;
24980 PyObject * obj1 = 0 ;
24981 char * kwnames[] = {
24982 (char *) "self",(char *) "weekday", NULL
24983 };
24984
24985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24987 if (!SWIG_IsOK(res1)) {
24988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24989 }
24990 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24991 ecode2 = SWIG_AsVal_int(obj1, &val2);
24992 if (!SWIG_IsOK(ecode2)) {
24993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24994 }
24995 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (arg1)->GetPrevWeekDay(arg2);
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25003 return resultobj;
25004 fail:
25005 return NULL;
25006 }
25007
25008
25009 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25010 PyObject *resultobj = 0;
25011 wxDateTime *arg1 = (wxDateTime *) 0 ;
25012 wxDateTime::WeekDay arg2 ;
25013 int arg3 = (int) 1 ;
25014 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25015 int arg5 = (int) wxDateTime::Inv_Year ;
25016 bool result;
25017 void *argp1 = 0 ;
25018 int res1 = 0 ;
25019 int val2 ;
25020 int ecode2 = 0 ;
25021 int val3 ;
25022 int ecode3 = 0 ;
25023 int val4 ;
25024 int ecode4 = 0 ;
25025 int val5 ;
25026 int ecode5 = 0 ;
25027 PyObject * obj0 = 0 ;
25028 PyObject * obj1 = 0 ;
25029 PyObject * obj2 = 0 ;
25030 PyObject * obj3 = 0 ;
25031 PyObject * obj4 = 0 ;
25032 char * kwnames[] = {
25033 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25034 };
25035
25036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25040 }
25041 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25042 ecode2 = SWIG_AsVal_int(obj1, &val2);
25043 if (!SWIG_IsOK(ecode2)) {
25044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25045 }
25046 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25047 if (obj2) {
25048 ecode3 = SWIG_AsVal_int(obj2, &val3);
25049 if (!SWIG_IsOK(ecode3)) {
25050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25051 }
25052 arg3 = static_cast< int >(val3);
25053 }
25054 if (obj3) {
25055 ecode4 = SWIG_AsVal_int(obj3, &val4);
25056 if (!SWIG_IsOK(ecode4)) {
25057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25058 }
25059 arg4 = static_cast< wxDateTime::Month >(val4);
25060 }
25061 if (obj4) {
25062 ecode5 = SWIG_AsVal_int(obj4, &val5);
25063 if (!SWIG_IsOK(ecode5)) {
25064 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25065 }
25066 arg5 = static_cast< int >(val5);
25067 }
25068 {
25069 PyThreadState* __tstate = wxPyBeginAllowThreads();
25070 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25071 wxPyEndAllowThreads(__tstate);
25072 if (PyErr_Occurred()) SWIG_fail;
25073 }
25074 {
25075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25076 }
25077 return resultobj;
25078 fail:
25079 return NULL;
25080 }
25081
25082
25083 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25084 PyObject *resultobj = 0;
25085 wxDateTime *arg1 = (wxDateTime *) 0 ;
25086 wxDateTime::WeekDay arg2 ;
25087 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25088 int arg4 = (int) wxDateTime::Inv_Year ;
25089 bool result;
25090 void *argp1 = 0 ;
25091 int res1 = 0 ;
25092 int val2 ;
25093 int ecode2 = 0 ;
25094 int val3 ;
25095 int ecode3 = 0 ;
25096 int val4 ;
25097 int ecode4 = 0 ;
25098 PyObject * obj0 = 0 ;
25099 PyObject * obj1 = 0 ;
25100 PyObject * obj2 = 0 ;
25101 PyObject * obj3 = 0 ;
25102 char * kwnames[] = {
25103 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25104 };
25105
25106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25108 if (!SWIG_IsOK(res1)) {
25109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25110 }
25111 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25112 ecode2 = SWIG_AsVal_int(obj1, &val2);
25113 if (!SWIG_IsOK(ecode2)) {
25114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25115 }
25116 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25117 if (obj2) {
25118 ecode3 = SWIG_AsVal_int(obj2, &val3);
25119 if (!SWIG_IsOK(ecode3)) {
25120 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25121 }
25122 arg3 = static_cast< wxDateTime::Month >(val3);
25123 }
25124 if (obj3) {
25125 ecode4 = SWIG_AsVal_int(obj3, &val4);
25126 if (!SWIG_IsOK(ecode4)) {
25127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25128 }
25129 arg4 = static_cast< int >(val4);
25130 }
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 {
25138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25139 }
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25147 PyObject *resultobj = 0;
25148 wxDateTime *arg1 = (wxDateTime *) 0 ;
25149 wxDateTime::WeekDay arg2 ;
25150 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25151 int arg4 = (int) wxDateTime::Inv_Year ;
25152 wxDateTime result;
25153 void *argp1 = 0 ;
25154 int res1 = 0 ;
25155 int val2 ;
25156 int ecode2 = 0 ;
25157 int val3 ;
25158 int ecode3 = 0 ;
25159 int val4 ;
25160 int ecode4 = 0 ;
25161 PyObject * obj0 = 0 ;
25162 PyObject * obj1 = 0 ;
25163 PyObject * obj2 = 0 ;
25164 PyObject * obj3 = 0 ;
25165 char * kwnames[] = {
25166 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25167 };
25168
25169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25171 if (!SWIG_IsOK(res1)) {
25172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25173 }
25174 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25175 ecode2 = SWIG_AsVal_int(obj1, &val2);
25176 if (!SWIG_IsOK(ecode2)) {
25177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25178 }
25179 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25180 if (obj2) {
25181 ecode3 = SWIG_AsVal_int(obj2, &val3);
25182 if (!SWIG_IsOK(ecode3)) {
25183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25184 }
25185 arg3 = static_cast< wxDateTime::Month >(val3);
25186 }
25187 if (obj3) {
25188 ecode4 = SWIG_AsVal_int(obj3, &val4);
25189 if (!SWIG_IsOK(ecode4)) {
25190 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25191 }
25192 arg4 = static_cast< int >(val4);
25193 }
25194 {
25195 PyThreadState* __tstate = wxPyBeginAllowThreads();
25196 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25197 wxPyEndAllowThreads(__tstate);
25198 if (PyErr_Occurred()) SWIG_fail;
25199 }
25200 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25201 return resultobj;
25202 fail:
25203 return NULL;
25204 }
25205
25206
25207 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj = 0;
25209 wxDateTime *arg1 = (wxDateTime *) 0 ;
25210 int arg2 ;
25211 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25212 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25213 bool result;
25214 void *argp1 = 0 ;
25215 int res1 = 0 ;
25216 int val2 ;
25217 int ecode2 = 0 ;
25218 int val3 ;
25219 int ecode3 = 0 ;
25220 int val4 ;
25221 int ecode4 = 0 ;
25222 PyObject * obj0 = 0 ;
25223 PyObject * obj1 = 0 ;
25224 PyObject * obj2 = 0 ;
25225 PyObject * obj3 = 0 ;
25226 char * kwnames[] = {
25227 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25228 };
25229
25230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25232 if (!SWIG_IsOK(res1)) {
25233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25234 }
25235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25236 ecode2 = SWIG_AsVal_int(obj1, &val2);
25237 if (!SWIG_IsOK(ecode2)) {
25238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25239 }
25240 arg2 = static_cast< int >(val2);
25241 if (obj2) {
25242 ecode3 = SWIG_AsVal_int(obj2, &val3);
25243 if (!SWIG_IsOK(ecode3)) {
25244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25245 }
25246 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25247 }
25248 if (obj3) {
25249 ecode4 = SWIG_AsVal_int(obj3, &val4);
25250 if (!SWIG_IsOK(ecode4)) {
25251 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25252 }
25253 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25254 }
25255 {
25256 PyThreadState* __tstate = wxPyBeginAllowThreads();
25257 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25258 wxPyEndAllowThreads(__tstate);
25259 if (PyErr_Occurred()) SWIG_fail;
25260 }
25261 {
25262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25263 }
25264 return resultobj;
25265 fail:
25266 return NULL;
25267 }
25268
25269
25270 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25271 PyObject *resultobj = 0;
25272 wxDateTime *arg1 = (wxDateTime *) 0 ;
25273 int arg2 ;
25274 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25275 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25276 wxDateTime result;
25277 void *argp1 = 0 ;
25278 int res1 = 0 ;
25279 int val2 ;
25280 int ecode2 = 0 ;
25281 int val3 ;
25282 int ecode3 = 0 ;
25283 int val4 ;
25284 int ecode4 = 0 ;
25285 PyObject * obj0 = 0 ;
25286 PyObject * obj1 = 0 ;
25287 PyObject * obj2 = 0 ;
25288 PyObject * obj3 = 0 ;
25289 char * kwnames[] = {
25290 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25291 };
25292
25293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25295 if (!SWIG_IsOK(res1)) {
25296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25297 }
25298 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25299 ecode2 = SWIG_AsVal_int(obj1, &val2);
25300 if (!SWIG_IsOK(ecode2)) {
25301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25302 }
25303 arg2 = static_cast< int >(val2);
25304 if (obj2) {
25305 ecode3 = SWIG_AsVal_int(obj2, &val3);
25306 if (!SWIG_IsOK(ecode3)) {
25307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25308 }
25309 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25310 }
25311 if (obj3) {
25312 ecode4 = SWIG_AsVal_int(obj3, &val4);
25313 if (!SWIG_IsOK(ecode4)) {
25314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25315 }
25316 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25317 }
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 result = (arg1)->GetWeek(arg2,arg3,arg4);
25321 wxPyEndAllowThreads(__tstate);
25322 if (PyErr_Occurred()) SWIG_fail;
25323 }
25324 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25325 return resultobj;
25326 fail:
25327 return NULL;
25328 }
25329
25330
25331 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25332 PyObject *resultobj = 0;
25333 int arg1 ;
25334 int arg2 ;
25335 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25336 wxDateTime result;
25337 int val1 ;
25338 int ecode1 = 0 ;
25339 int val2 ;
25340 int ecode2 = 0 ;
25341 int val3 ;
25342 int ecode3 = 0 ;
25343 PyObject * obj0 = 0 ;
25344 PyObject * obj1 = 0 ;
25345 PyObject * obj2 = 0 ;
25346 char * kwnames[] = {
25347 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25348 };
25349
25350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25351 ecode1 = SWIG_AsVal_int(obj0, &val1);
25352 if (!SWIG_IsOK(ecode1)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25354 }
25355 arg1 = static_cast< int >(val1);
25356 ecode2 = SWIG_AsVal_int(obj1, &val2);
25357 if (!SWIG_IsOK(ecode2)) {
25358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25359 }
25360 arg2 = static_cast< int >(val2);
25361 if (obj2) {
25362 ecode3 = SWIG_AsVal_int(obj2, &val3);
25363 if (!SWIG_IsOK(ecode3)) {
25364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25365 }
25366 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25367 }
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj = 0;
25383 wxDateTime *arg1 = (wxDateTime *) 0 ;
25384 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25385 int arg3 = (int) wxDateTime::Inv_Year ;
25386 wxDateTime *result = 0 ;
25387 void *argp1 = 0 ;
25388 int res1 = 0 ;
25389 int val2 ;
25390 int ecode2 = 0 ;
25391 int val3 ;
25392 int ecode3 = 0 ;
25393 PyObject * obj0 = 0 ;
25394 PyObject * obj1 = 0 ;
25395 PyObject * obj2 = 0 ;
25396 char * kwnames[] = {
25397 (char *) "self",(char *) "month",(char *) "year", NULL
25398 };
25399
25400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25402 if (!SWIG_IsOK(res1)) {
25403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25404 }
25405 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25406 if (obj1) {
25407 ecode2 = SWIG_AsVal_int(obj1, &val2);
25408 if (!SWIG_IsOK(ecode2)) {
25409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25410 }
25411 arg2 = static_cast< wxDateTime::Month >(val2);
25412 }
25413 if (obj2) {
25414 ecode3 = SWIG_AsVal_int(obj2, &val3);
25415 if (!SWIG_IsOK(ecode3)) {
25416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25417 }
25418 arg3 = static_cast< int >(val3);
25419 }
25420 {
25421 PyThreadState* __tstate = wxPyBeginAllowThreads();
25422 {
25423 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25424 result = (wxDateTime *) &_result_ref;
25425 }
25426 wxPyEndAllowThreads(__tstate);
25427 if (PyErr_Occurred()) SWIG_fail;
25428 }
25429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25430 return resultobj;
25431 fail:
25432 return NULL;
25433 }
25434
25435
25436 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25437 PyObject *resultobj = 0;
25438 wxDateTime *arg1 = (wxDateTime *) 0 ;
25439 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25440 int arg3 = (int) wxDateTime::Inv_Year ;
25441 wxDateTime result;
25442 void *argp1 = 0 ;
25443 int res1 = 0 ;
25444 int val2 ;
25445 int ecode2 = 0 ;
25446 int val3 ;
25447 int ecode3 = 0 ;
25448 PyObject * obj0 = 0 ;
25449 PyObject * obj1 = 0 ;
25450 PyObject * obj2 = 0 ;
25451 char * kwnames[] = {
25452 (char *) "self",(char *) "month",(char *) "year", NULL
25453 };
25454
25455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25457 if (!SWIG_IsOK(res1)) {
25458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25459 }
25460 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25461 if (obj1) {
25462 ecode2 = SWIG_AsVal_int(obj1, &val2);
25463 if (!SWIG_IsOK(ecode2)) {
25464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25465 }
25466 arg2 = static_cast< wxDateTime::Month >(val2);
25467 }
25468 if (obj2) {
25469 ecode3 = SWIG_AsVal_int(obj2, &val3);
25470 if (!SWIG_IsOK(ecode3)) {
25471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25472 }
25473 arg3 = static_cast< int >(val3);
25474 }
25475 {
25476 PyThreadState* __tstate = wxPyBeginAllowThreads();
25477 result = (arg1)->GetLastMonthDay(arg2,arg3);
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25489 PyObject *resultobj = 0;
25490 wxDateTime *arg1 = (wxDateTime *) 0 ;
25491 int arg2 ;
25492 wxDateTime *result = 0 ;
25493 void *argp1 = 0 ;
25494 int res1 = 0 ;
25495 int val2 ;
25496 int ecode2 = 0 ;
25497 PyObject * obj0 = 0 ;
25498 PyObject * obj1 = 0 ;
25499 char * kwnames[] = {
25500 (char *) "self",(char *) "yday", NULL
25501 };
25502
25503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25505 if (!SWIG_IsOK(res1)) {
25506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25507 }
25508 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25509 ecode2 = SWIG_AsVal_int(obj1, &val2);
25510 if (!SWIG_IsOK(ecode2)) {
25511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25512 }
25513 arg2 = static_cast< int >(val2);
25514 {
25515 PyThreadState* __tstate = wxPyBeginAllowThreads();
25516 {
25517 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25518 result = (wxDateTime *) &_result_ref;
25519 }
25520 wxPyEndAllowThreads(__tstate);
25521 if (PyErr_Occurred()) SWIG_fail;
25522 }
25523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25524 return resultobj;
25525 fail:
25526 return NULL;
25527 }
25528
25529
25530 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25531 PyObject *resultobj = 0;
25532 wxDateTime *arg1 = (wxDateTime *) 0 ;
25533 int arg2 ;
25534 wxDateTime result;
25535 void *argp1 = 0 ;
25536 int res1 = 0 ;
25537 int val2 ;
25538 int ecode2 = 0 ;
25539 PyObject * obj0 = 0 ;
25540 PyObject * obj1 = 0 ;
25541 char * kwnames[] = {
25542 (char *) "self",(char *) "yday", NULL
25543 };
25544
25545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25547 if (!SWIG_IsOK(res1)) {
25548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25549 }
25550 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25551 ecode2 = SWIG_AsVal_int(obj1, &val2);
25552 if (!SWIG_IsOK(ecode2)) {
25553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25554 }
25555 arg2 = static_cast< int >(val2);
25556 {
25557 PyThreadState* __tstate = wxPyBeginAllowThreads();
25558 result = (arg1)->GetYearDay(arg2);
25559 wxPyEndAllowThreads(__tstate);
25560 if (PyErr_Occurred()) SWIG_fail;
25561 }
25562 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25563 return resultobj;
25564 fail:
25565 return NULL;
25566 }
25567
25568
25569 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25570 PyObject *resultobj = 0;
25571 wxDateTime *arg1 = (wxDateTime *) 0 ;
25572 double result;
25573 void *argp1 = 0 ;
25574 int res1 = 0 ;
25575 PyObject *swig_obj[1] ;
25576
25577 if (!args) SWIG_fail;
25578 swig_obj[0] = args;
25579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25580 if (!SWIG_IsOK(res1)) {
25581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25582 }
25583 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25584 {
25585 PyThreadState* __tstate = wxPyBeginAllowThreads();
25586 result = (double)(arg1)->GetJulianDayNumber();
25587 wxPyEndAllowThreads(__tstate);
25588 if (PyErr_Occurred()) SWIG_fail;
25589 }
25590 resultobj = SWIG_From_double(static_cast< double >(result));
25591 return resultobj;
25592 fail:
25593 return NULL;
25594 }
25595
25596
25597 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25598 PyObject *resultobj = 0;
25599 wxDateTime *arg1 = (wxDateTime *) 0 ;
25600 double result;
25601 void *argp1 = 0 ;
25602 int res1 = 0 ;
25603 PyObject *swig_obj[1] ;
25604
25605 if (!args) SWIG_fail;
25606 swig_obj[0] = args;
25607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25608 if (!SWIG_IsOK(res1)) {
25609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25610 }
25611 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25612 {
25613 PyThreadState* __tstate = wxPyBeginAllowThreads();
25614 result = (double)(arg1)->GetJDN();
25615 wxPyEndAllowThreads(__tstate);
25616 if (PyErr_Occurred()) SWIG_fail;
25617 }
25618 resultobj = SWIG_From_double(static_cast< double >(result));
25619 return resultobj;
25620 fail:
25621 return NULL;
25622 }
25623
25624
25625 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25626 PyObject *resultobj = 0;
25627 wxDateTime *arg1 = (wxDateTime *) 0 ;
25628 double result;
25629 void *argp1 = 0 ;
25630 int res1 = 0 ;
25631 PyObject *swig_obj[1] ;
25632
25633 if (!args) SWIG_fail;
25634 swig_obj[0] = args;
25635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25636 if (!SWIG_IsOK(res1)) {
25637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25638 }
25639 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25640 {
25641 PyThreadState* __tstate = wxPyBeginAllowThreads();
25642 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 resultobj = SWIG_From_double(static_cast< double >(result));
25647 return resultobj;
25648 fail:
25649 return NULL;
25650 }
25651
25652
25653 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25654 PyObject *resultobj = 0;
25655 wxDateTime *arg1 = (wxDateTime *) 0 ;
25656 double result;
25657 void *argp1 = 0 ;
25658 int res1 = 0 ;
25659 PyObject *swig_obj[1] ;
25660
25661 if (!args) SWIG_fail;
25662 swig_obj[0] = args;
25663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25664 if (!SWIG_IsOK(res1)) {
25665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25666 }
25667 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25668 {
25669 PyThreadState* __tstate = wxPyBeginAllowThreads();
25670 result = (double)(arg1)->GetMJD();
25671 wxPyEndAllowThreads(__tstate);
25672 if (PyErr_Occurred()) SWIG_fail;
25673 }
25674 resultobj = SWIG_From_double(static_cast< double >(result));
25675 return resultobj;
25676 fail:
25677 return NULL;
25678 }
25679
25680
25681 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25682 PyObject *resultobj = 0;
25683 wxDateTime *arg1 = (wxDateTime *) 0 ;
25684 double result;
25685 void *argp1 = 0 ;
25686 int res1 = 0 ;
25687 PyObject *swig_obj[1] ;
25688
25689 if (!args) SWIG_fail;
25690 swig_obj[0] = args;
25691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25692 if (!SWIG_IsOK(res1)) {
25693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25694 }
25695 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25696 {
25697 PyThreadState* __tstate = wxPyBeginAllowThreads();
25698 result = (double)(arg1)->GetRataDie();
25699 wxPyEndAllowThreads(__tstate);
25700 if (PyErr_Occurred()) SWIG_fail;
25701 }
25702 resultobj = SWIG_From_double(static_cast< double >(result));
25703 return resultobj;
25704 fail:
25705 return NULL;
25706 }
25707
25708
25709 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25710 PyObject *resultobj = 0;
25711 wxDateTime *arg1 = (wxDateTime *) 0 ;
25712 wxDateTime::TimeZone *arg2 = 0 ;
25713 bool arg3 = (bool) false ;
25714 wxDateTime result;
25715 void *argp1 = 0 ;
25716 int res1 = 0 ;
25717 bool temp2 = false ;
25718 bool val3 ;
25719 int ecode3 = 0 ;
25720 PyObject * obj0 = 0 ;
25721 PyObject * obj1 = 0 ;
25722 PyObject * obj2 = 0 ;
25723 char * kwnames[] = {
25724 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25725 };
25726
25727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25731 }
25732 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25733 {
25734 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25735 temp2 = true;
25736 }
25737 if (obj2) {
25738 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25739 if (!SWIG_IsOK(ecode3)) {
25740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25741 }
25742 arg3 = static_cast< bool >(val3);
25743 }
25744 {
25745 PyThreadState* __tstate = wxPyBeginAllowThreads();
25746 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25747 wxPyEndAllowThreads(__tstate);
25748 if (PyErr_Occurred()) SWIG_fail;
25749 }
25750 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25751 {
25752 if (temp2) delete arg2;
25753 }
25754 return resultobj;
25755 fail:
25756 {
25757 if (temp2) delete arg2;
25758 }
25759 return NULL;
25760 }
25761
25762
25763 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25764 PyObject *resultobj = 0;
25765 wxDateTime *arg1 = (wxDateTime *) 0 ;
25766 wxDateTime::TimeZone *arg2 = 0 ;
25767 bool arg3 = (bool) false ;
25768 wxDateTime *result = 0 ;
25769 void *argp1 = 0 ;
25770 int res1 = 0 ;
25771 bool temp2 = false ;
25772 bool val3 ;
25773 int ecode3 = 0 ;
25774 PyObject * obj0 = 0 ;
25775 PyObject * obj1 = 0 ;
25776 PyObject * obj2 = 0 ;
25777 char * kwnames[] = {
25778 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25779 };
25780
25781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25783 if (!SWIG_IsOK(res1)) {
25784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25785 }
25786 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25787 {
25788 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25789 temp2 = true;
25790 }
25791 if (obj2) {
25792 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25793 if (!SWIG_IsOK(ecode3)) {
25794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25795 }
25796 arg3 = static_cast< bool >(val3);
25797 }
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 {
25801 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25802 result = (wxDateTime *) &_result_ref;
25803 }
25804 wxPyEndAllowThreads(__tstate);
25805 if (PyErr_Occurred()) SWIG_fail;
25806 }
25807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25808 {
25809 if (temp2) delete arg2;
25810 }
25811 return resultobj;
25812 fail:
25813 {
25814 if (temp2) delete arg2;
25815 }
25816 return NULL;
25817 }
25818
25819
25820 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25821 PyObject *resultobj = 0;
25822 wxDateTime *arg1 = (wxDateTime *) 0 ;
25823 wxDateTime::TimeZone *arg2 = 0 ;
25824 bool arg3 = (bool) false ;
25825 wxDateTime result;
25826 void *argp1 = 0 ;
25827 int res1 = 0 ;
25828 bool temp2 = false ;
25829 bool val3 ;
25830 int ecode3 = 0 ;
25831 PyObject * obj0 = 0 ;
25832 PyObject * obj1 = 0 ;
25833 PyObject * obj2 = 0 ;
25834 char * kwnames[] = {
25835 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25836 };
25837
25838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25840 if (!SWIG_IsOK(res1)) {
25841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25842 }
25843 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25844 {
25845 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25846 temp2 = true;
25847 }
25848 if (obj2) {
25849 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25850 if (!SWIG_IsOK(ecode3)) {
25851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25852 }
25853 arg3 = static_cast< bool >(val3);
25854 }
25855 {
25856 PyThreadState* __tstate = wxPyBeginAllowThreads();
25857 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25858 wxPyEndAllowThreads(__tstate);
25859 if (PyErr_Occurred()) SWIG_fail;
25860 }
25861 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25862 {
25863 if (temp2) delete arg2;
25864 }
25865 return resultobj;
25866 fail:
25867 {
25868 if (temp2) delete arg2;
25869 }
25870 return NULL;
25871 }
25872
25873
25874 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25875 PyObject *resultobj = 0;
25876 wxDateTime *arg1 = (wxDateTime *) 0 ;
25877 wxDateTime::TimeZone *arg2 = 0 ;
25878 bool arg3 = (bool) false ;
25879 wxDateTime *result = 0 ;
25880 void *argp1 = 0 ;
25881 int res1 = 0 ;
25882 bool temp2 = false ;
25883 bool val3 ;
25884 int ecode3 = 0 ;
25885 PyObject * obj0 = 0 ;
25886 PyObject * obj1 = 0 ;
25887 PyObject * obj2 = 0 ;
25888 char * kwnames[] = {
25889 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25890 };
25891
25892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25894 if (!SWIG_IsOK(res1)) {
25895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25896 }
25897 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25898 {
25899 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25900 temp2 = true;
25901 }
25902 if (obj2) {
25903 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25904 if (!SWIG_IsOK(ecode3)) {
25905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25906 }
25907 arg3 = static_cast< bool >(val3);
25908 }
25909 {
25910 PyThreadState* __tstate = wxPyBeginAllowThreads();
25911 {
25912 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25913 result = (wxDateTime *) &_result_ref;
25914 }
25915 wxPyEndAllowThreads(__tstate);
25916 if (PyErr_Occurred()) SWIG_fail;
25917 }
25918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25919 {
25920 if (temp2) delete arg2;
25921 }
25922 return resultobj;
25923 fail:
25924 {
25925 if (temp2) delete arg2;
25926 }
25927 return NULL;
25928 }
25929
25930
25931 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25932 PyObject *resultobj = 0;
25933 wxDateTime *arg1 = (wxDateTime *) 0 ;
25934 bool arg2 = (bool) false ;
25935 wxDateTime result;
25936 void *argp1 = 0 ;
25937 int res1 = 0 ;
25938 bool val2 ;
25939 int ecode2 = 0 ;
25940 PyObject * obj0 = 0 ;
25941 PyObject * obj1 = 0 ;
25942 char * kwnames[] = {
25943 (char *) "self",(char *) "noDST", NULL
25944 };
25945
25946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25948 if (!SWIG_IsOK(res1)) {
25949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25950 }
25951 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25952 if (obj1) {
25953 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25954 if (!SWIG_IsOK(ecode2)) {
25955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25956 }
25957 arg2 = static_cast< bool >(val2);
25958 }
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25973 PyObject *resultobj = 0;
25974 wxDateTime *arg1 = (wxDateTime *) 0 ;
25975 bool arg2 = (bool) false ;
25976 wxDateTime *result = 0 ;
25977 void *argp1 = 0 ;
25978 int res1 = 0 ;
25979 bool val2 ;
25980 int ecode2 = 0 ;
25981 PyObject * obj0 = 0 ;
25982 PyObject * obj1 = 0 ;
25983 char * kwnames[] = {
25984 (char *) "self",(char *) "noDST", NULL
25985 };
25986
25987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25989 if (!SWIG_IsOK(res1)) {
25990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25991 }
25992 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25993 if (obj1) {
25994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25995 if (!SWIG_IsOK(ecode2)) {
25996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25997 }
25998 arg2 = static_cast< bool >(val2);
25999 }
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 {
26003 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26004 result = (wxDateTime *) &_result_ref;
26005 }
26006 wxPyEndAllowThreads(__tstate);
26007 if (PyErr_Occurred()) SWIG_fail;
26008 }
26009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26017 PyObject *resultobj = 0;
26018 wxDateTime *arg1 = (wxDateTime *) 0 ;
26019 bool arg2 = (bool) false ;
26020 wxDateTime result;
26021 void *argp1 = 0 ;
26022 int res1 = 0 ;
26023 bool val2 ;
26024 int ecode2 = 0 ;
26025 PyObject * obj0 = 0 ;
26026 PyObject * obj1 = 0 ;
26027 char * kwnames[] = {
26028 (char *) "self",(char *) "noDST", NULL
26029 };
26030
26031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26033 if (!SWIG_IsOK(res1)) {
26034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26035 }
26036 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26037 if (obj1) {
26038 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26039 if (!SWIG_IsOK(ecode2)) {
26040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26041 }
26042 arg2 = static_cast< bool >(val2);
26043 }
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26058 PyObject *resultobj = 0;
26059 wxDateTime *arg1 = (wxDateTime *) 0 ;
26060 bool arg2 = (bool) false ;
26061 wxDateTime *result = 0 ;
26062 void *argp1 = 0 ;
26063 int res1 = 0 ;
26064 bool val2 ;
26065 int ecode2 = 0 ;
26066 PyObject * obj0 = 0 ;
26067 PyObject * obj1 = 0 ;
26068 char * kwnames[] = {
26069 (char *) "self",(char *) "noDST", NULL
26070 };
26071
26072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26074 if (!SWIG_IsOK(res1)) {
26075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26076 }
26077 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26078 if (obj1) {
26079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26080 if (!SWIG_IsOK(ecode2)) {
26081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26082 }
26083 arg2 = static_cast< bool >(val2);
26084 }
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 {
26088 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26089 result = (wxDateTime *) &_result_ref;
26090 }
26091 wxPyEndAllowThreads(__tstate);
26092 if (PyErr_Occurred()) SWIG_fail;
26093 }
26094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26095 return resultobj;
26096 fail:
26097 return NULL;
26098 }
26099
26100
26101 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26102 PyObject *resultobj = 0;
26103 wxDateTime *arg1 = (wxDateTime *) 0 ;
26104 bool arg2 = (bool) false ;
26105 wxDateTime result;
26106 void *argp1 = 0 ;
26107 int res1 = 0 ;
26108 bool val2 ;
26109 int ecode2 = 0 ;
26110 PyObject * obj0 = 0 ;
26111 PyObject * obj1 = 0 ;
26112 char * kwnames[] = {
26113 (char *) "self",(char *) "noDST", NULL
26114 };
26115
26116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26118 if (!SWIG_IsOK(res1)) {
26119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26120 }
26121 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26122 if (obj1) {
26123 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26124 if (!SWIG_IsOK(ecode2)) {
26125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26126 }
26127 arg2 = static_cast< bool >(val2);
26128 }
26129 {
26130 PyThreadState* __tstate = wxPyBeginAllowThreads();
26131 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26132 wxPyEndAllowThreads(__tstate);
26133 if (PyErr_Occurred()) SWIG_fail;
26134 }
26135 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26136 return resultobj;
26137 fail:
26138 return NULL;
26139 }
26140
26141
26142 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26143 PyObject *resultobj = 0;
26144 wxDateTime *arg1 = (wxDateTime *) 0 ;
26145 bool arg2 = (bool) false ;
26146 wxDateTime *result = 0 ;
26147 void *argp1 = 0 ;
26148 int res1 = 0 ;
26149 bool val2 ;
26150 int ecode2 = 0 ;
26151 PyObject * obj0 = 0 ;
26152 PyObject * obj1 = 0 ;
26153 char * kwnames[] = {
26154 (char *) "self",(char *) "noDST", NULL
26155 };
26156
26157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26159 if (!SWIG_IsOK(res1)) {
26160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26161 }
26162 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26163 if (obj1) {
26164 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26165 if (!SWIG_IsOK(ecode2)) {
26166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26167 }
26168 arg2 = static_cast< bool >(val2);
26169 }
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 {
26173 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26174 result = (wxDateTime *) &_result_ref;
26175 }
26176 wxPyEndAllowThreads(__tstate);
26177 if (PyErr_Occurred()) SWIG_fail;
26178 }
26179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26180 return resultobj;
26181 fail:
26182 return NULL;
26183 }
26184
26185
26186 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26187 PyObject *resultobj = 0;
26188 wxDateTime *arg1 = (wxDateTime *) 0 ;
26189 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26190 int result;
26191 void *argp1 = 0 ;
26192 int res1 = 0 ;
26193 int val2 ;
26194 int ecode2 = 0 ;
26195 PyObject * obj0 = 0 ;
26196 PyObject * obj1 = 0 ;
26197 char * kwnames[] = {
26198 (char *) "self",(char *) "country", NULL
26199 };
26200
26201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26203 if (!SWIG_IsOK(res1)) {
26204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26205 }
26206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26207 if (obj1) {
26208 ecode2 = SWIG_AsVal_int(obj1, &val2);
26209 if (!SWIG_IsOK(ecode2)) {
26210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26211 }
26212 arg2 = static_cast< wxDateTime::Country >(val2);
26213 }
26214 {
26215 PyThreadState* __tstate = wxPyBeginAllowThreads();
26216 result = (int)(arg1)->IsDST(arg2);
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 resultobj = SWIG_From_int(static_cast< int >(result));
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26228 PyObject *resultobj = 0;
26229 wxDateTime *arg1 = (wxDateTime *) 0 ;
26230 bool result;
26231 void *argp1 = 0 ;
26232 int res1 = 0 ;
26233 PyObject *swig_obj[1] ;
26234
26235 if (!args) SWIG_fail;
26236 swig_obj[0] = args;
26237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26238 if (!SWIG_IsOK(res1)) {
26239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26240 }
26241 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26242 {
26243 PyThreadState* __tstate = wxPyBeginAllowThreads();
26244 result = (bool)((wxDateTime const *)arg1)->IsValid();
26245 wxPyEndAllowThreads(__tstate);
26246 if (PyErr_Occurred()) SWIG_fail;
26247 }
26248 {
26249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26250 }
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26258 PyObject *resultobj = 0;
26259 wxDateTime *arg1 = (wxDateTime *) 0 ;
26260 time_t result;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 PyObject *swig_obj[1] ;
26264
26265 if (!args) SWIG_fail;
26266 swig_obj[0] = args;
26267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26270 }
26271 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26272 {
26273 PyThreadState* __tstate = wxPyBeginAllowThreads();
26274 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26275 wxPyEndAllowThreads(__tstate);
26276 if (PyErr_Occurred()) SWIG_fail;
26277 }
26278 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26286 PyObject *resultobj = 0;
26287 wxDateTime *arg1 = (wxDateTime *) 0 ;
26288 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26289 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26290 int result;
26291 void *argp1 = 0 ;
26292 int res1 = 0 ;
26293 bool temp2 = false ;
26294 PyObject * obj0 = 0 ;
26295 PyObject * obj1 = 0 ;
26296 char * kwnames[] = {
26297 (char *) "self",(char *) "tz", NULL
26298 };
26299
26300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26302 if (!SWIG_IsOK(res1)) {
26303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26304 }
26305 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26306 if (obj1) {
26307 {
26308 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26309 temp2 = true;
26310 }
26311 }
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26315 wxPyEndAllowThreads(__tstate);
26316 if (PyErr_Occurred()) SWIG_fail;
26317 }
26318 resultobj = SWIG_From_int(static_cast< int >(result));
26319 {
26320 if (temp2) delete arg2;
26321 }
26322 return resultobj;
26323 fail:
26324 {
26325 if (temp2) delete arg2;
26326 }
26327 return NULL;
26328 }
26329
26330
26331 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26332 PyObject *resultobj = 0;
26333 wxDateTime *arg1 = (wxDateTime *) 0 ;
26334 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26335 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26336 wxDateTime::Month result;
26337 void *argp1 = 0 ;
26338 int res1 = 0 ;
26339 bool temp2 = false ;
26340 PyObject * obj0 = 0 ;
26341 PyObject * obj1 = 0 ;
26342 char * kwnames[] = {
26343 (char *) "self",(char *) "tz", NULL
26344 };
26345
26346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26348 if (!SWIG_IsOK(res1)) {
26349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26350 }
26351 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26352 if (obj1) {
26353 {
26354 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26355 temp2 = true;
26356 }
26357 }
26358 {
26359 PyThreadState* __tstate = wxPyBeginAllowThreads();
26360 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26361 wxPyEndAllowThreads(__tstate);
26362 if (PyErr_Occurred()) SWIG_fail;
26363 }
26364 resultobj = SWIG_From_int(static_cast< int >(result));
26365 {
26366 if (temp2) delete arg2;
26367 }
26368 return resultobj;
26369 fail:
26370 {
26371 if (temp2) delete arg2;
26372 }
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26378 PyObject *resultobj = 0;
26379 wxDateTime *arg1 = (wxDateTime *) 0 ;
26380 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26381 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26382 int result;
26383 void *argp1 = 0 ;
26384 int res1 = 0 ;
26385 bool temp2 = false ;
26386 PyObject * obj0 = 0 ;
26387 PyObject * obj1 = 0 ;
26388 char * kwnames[] = {
26389 (char *) "self",(char *) "tz", NULL
26390 };
26391
26392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26394 if (!SWIG_IsOK(res1)) {
26395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26396 }
26397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26398 if (obj1) {
26399 {
26400 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26401 temp2 = true;
26402 }
26403 }
26404 {
26405 PyThreadState* __tstate = wxPyBeginAllowThreads();
26406 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26407 wxPyEndAllowThreads(__tstate);
26408 if (PyErr_Occurred()) SWIG_fail;
26409 }
26410 resultobj = SWIG_From_int(static_cast< int >(result));
26411 {
26412 if (temp2) delete arg2;
26413 }
26414 return resultobj;
26415 fail:
26416 {
26417 if (temp2) delete arg2;
26418 }
26419 return NULL;
26420 }
26421
26422
26423 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26424 PyObject *resultobj = 0;
26425 wxDateTime *arg1 = (wxDateTime *) 0 ;
26426 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26427 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26428 wxDateTime::WeekDay result;
26429 void *argp1 = 0 ;
26430 int res1 = 0 ;
26431 bool temp2 = false ;
26432 PyObject * obj0 = 0 ;
26433 PyObject * obj1 = 0 ;
26434 char * kwnames[] = {
26435 (char *) "self",(char *) "tz", NULL
26436 };
26437
26438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26440 if (!SWIG_IsOK(res1)) {
26441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26442 }
26443 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26444 if (obj1) {
26445 {
26446 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26447 temp2 = true;
26448 }
26449 }
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26453 wxPyEndAllowThreads(__tstate);
26454 if (PyErr_Occurred()) SWIG_fail;
26455 }
26456 resultobj = SWIG_From_int(static_cast< int >(result));
26457 {
26458 if (temp2) delete arg2;
26459 }
26460 return resultobj;
26461 fail:
26462 {
26463 if (temp2) delete arg2;
26464 }
26465 return NULL;
26466 }
26467
26468
26469 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26470 PyObject *resultobj = 0;
26471 wxDateTime *arg1 = (wxDateTime *) 0 ;
26472 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26473 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26474 int result;
26475 void *argp1 = 0 ;
26476 int res1 = 0 ;
26477 bool temp2 = false ;
26478 PyObject * obj0 = 0 ;
26479 PyObject * obj1 = 0 ;
26480 char * kwnames[] = {
26481 (char *) "self",(char *) "tz", NULL
26482 };
26483
26484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26486 if (!SWIG_IsOK(res1)) {
26487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26488 }
26489 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26490 if (obj1) {
26491 {
26492 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26493 temp2 = true;
26494 }
26495 }
26496 {
26497 PyThreadState* __tstate = wxPyBeginAllowThreads();
26498 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26499 wxPyEndAllowThreads(__tstate);
26500 if (PyErr_Occurred()) SWIG_fail;
26501 }
26502 resultobj = SWIG_From_int(static_cast< int >(result));
26503 {
26504 if (temp2) delete arg2;
26505 }
26506 return resultobj;
26507 fail:
26508 {
26509 if (temp2) delete arg2;
26510 }
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26516 PyObject *resultobj = 0;
26517 wxDateTime *arg1 = (wxDateTime *) 0 ;
26518 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26519 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26520 int result;
26521 void *argp1 = 0 ;
26522 int res1 = 0 ;
26523 bool temp2 = false ;
26524 PyObject * obj0 = 0 ;
26525 PyObject * obj1 = 0 ;
26526 char * kwnames[] = {
26527 (char *) "self",(char *) "tz", NULL
26528 };
26529
26530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26532 if (!SWIG_IsOK(res1)) {
26533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26534 }
26535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26536 if (obj1) {
26537 {
26538 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26539 temp2 = true;
26540 }
26541 }
26542 {
26543 PyThreadState* __tstate = wxPyBeginAllowThreads();
26544 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26545 wxPyEndAllowThreads(__tstate);
26546 if (PyErr_Occurred()) SWIG_fail;
26547 }
26548 resultobj = SWIG_From_int(static_cast< int >(result));
26549 {
26550 if (temp2) delete arg2;
26551 }
26552 return resultobj;
26553 fail:
26554 {
26555 if (temp2) delete arg2;
26556 }
26557 return NULL;
26558 }
26559
26560
26561 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26562 PyObject *resultobj = 0;
26563 wxDateTime *arg1 = (wxDateTime *) 0 ;
26564 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26565 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26566 int result;
26567 void *argp1 = 0 ;
26568 int res1 = 0 ;
26569 bool temp2 = false ;
26570 PyObject * obj0 = 0 ;
26571 PyObject * obj1 = 0 ;
26572 char * kwnames[] = {
26573 (char *) "self",(char *) "tz", NULL
26574 };
26575
26576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26578 if (!SWIG_IsOK(res1)) {
26579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26580 }
26581 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26582 if (obj1) {
26583 {
26584 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26585 temp2 = true;
26586 }
26587 }
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 resultobj = SWIG_From_int(static_cast< int >(result));
26595 {
26596 if (temp2) delete arg2;
26597 }
26598 return resultobj;
26599 fail:
26600 {
26601 if (temp2) delete arg2;
26602 }
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj = 0;
26609 wxDateTime *arg1 = (wxDateTime *) 0 ;
26610 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26611 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26612 int result;
26613 void *argp1 = 0 ;
26614 int res1 = 0 ;
26615 bool temp2 = false ;
26616 PyObject * obj0 = 0 ;
26617 PyObject * obj1 = 0 ;
26618 char * kwnames[] = {
26619 (char *) "self",(char *) "tz", NULL
26620 };
26621
26622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26624 if (!SWIG_IsOK(res1)) {
26625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26626 }
26627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26628 if (obj1) {
26629 {
26630 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26631 temp2 = true;
26632 }
26633 }
26634 {
26635 PyThreadState* __tstate = wxPyBeginAllowThreads();
26636 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26637 wxPyEndAllowThreads(__tstate);
26638 if (PyErr_Occurred()) SWIG_fail;
26639 }
26640 resultobj = SWIG_From_int(static_cast< int >(result));
26641 {
26642 if (temp2) delete arg2;
26643 }
26644 return resultobj;
26645 fail:
26646 {
26647 if (temp2) delete arg2;
26648 }
26649 return NULL;
26650 }
26651
26652
26653 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26654 PyObject *resultobj = 0;
26655 wxDateTime *arg1 = (wxDateTime *) 0 ;
26656 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26657 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26658 int result;
26659 void *argp1 = 0 ;
26660 int res1 = 0 ;
26661 bool temp2 = false ;
26662 PyObject * obj0 = 0 ;
26663 PyObject * obj1 = 0 ;
26664 char * kwnames[] = {
26665 (char *) "self",(char *) "tz", NULL
26666 };
26667
26668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26670 if (!SWIG_IsOK(res1)) {
26671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26672 }
26673 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26674 if (obj1) {
26675 {
26676 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26677 temp2 = true;
26678 }
26679 }
26680 {
26681 PyThreadState* __tstate = wxPyBeginAllowThreads();
26682 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 resultobj = SWIG_From_int(static_cast< int >(result));
26687 {
26688 if (temp2) delete arg2;
26689 }
26690 return resultobj;
26691 fail:
26692 {
26693 if (temp2) delete arg2;
26694 }
26695 return NULL;
26696 }
26697
26698
26699 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26700 PyObject *resultobj = 0;
26701 wxDateTime *arg1 = (wxDateTime *) 0 ;
26702 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26703 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26704 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26705 int result;
26706 void *argp1 = 0 ;
26707 int res1 = 0 ;
26708 int val2 ;
26709 int ecode2 = 0 ;
26710 bool temp3 = false ;
26711 PyObject * obj0 = 0 ;
26712 PyObject * obj1 = 0 ;
26713 PyObject * obj2 = 0 ;
26714 char * kwnames[] = {
26715 (char *) "self",(char *) "flags",(char *) "tz", NULL
26716 };
26717
26718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26720 if (!SWIG_IsOK(res1)) {
26721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26722 }
26723 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26724 if (obj1) {
26725 ecode2 = SWIG_AsVal_int(obj1, &val2);
26726 if (!SWIG_IsOK(ecode2)) {
26727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26728 }
26729 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26730 }
26731 if (obj2) {
26732 {
26733 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26734 temp3 = true;
26735 }
26736 }
26737 {
26738 PyThreadState* __tstate = wxPyBeginAllowThreads();
26739 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26740 wxPyEndAllowThreads(__tstate);
26741 if (PyErr_Occurred()) SWIG_fail;
26742 }
26743 resultobj = SWIG_From_int(static_cast< int >(result));
26744 {
26745 if (temp3) delete arg3;
26746 }
26747 return resultobj;
26748 fail:
26749 {
26750 if (temp3) delete arg3;
26751 }
26752 return NULL;
26753 }
26754
26755
26756 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26757 PyObject *resultobj = 0;
26758 wxDateTime *arg1 = (wxDateTime *) 0 ;
26759 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26760 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26761 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26762 int result;
26763 void *argp1 = 0 ;
26764 int res1 = 0 ;
26765 int val2 ;
26766 int ecode2 = 0 ;
26767 bool temp3 = false ;
26768 PyObject * obj0 = 0 ;
26769 PyObject * obj1 = 0 ;
26770 PyObject * obj2 = 0 ;
26771 char * kwnames[] = {
26772 (char *) "self",(char *) "flags",(char *) "tz", NULL
26773 };
26774
26775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26777 if (!SWIG_IsOK(res1)) {
26778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26779 }
26780 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26781 if (obj1) {
26782 ecode2 = SWIG_AsVal_int(obj1, &val2);
26783 if (!SWIG_IsOK(ecode2)) {
26784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26785 }
26786 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26787 }
26788 if (obj2) {
26789 {
26790 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26791 temp3 = true;
26792 }
26793 }
26794 {
26795 PyThreadState* __tstate = wxPyBeginAllowThreads();
26796 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26797 wxPyEndAllowThreads(__tstate);
26798 if (PyErr_Occurred()) SWIG_fail;
26799 }
26800 resultobj = SWIG_From_int(static_cast< int >(result));
26801 {
26802 if (temp3) delete arg3;
26803 }
26804 return resultobj;
26805 fail:
26806 {
26807 if (temp3) delete arg3;
26808 }
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26814 PyObject *resultobj = 0;
26815 wxDateTime *arg1 = (wxDateTime *) 0 ;
26816 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26817 bool result;
26818 void *argp1 = 0 ;
26819 int res1 = 0 ;
26820 int val2 ;
26821 int ecode2 = 0 ;
26822 PyObject * obj0 = 0 ;
26823 PyObject * obj1 = 0 ;
26824 char * kwnames[] = {
26825 (char *) "self",(char *) "country", NULL
26826 };
26827
26828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26830 if (!SWIG_IsOK(res1)) {
26831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26832 }
26833 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26834 if (obj1) {
26835 ecode2 = SWIG_AsVal_int(obj1, &val2);
26836 if (!SWIG_IsOK(ecode2)) {
26837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26838 }
26839 arg2 = static_cast< wxDateTime::Country >(val2);
26840 }
26841 {
26842 PyThreadState* __tstate = wxPyBeginAllowThreads();
26843 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26844 wxPyEndAllowThreads(__tstate);
26845 if (PyErr_Occurred()) SWIG_fail;
26846 }
26847 {
26848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26849 }
26850 return resultobj;
26851 fail:
26852 return NULL;
26853 }
26854
26855
26856 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26857 PyObject *resultobj = 0;
26858 wxDateTime *arg1 = (wxDateTime *) 0 ;
26859 wxDateTime *arg2 = 0 ;
26860 bool result;
26861 void *argp1 = 0 ;
26862 int res1 = 0 ;
26863 void *argp2 = 0 ;
26864 int res2 = 0 ;
26865 PyObject * obj0 = 0 ;
26866 PyObject * obj1 = 0 ;
26867 char * kwnames[] = {
26868 (char *) "self",(char *) "datetime", NULL
26869 };
26870
26871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26873 if (!SWIG_IsOK(res1)) {
26874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26875 }
26876 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26877 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26878 if (!SWIG_IsOK(res2)) {
26879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26880 }
26881 if (!argp2) {
26882 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26883 }
26884 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26888 wxPyEndAllowThreads(__tstate);
26889 if (PyErr_Occurred()) SWIG_fail;
26890 }
26891 {
26892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26893 }
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj = 0;
26902 wxDateTime *arg1 = (wxDateTime *) 0 ;
26903 wxDateTime *arg2 = 0 ;
26904 bool result;
26905 void *argp1 = 0 ;
26906 int res1 = 0 ;
26907 void *argp2 = 0 ;
26908 int res2 = 0 ;
26909 PyObject * obj0 = 0 ;
26910 PyObject * obj1 = 0 ;
26911 char * kwnames[] = {
26912 (char *) "self",(char *) "datetime", NULL
26913 };
26914
26915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26917 if (!SWIG_IsOK(res1)) {
26918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26919 }
26920 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26921 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26922 if (!SWIG_IsOK(res2)) {
26923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26924 }
26925 if (!argp2) {
26926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26927 }
26928 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 {
26936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26937 }
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26945 PyObject *resultobj = 0;
26946 wxDateTime *arg1 = (wxDateTime *) 0 ;
26947 wxDateTime *arg2 = 0 ;
26948 bool result;
26949 void *argp1 = 0 ;
26950 int res1 = 0 ;
26951 void *argp2 = 0 ;
26952 int res2 = 0 ;
26953 PyObject * obj0 = 0 ;
26954 PyObject * obj1 = 0 ;
26955 char * kwnames[] = {
26956 (char *) "self",(char *) "datetime", NULL
26957 };
26958
26959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26961 if (!SWIG_IsOK(res1)) {
26962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26963 }
26964 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26965 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26966 if (!SWIG_IsOK(res2)) {
26967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26968 }
26969 if (!argp2) {
26970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26971 }
26972 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26973 {
26974 PyThreadState* __tstate = wxPyBeginAllowThreads();
26975 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26976 wxPyEndAllowThreads(__tstate);
26977 if (PyErr_Occurred()) SWIG_fail;
26978 }
26979 {
26980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26981 }
26982 return resultobj;
26983 fail:
26984 return NULL;
26985 }
26986
26987
26988 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26989 PyObject *resultobj = 0;
26990 wxDateTime *arg1 = (wxDateTime *) 0 ;
26991 wxDateTime *arg2 = 0 ;
26992 wxDateTime *arg3 = 0 ;
26993 bool result;
26994 void *argp1 = 0 ;
26995 int res1 = 0 ;
26996 void *argp2 = 0 ;
26997 int res2 = 0 ;
26998 void *argp3 = 0 ;
26999 int res3 = 0 ;
27000 PyObject * obj0 = 0 ;
27001 PyObject * obj1 = 0 ;
27002 PyObject * obj2 = 0 ;
27003 char * kwnames[] = {
27004 (char *) "self",(char *) "t1",(char *) "t2", NULL
27005 };
27006
27007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27009 if (!SWIG_IsOK(res1)) {
27010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27011 }
27012 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27013 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27014 if (!SWIG_IsOK(res2)) {
27015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27016 }
27017 if (!argp2) {
27018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27019 }
27020 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27021 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27022 if (!SWIG_IsOK(res3)) {
27023 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27024 }
27025 if (!argp3) {
27026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27027 }
27028 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27032 wxPyEndAllowThreads(__tstate);
27033 if (PyErr_Occurred()) SWIG_fail;
27034 }
27035 {
27036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27037 }
27038 return resultobj;
27039 fail:
27040 return NULL;
27041 }
27042
27043
27044 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27045 PyObject *resultobj = 0;
27046 wxDateTime *arg1 = (wxDateTime *) 0 ;
27047 wxDateTime *arg2 = 0 ;
27048 wxDateTime *arg3 = 0 ;
27049 bool result;
27050 void *argp1 = 0 ;
27051 int res1 = 0 ;
27052 void *argp2 = 0 ;
27053 int res2 = 0 ;
27054 void *argp3 = 0 ;
27055 int res3 = 0 ;
27056 PyObject * obj0 = 0 ;
27057 PyObject * obj1 = 0 ;
27058 PyObject * obj2 = 0 ;
27059 char * kwnames[] = {
27060 (char *) "self",(char *) "t1",(char *) "t2", NULL
27061 };
27062
27063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27065 if (!SWIG_IsOK(res1)) {
27066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27067 }
27068 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27069 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27070 if (!SWIG_IsOK(res2)) {
27071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27072 }
27073 if (!argp2) {
27074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27075 }
27076 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27077 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27078 if (!SWIG_IsOK(res3)) {
27079 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27080 }
27081 if (!argp3) {
27082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27083 }
27084 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 {
27092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27093 }
27094 return resultobj;
27095 fail:
27096 return NULL;
27097 }
27098
27099
27100 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27101 PyObject *resultobj = 0;
27102 wxDateTime *arg1 = (wxDateTime *) 0 ;
27103 wxDateTime *arg2 = 0 ;
27104 bool result;
27105 void *argp1 = 0 ;
27106 int res1 = 0 ;
27107 void *argp2 = 0 ;
27108 int res2 = 0 ;
27109 PyObject * obj0 = 0 ;
27110 PyObject * obj1 = 0 ;
27111 char * kwnames[] = {
27112 (char *) "self",(char *) "dt", NULL
27113 };
27114
27115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27117 if (!SWIG_IsOK(res1)) {
27118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27119 }
27120 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27121 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27122 if (!SWIG_IsOK(res2)) {
27123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27124 }
27125 if (!argp2) {
27126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27127 }
27128 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27129 {
27130 PyThreadState* __tstate = wxPyBeginAllowThreads();
27131 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27132 wxPyEndAllowThreads(__tstate);
27133 if (PyErr_Occurred()) SWIG_fail;
27134 }
27135 {
27136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27137 }
27138 return resultobj;
27139 fail:
27140 return NULL;
27141 }
27142
27143
27144 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj = 0;
27146 wxDateTime *arg1 = (wxDateTime *) 0 ;
27147 wxDateTime *arg2 = 0 ;
27148 bool result;
27149 void *argp1 = 0 ;
27150 int res1 = 0 ;
27151 void *argp2 = 0 ;
27152 int res2 = 0 ;
27153 PyObject * obj0 = 0 ;
27154 PyObject * obj1 = 0 ;
27155 char * kwnames[] = {
27156 (char *) "self",(char *) "dt", NULL
27157 };
27158
27159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27161 if (!SWIG_IsOK(res1)) {
27162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27163 }
27164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27165 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27166 if (!SWIG_IsOK(res2)) {
27167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27168 }
27169 if (!argp2) {
27170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27171 }
27172 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27176 wxPyEndAllowThreads(__tstate);
27177 if (PyErr_Occurred()) SWIG_fail;
27178 }
27179 {
27180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27181 }
27182 return resultobj;
27183 fail:
27184 return NULL;
27185 }
27186
27187
27188 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27189 PyObject *resultobj = 0;
27190 wxDateTime *arg1 = (wxDateTime *) 0 ;
27191 wxDateTime *arg2 = 0 ;
27192 wxTimeSpan *arg3 = 0 ;
27193 bool result;
27194 void *argp1 = 0 ;
27195 int res1 = 0 ;
27196 void *argp2 = 0 ;
27197 int res2 = 0 ;
27198 void *argp3 = 0 ;
27199 int res3 = 0 ;
27200 PyObject * obj0 = 0 ;
27201 PyObject * obj1 = 0 ;
27202 PyObject * obj2 = 0 ;
27203 char * kwnames[] = {
27204 (char *) "self",(char *) "dt",(char *) "ts", NULL
27205 };
27206
27207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27209 if (!SWIG_IsOK(res1)) {
27210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27211 }
27212 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27213 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27214 if (!SWIG_IsOK(res2)) {
27215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27216 }
27217 if (!argp2) {
27218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27219 }
27220 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27221 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27222 if (!SWIG_IsOK(res3)) {
27223 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27224 }
27225 if (!argp3) {
27226 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27227 }
27228 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 {
27236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27237 }
27238 return resultobj;
27239 fail:
27240 return NULL;
27241 }
27242
27243
27244 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27245 PyObject *resultobj = 0;
27246 wxDateTime *arg1 = (wxDateTime *) 0 ;
27247 wxTimeSpan *arg2 = 0 ;
27248 wxDateTime *result = 0 ;
27249 void *argp1 = 0 ;
27250 int res1 = 0 ;
27251 void *argp2 = 0 ;
27252 int res2 = 0 ;
27253 PyObject * obj0 = 0 ;
27254 PyObject * obj1 = 0 ;
27255 char * kwnames[] = {
27256 (char *) "self",(char *) "diff", NULL
27257 };
27258
27259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27261 if (!SWIG_IsOK(res1)) {
27262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27263 }
27264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27265 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27266 if (!SWIG_IsOK(res2)) {
27267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27268 }
27269 if (!argp2) {
27270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27271 }
27272 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 {
27276 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27277 result = (wxDateTime *) &_result_ref;
27278 }
27279 wxPyEndAllowThreads(__tstate);
27280 if (PyErr_Occurred()) SWIG_fail;
27281 }
27282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27283 return resultobj;
27284 fail:
27285 return NULL;
27286 }
27287
27288
27289 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27290 PyObject *resultobj = 0;
27291 wxDateTime *arg1 = (wxDateTime *) 0 ;
27292 wxDateSpan *arg2 = 0 ;
27293 wxDateTime *result = 0 ;
27294 void *argp1 = 0 ;
27295 int res1 = 0 ;
27296 void *argp2 = 0 ;
27297 int res2 = 0 ;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 char * kwnames[] = {
27301 (char *) "self",(char *) "diff", NULL
27302 };
27303
27304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27306 if (!SWIG_IsOK(res1)) {
27307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27308 }
27309 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27310 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27311 if (!SWIG_IsOK(res2)) {
27312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27313 }
27314 if (!argp2) {
27315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27316 }
27317 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 {
27321 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27322 result = (wxDateTime *) &_result_ref;
27323 }
27324 wxPyEndAllowThreads(__tstate);
27325 if (PyErr_Occurred()) SWIG_fail;
27326 }
27327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27328 return resultobj;
27329 fail:
27330 return NULL;
27331 }
27332
27333
27334 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27335 PyObject *resultobj = 0;
27336 wxDateTime *arg1 = (wxDateTime *) 0 ;
27337 wxTimeSpan *arg2 = 0 ;
27338 wxDateTime *result = 0 ;
27339 void *argp1 = 0 ;
27340 int res1 = 0 ;
27341 void *argp2 = 0 ;
27342 int res2 = 0 ;
27343 PyObject * obj0 = 0 ;
27344 PyObject * obj1 = 0 ;
27345 char * kwnames[] = {
27346 (char *) "self",(char *) "diff", NULL
27347 };
27348
27349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27351 if (!SWIG_IsOK(res1)) {
27352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27353 }
27354 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27356 if (!SWIG_IsOK(res2)) {
27357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27358 }
27359 if (!argp2) {
27360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27361 }
27362 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 {
27366 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27367 result = (wxDateTime *) &_result_ref;
27368 }
27369 wxPyEndAllowThreads(__tstate);
27370 if (PyErr_Occurred()) SWIG_fail;
27371 }
27372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27380 PyObject *resultobj = 0;
27381 wxDateTime *arg1 = (wxDateTime *) 0 ;
27382 wxDateSpan *arg2 = 0 ;
27383 wxDateTime *result = 0 ;
27384 void *argp1 = 0 ;
27385 int res1 = 0 ;
27386 void *argp2 = 0 ;
27387 int res2 = 0 ;
27388 PyObject * obj0 = 0 ;
27389 PyObject * obj1 = 0 ;
27390 char * kwnames[] = {
27391 (char *) "self",(char *) "diff", NULL
27392 };
27393
27394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27396 if (!SWIG_IsOK(res1)) {
27397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27398 }
27399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27400 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27401 if (!SWIG_IsOK(res2)) {
27402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27403 }
27404 if (!argp2) {
27405 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27406 }
27407 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27408 {
27409 PyThreadState* __tstate = wxPyBeginAllowThreads();
27410 {
27411 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27412 result = (wxDateTime *) &_result_ref;
27413 }
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27418 return resultobj;
27419 fail:
27420 return NULL;
27421 }
27422
27423
27424 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27425 PyObject *resultobj = 0;
27426 wxDateTime *arg1 = (wxDateTime *) 0 ;
27427 wxDateTime *arg2 = 0 ;
27428 wxTimeSpan result;
27429 void *argp1 = 0 ;
27430 int res1 = 0 ;
27431 void *argp2 = 0 ;
27432 int res2 = 0 ;
27433 PyObject * obj0 = 0 ;
27434 PyObject * obj1 = 0 ;
27435 char * kwnames[] = {
27436 (char *) "self",(char *) "dt", NULL
27437 };
27438
27439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27441 if (!SWIG_IsOK(res1)) {
27442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27443 }
27444 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27445 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27446 if (!SWIG_IsOK(res2)) {
27447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27448 }
27449 if (!argp2) {
27450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27451 }
27452 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27460 return resultobj;
27461 fail:
27462 return NULL;
27463 }
27464
27465
27466 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27467 PyObject *resultobj = 0;
27468 wxDateTime *arg1 = (wxDateTime *) 0 ;
27469 wxTimeSpan *arg2 = 0 ;
27470 wxDateTime *result = 0 ;
27471 void *argp1 = 0 ;
27472 int res1 = 0 ;
27473 void *argp2 = 0 ;
27474 int res2 = 0 ;
27475
27476 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27478 if (!SWIG_IsOK(res1)) {
27479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27480 }
27481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27482 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27483 if (!SWIG_IsOK(res2)) {
27484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27485 }
27486 if (!argp2) {
27487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27488 }
27489 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 {
27493 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27494 result = (wxDateTime *) &_result_ref;
27495 }
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27500 return resultobj;
27501 fail:
27502 return NULL;
27503 }
27504
27505
27506 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27507 PyObject *resultobj = 0;
27508 wxDateTime *arg1 = (wxDateTime *) 0 ;
27509 wxDateSpan *arg2 = 0 ;
27510 wxDateTime *result = 0 ;
27511 void *argp1 = 0 ;
27512 int res1 = 0 ;
27513 void *argp2 = 0 ;
27514 int res2 = 0 ;
27515
27516 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27518 if (!SWIG_IsOK(res1)) {
27519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27520 }
27521 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27522 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27523 if (!SWIG_IsOK(res2)) {
27524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27525 }
27526 if (!argp2) {
27527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27528 }
27529 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27530 {
27531 PyThreadState* __tstate = wxPyBeginAllowThreads();
27532 {
27533 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27534 result = (wxDateTime *) &_result_ref;
27535 }
27536 wxPyEndAllowThreads(__tstate);
27537 if (PyErr_Occurred()) SWIG_fail;
27538 }
27539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27540 return resultobj;
27541 fail:
27542 return NULL;
27543 }
27544
27545
27546 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27547 int argc;
27548 PyObject *argv[3];
27549
27550 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27551 --argc;
27552 if (argc == 2) {
27553 int _v = 0;
27554 {
27555 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27556 _v = SWIG_CheckState(res);
27557 }
27558 if (!_v) goto check_1;
27559 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27560 }
27561 check_1:
27562
27563 if (argc == 2) {
27564 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27565 }
27566
27567 fail:
27568 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27569 return NULL;
27570 }
27571
27572
27573 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27574 PyObject *resultobj = 0;
27575 wxDateTime *arg1 = (wxDateTime *) 0 ;
27576 wxTimeSpan *arg2 = 0 ;
27577 wxDateTime *result = 0 ;
27578 void *argp1 = 0 ;
27579 int res1 = 0 ;
27580 void *argp2 = 0 ;
27581 int res2 = 0 ;
27582
27583 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27585 if (!SWIG_IsOK(res1)) {
27586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27587 }
27588 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27589 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27590 if (!SWIG_IsOK(res2)) {
27591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27592 }
27593 if (!argp2) {
27594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27595 }
27596 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 {
27600 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27601 result = (wxDateTime *) &_result_ref;
27602 }
27603 wxPyEndAllowThreads(__tstate);
27604 if (PyErr_Occurred()) SWIG_fail;
27605 }
27606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27614 PyObject *resultobj = 0;
27615 wxDateTime *arg1 = (wxDateTime *) 0 ;
27616 wxDateSpan *arg2 = 0 ;
27617 wxDateTime *result = 0 ;
27618 void *argp1 = 0 ;
27619 int res1 = 0 ;
27620 void *argp2 = 0 ;
27621 int res2 = 0 ;
27622
27623 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27625 if (!SWIG_IsOK(res1)) {
27626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27627 }
27628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27629 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27630 if (!SWIG_IsOK(res2)) {
27631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27632 }
27633 if (!argp2) {
27634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27635 }
27636 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27637 {
27638 PyThreadState* __tstate = wxPyBeginAllowThreads();
27639 {
27640 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27641 result = (wxDateTime *) &_result_ref;
27642 }
27643 wxPyEndAllowThreads(__tstate);
27644 if (PyErr_Occurred()) SWIG_fail;
27645 }
27646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27647 return resultobj;
27648 fail:
27649 return NULL;
27650 }
27651
27652
27653 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27654 int argc;
27655 PyObject *argv[3];
27656
27657 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27658 --argc;
27659 if (argc == 2) {
27660 int _v = 0;
27661 {
27662 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27663 _v = SWIG_CheckState(res);
27664 }
27665 if (!_v) goto check_1;
27666 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27667 }
27668 check_1:
27669
27670 if (argc == 2) {
27671 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27672 }
27673
27674 fail:
27675 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27676 return NULL;
27677 }
27678
27679
27680 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27681 PyObject *resultobj = 0;
27682 wxDateTime *arg1 = (wxDateTime *) 0 ;
27683 wxTimeSpan *arg2 = 0 ;
27684 wxDateTime result;
27685 void *argp1 = 0 ;
27686 int res1 = 0 ;
27687 void *argp2 = 0 ;
27688 int res2 = 0 ;
27689
27690 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27692 if (!SWIG_IsOK(res1)) {
27693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27694 }
27695 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27696 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27697 if (!SWIG_IsOK(res2)) {
27698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27699 }
27700 if (!argp2) {
27701 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27702 }
27703 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27704 {
27705 PyThreadState* __tstate = wxPyBeginAllowThreads();
27706 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27707 wxPyEndAllowThreads(__tstate);
27708 if (PyErr_Occurred()) SWIG_fail;
27709 }
27710 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27711 return resultobj;
27712 fail:
27713 return NULL;
27714 }
27715
27716
27717 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27718 PyObject *resultobj = 0;
27719 wxDateTime *arg1 = (wxDateTime *) 0 ;
27720 wxDateSpan *arg2 = 0 ;
27721 wxDateTime result;
27722 void *argp1 = 0 ;
27723 int res1 = 0 ;
27724 void *argp2 = 0 ;
27725 int res2 = 0 ;
27726
27727 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27729 if (!SWIG_IsOK(res1)) {
27730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27731 }
27732 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27733 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27734 if (!SWIG_IsOK(res2)) {
27735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27736 }
27737 if (!argp2) {
27738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27739 }
27740 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27755 int argc;
27756 PyObject *argv[3];
27757
27758 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27759 --argc;
27760 if (argc == 2) {
27761 int _v = 0;
27762 {
27763 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27764 _v = SWIG_CheckState(res);
27765 }
27766 if (!_v) goto check_1;
27767 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27768 }
27769 check_1:
27770
27771 if (argc == 2) {
27772 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27773 }
27774
27775 fail:
27776 Py_INCREF(Py_NotImplemented);
27777 return Py_NotImplemented;
27778 }
27779
27780
27781 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27782 PyObject *resultobj = 0;
27783 wxDateTime *arg1 = (wxDateTime *) 0 ;
27784 wxDateTime *arg2 = 0 ;
27785 wxTimeSpan result;
27786 void *argp1 = 0 ;
27787 int res1 = 0 ;
27788 void *argp2 = 0 ;
27789 int res2 = 0 ;
27790
27791 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27793 if (!SWIG_IsOK(res1)) {
27794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27795 }
27796 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27797 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27798 if (!SWIG_IsOK(res2)) {
27799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27800 }
27801 if (!argp2) {
27802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27803 }
27804 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27819 PyObject *resultobj = 0;
27820 wxDateTime *arg1 = (wxDateTime *) 0 ;
27821 wxTimeSpan *arg2 = 0 ;
27822 wxDateTime result;
27823 void *argp1 = 0 ;
27824 int res1 = 0 ;
27825 void *argp2 = 0 ;
27826 int res2 = 0 ;
27827
27828 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27830 if (!SWIG_IsOK(res1)) {
27831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27832 }
27833 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27834 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27835 if (!SWIG_IsOK(res2)) {
27836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27837 }
27838 if (!argp2) {
27839 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27840 }
27841 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27856 PyObject *resultobj = 0;
27857 wxDateTime *arg1 = (wxDateTime *) 0 ;
27858 wxDateSpan *arg2 = 0 ;
27859 wxDateTime result;
27860 void *argp1 = 0 ;
27861 int res1 = 0 ;
27862 void *argp2 = 0 ;
27863 int res2 = 0 ;
27864
27865 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27867 if (!SWIG_IsOK(res1)) {
27868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27869 }
27870 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27871 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27872 if (!SWIG_IsOK(res2)) {
27873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27874 }
27875 if (!argp2) {
27876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27877 }
27878 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27879 {
27880 PyThreadState* __tstate = wxPyBeginAllowThreads();
27881 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27882 wxPyEndAllowThreads(__tstate);
27883 if (PyErr_Occurred()) SWIG_fail;
27884 }
27885 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27886 return resultobj;
27887 fail:
27888 return NULL;
27889 }
27890
27891
27892 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27893 int argc;
27894 PyObject *argv[3];
27895
27896 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27897 --argc;
27898 if (argc == 2) {
27899 int _v = 0;
27900 {
27901 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27902 _v = SWIG_CheckState(res);
27903 }
27904 if (!_v) goto check_1;
27905 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27906 }
27907 check_1:
27908
27909 if (argc == 2) {
27910 int _v = 0;
27911 {
27912 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27913 _v = SWIG_CheckState(res);
27914 }
27915 if (!_v) goto check_2;
27916 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27917 }
27918 check_2:
27919
27920 if (argc == 2) {
27921 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27922 }
27923
27924 fail:
27925 Py_INCREF(Py_NotImplemented);
27926 return Py_NotImplemented;
27927 }
27928
27929
27930 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27931 PyObject *resultobj = 0;
27932 wxDateTime *arg1 = (wxDateTime *) 0 ;
27933 wxDateTime *arg2 = (wxDateTime *) 0 ;
27934 bool result;
27935 void *argp1 = 0 ;
27936 int res1 = 0 ;
27937 void *argp2 = 0 ;
27938 int res2 = 0 ;
27939 PyObject * obj0 = 0 ;
27940 PyObject * obj1 = 0 ;
27941 char * kwnames[] = {
27942 (char *) "self",(char *) "other", NULL
27943 };
27944
27945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27947 if (!SWIG_IsOK(res1)) {
27948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27949 }
27950 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27952 if (!SWIG_IsOK(res2)) {
27953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27954 }
27955 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27956 {
27957 PyThreadState* __tstate = wxPyBeginAllowThreads();
27958 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27959 wxPyEndAllowThreads(__tstate);
27960 if (PyErr_Occurred()) SWIG_fail;
27961 }
27962 {
27963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27964 }
27965 return resultobj;
27966 fail:
27967 return NULL;
27968 }
27969
27970
27971 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27972 PyObject *resultobj = 0;
27973 wxDateTime *arg1 = (wxDateTime *) 0 ;
27974 wxDateTime *arg2 = (wxDateTime *) 0 ;
27975 bool result;
27976 void *argp1 = 0 ;
27977 int res1 = 0 ;
27978 void *argp2 = 0 ;
27979 int res2 = 0 ;
27980 PyObject * obj0 = 0 ;
27981 PyObject * obj1 = 0 ;
27982 char * kwnames[] = {
27983 (char *) "self",(char *) "other", NULL
27984 };
27985
27986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27988 if (!SWIG_IsOK(res1)) {
27989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27990 }
27991 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27993 if (!SWIG_IsOK(res2)) {
27994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27995 }
27996 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27997 {
27998 PyThreadState* __tstate = wxPyBeginAllowThreads();
27999 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 {
28004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28005 }
28006 return resultobj;
28007 fail:
28008 return NULL;
28009 }
28010
28011
28012 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28013 PyObject *resultobj = 0;
28014 wxDateTime *arg1 = (wxDateTime *) 0 ;
28015 wxDateTime *arg2 = (wxDateTime *) 0 ;
28016 bool result;
28017 void *argp1 = 0 ;
28018 int res1 = 0 ;
28019 void *argp2 = 0 ;
28020 int res2 = 0 ;
28021 PyObject * obj0 = 0 ;
28022 PyObject * obj1 = 0 ;
28023 char * kwnames[] = {
28024 (char *) "self",(char *) "other", NULL
28025 };
28026
28027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28029 if (!SWIG_IsOK(res1)) {
28030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28031 }
28032 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28034 if (!SWIG_IsOK(res2)) {
28035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28036 }
28037 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28038 {
28039 PyThreadState* __tstate = wxPyBeginAllowThreads();
28040 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 {
28045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28046 }
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28054 PyObject *resultobj = 0;
28055 wxDateTime *arg1 = (wxDateTime *) 0 ;
28056 wxDateTime *arg2 = (wxDateTime *) 0 ;
28057 bool result;
28058 void *argp1 = 0 ;
28059 int res1 = 0 ;
28060 void *argp2 = 0 ;
28061 int res2 = 0 ;
28062 PyObject * obj0 = 0 ;
28063 PyObject * obj1 = 0 ;
28064 char * kwnames[] = {
28065 (char *) "self",(char *) "other", NULL
28066 };
28067
28068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28070 if (!SWIG_IsOK(res1)) {
28071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28072 }
28073 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28074 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28075 if (!SWIG_IsOK(res2)) {
28076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28077 }
28078 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 {
28086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28087 }
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28095 PyObject *resultobj = 0;
28096 wxDateTime *arg1 = (wxDateTime *) 0 ;
28097 wxDateTime *arg2 = (wxDateTime *) 0 ;
28098 bool result;
28099 void *argp1 = 0 ;
28100 int res1 = 0 ;
28101 void *argp2 = 0 ;
28102 int res2 = 0 ;
28103 PyObject * obj0 = 0 ;
28104 PyObject * obj1 = 0 ;
28105 char * kwnames[] = {
28106 (char *) "self",(char *) "other", NULL
28107 };
28108
28109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28111 if (!SWIG_IsOK(res1)) {
28112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28113 }
28114 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28115 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28116 if (!SWIG_IsOK(res2)) {
28117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28118 }
28119 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28123 wxPyEndAllowThreads(__tstate);
28124 if (PyErr_Occurred()) SWIG_fail;
28125 }
28126 {
28127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28128 }
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj = 0;
28137 wxDateTime *arg1 = (wxDateTime *) 0 ;
28138 wxDateTime *arg2 = (wxDateTime *) 0 ;
28139 bool result;
28140 void *argp1 = 0 ;
28141 int res1 = 0 ;
28142 void *argp2 = 0 ;
28143 int res2 = 0 ;
28144 PyObject * obj0 = 0 ;
28145 PyObject * obj1 = 0 ;
28146 char * kwnames[] = {
28147 (char *) "self",(char *) "other", NULL
28148 };
28149
28150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28152 if (!SWIG_IsOK(res1)) {
28153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28154 }
28155 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28157 if (!SWIG_IsOK(res2)) {
28158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28159 }
28160 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28161 {
28162 PyThreadState* __tstate = wxPyBeginAllowThreads();
28163 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28164 wxPyEndAllowThreads(__tstate);
28165 if (PyErr_Occurred()) SWIG_fail;
28166 }
28167 {
28168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28169 }
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj = 0;
28178 wxDateTime *arg1 = (wxDateTime *) 0 ;
28179 wxString *arg2 = 0 ;
28180 int result;
28181 void *argp1 = 0 ;
28182 int res1 = 0 ;
28183 bool temp2 = false ;
28184 PyObject * obj0 = 0 ;
28185 PyObject * obj1 = 0 ;
28186 char * kwnames[] = {
28187 (char *) "self",(char *) "date", NULL
28188 };
28189
28190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28192 if (!SWIG_IsOK(res1)) {
28193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28194 }
28195 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28196 {
28197 arg2 = wxString_in_helper(obj1);
28198 if (arg2 == NULL) SWIG_fail;
28199 temp2 = true;
28200 }
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 resultobj = SWIG_From_int(static_cast< int >(result));
28208 {
28209 if (temp2)
28210 delete arg2;
28211 }
28212 return resultobj;
28213 fail:
28214 {
28215 if (temp2)
28216 delete arg2;
28217 }
28218 return NULL;
28219 }
28220
28221
28222 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28223 PyObject *resultobj = 0;
28224 wxDateTime *arg1 = (wxDateTime *) 0 ;
28225 wxString *arg2 = 0 ;
28226 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28227 wxString *arg3 = (wxString *) &arg3_defvalue ;
28228 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28229 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28230 int result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 bool temp2 = false ;
28234 bool temp3 = false ;
28235 void *argp4 = 0 ;
28236 int res4 = 0 ;
28237 PyObject * obj0 = 0 ;
28238 PyObject * obj1 = 0 ;
28239 PyObject * obj2 = 0 ;
28240 PyObject * obj3 = 0 ;
28241 char * kwnames[] = {
28242 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28243 };
28244
28245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28247 if (!SWIG_IsOK(res1)) {
28248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28249 }
28250 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28251 {
28252 arg2 = wxString_in_helper(obj1);
28253 if (arg2 == NULL) SWIG_fail;
28254 temp2 = true;
28255 }
28256 if (obj2) {
28257 {
28258 arg3 = wxString_in_helper(obj2);
28259 if (arg3 == NULL) SWIG_fail;
28260 temp3 = true;
28261 }
28262 }
28263 if (obj3) {
28264 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28265 if (!SWIG_IsOK(res4)) {
28266 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28267 }
28268 if (!argp4) {
28269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28270 }
28271 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28272 }
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 resultobj = SWIG_From_int(static_cast< int >(result));
28280 {
28281 if (temp2)
28282 delete arg2;
28283 }
28284 {
28285 if (temp3)
28286 delete arg3;
28287 }
28288 return resultobj;
28289 fail:
28290 {
28291 if (temp2)
28292 delete arg2;
28293 }
28294 {
28295 if (temp3)
28296 delete arg3;
28297 }
28298 return NULL;
28299 }
28300
28301
28302 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28303 PyObject *resultobj = 0;
28304 wxDateTime *arg1 = (wxDateTime *) 0 ;
28305 wxString *arg2 = 0 ;
28306 int result;
28307 void *argp1 = 0 ;
28308 int res1 = 0 ;
28309 bool temp2 = false ;
28310 PyObject * obj0 = 0 ;
28311 PyObject * obj1 = 0 ;
28312 char * kwnames[] = {
28313 (char *) "self",(char *) "datetime", NULL
28314 };
28315
28316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28318 if (!SWIG_IsOK(res1)) {
28319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28320 }
28321 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28322 {
28323 arg2 = wxString_in_helper(obj1);
28324 if (arg2 == NULL) SWIG_fail;
28325 temp2 = true;
28326 }
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 resultobj = SWIG_From_int(static_cast< int >(result));
28334 {
28335 if (temp2)
28336 delete arg2;
28337 }
28338 return resultobj;
28339 fail:
28340 {
28341 if (temp2)
28342 delete arg2;
28343 }
28344 return NULL;
28345 }
28346
28347
28348 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj = 0;
28350 wxDateTime *arg1 = (wxDateTime *) 0 ;
28351 wxString *arg2 = 0 ;
28352 int result;
28353 void *argp1 = 0 ;
28354 int res1 = 0 ;
28355 bool temp2 = false ;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 char * kwnames[] = {
28359 (char *) "self",(char *) "date", NULL
28360 };
28361
28362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28364 if (!SWIG_IsOK(res1)) {
28365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28366 }
28367 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28368 {
28369 arg2 = wxString_in_helper(obj1);
28370 if (arg2 == NULL) SWIG_fail;
28371 temp2 = true;
28372 }
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 resultobj = SWIG_From_int(static_cast< int >(result));
28380 {
28381 if (temp2)
28382 delete arg2;
28383 }
28384 return resultobj;
28385 fail:
28386 {
28387 if (temp2)
28388 delete arg2;
28389 }
28390 return NULL;
28391 }
28392
28393
28394 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28395 PyObject *resultobj = 0;
28396 wxDateTime *arg1 = (wxDateTime *) 0 ;
28397 wxString *arg2 = 0 ;
28398 int result;
28399 void *argp1 = 0 ;
28400 int res1 = 0 ;
28401 bool temp2 = false ;
28402 PyObject * obj0 = 0 ;
28403 PyObject * obj1 = 0 ;
28404 char * kwnames[] = {
28405 (char *) "self",(char *) "time", NULL
28406 };
28407
28408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28410 if (!SWIG_IsOK(res1)) {
28411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28412 }
28413 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28414 {
28415 arg2 = wxString_in_helper(obj1);
28416 if (arg2 == NULL) SWIG_fail;
28417 temp2 = true;
28418 }
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28422 wxPyEndAllowThreads(__tstate);
28423 if (PyErr_Occurred()) SWIG_fail;
28424 }
28425 resultobj = SWIG_From_int(static_cast< int >(result));
28426 {
28427 if (temp2)
28428 delete arg2;
28429 }
28430 return resultobj;
28431 fail:
28432 {
28433 if (temp2)
28434 delete arg2;
28435 }
28436 return NULL;
28437 }
28438
28439
28440 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28441 PyObject *resultobj = 0;
28442 wxDateTime *arg1 = (wxDateTime *) 0 ;
28443 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28444 wxString *arg2 = (wxString *) &arg2_defvalue ;
28445 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28446 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28447 wxString result;
28448 void *argp1 = 0 ;
28449 int res1 = 0 ;
28450 bool temp2 = false ;
28451 bool temp3 = false ;
28452 PyObject * obj0 = 0 ;
28453 PyObject * obj1 = 0 ;
28454 PyObject * obj2 = 0 ;
28455 char * kwnames[] = {
28456 (char *) "self",(char *) "format",(char *) "tz", NULL
28457 };
28458
28459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28461 if (!SWIG_IsOK(res1)) {
28462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28463 }
28464 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28465 if (obj1) {
28466 {
28467 arg2 = wxString_in_helper(obj1);
28468 if (arg2 == NULL) SWIG_fail;
28469 temp2 = true;
28470 }
28471 }
28472 if (obj2) {
28473 {
28474 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28475 temp3 = true;
28476 }
28477 }
28478 {
28479 PyThreadState* __tstate = wxPyBeginAllowThreads();
28480 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28481 wxPyEndAllowThreads(__tstate);
28482 if (PyErr_Occurred()) SWIG_fail;
28483 }
28484 {
28485 #if wxUSE_UNICODE
28486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28487 #else
28488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28489 #endif
28490 }
28491 {
28492 if (temp2)
28493 delete arg2;
28494 }
28495 {
28496 if (temp3) delete arg3;
28497 }
28498 return resultobj;
28499 fail:
28500 {
28501 if (temp2)
28502 delete arg2;
28503 }
28504 {
28505 if (temp3) delete arg3;
28506 }
28507 return NULL;
28508 }
28509
28510
28511 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28512 PyObject *resultobj = 0;
28513 wxDateTime *arg1 = (wxDateTime *) 0 ;
28514 wxString result;
28515 void *argp1 = 0 ;
28516 int res1 = 0 ;
28517 PyObject *swig_obj[1] ;
28518
28519 if (!args) SWIG_fail;
28520 swig_obj[0] = args;
28521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28522 if (!SWIG_IsOK(res1)) {
28523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28524 }
28525 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28526 {
28527 PyThreadState* __tstate = wxPyBeginAllowThreads();
28528 result = ((wxDateTime const *)arg1)->FormatDate();
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 {
28533 #if wxUSE_UNICODE
28534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28535 #else
28536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28537 #endif
28538 }
28539 return resultobj;
28540 fail:
28541 return NULL;
28542 }
28543
28544
28545 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28546 PyObject *resultobj = 0;
28547 wxDateTime *arg1 = (wxDateTime *) 0 ;
28548 wxString result;
28549 void *argp1 = 0 ;
28550 int res1 = 0 ;
28551 PyObject *swig_obj[1] ;
28552
28553 if (!args) SWIG_fail;
28554 swig_obj[0] = args;
28555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28556 if (!SWIG_IsOK(res1)) {
28557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28558 }
28559 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = ((wxDateTime const *)arg1)->FormatTime();
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 {
28567 #if wxUSE_UNICODE
28568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28569 #else
28570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28571 #endif
28572 }
28573 return resultobj;
28574 fail:
28575 return NULL;
28576 }
28577
28578
28579 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28580 PyObject *resultobj = 0;
28581 wxDateTime *arg1 = (wxDateTime *) 0 ;
28582 wxString result;
28583 void *argp1 = 0 ;
28584 int res1 = 0 ;
28585 PyObject *swig_obj[1] ;
28586
28587 if (!args) SWIG_fail;
28588 swig_obj[0] = args;
28589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28590 if (!SWIG_IsOK(res1)) {
28591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28592 }
28593 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28594 {
28595 PyThreadState* __tstate = wxPyBeginAllowThreads();
28596 result = ((wxDateTime const *)arg1)->FormatISODate();
28597 wxPyEndAllowThreads(__tstate);
28598 if (PyErr_Occurred()) SWIG_fail;
28599 }
28600 {
28601 #if wxUSE_UNICODE
28602 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28603 #else
28604 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28605 #endif
28606 }
28607 return resultobj;
28608 fail:
28609 return NULL;
28610 }
28611
28612
28613 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28614 PyObject *resultobj = 0;
28615 wxDateTime *arg1 = (wxDateTime *) 0 ;
28616 wxString result;
28617 void *argp1 = 0 ;
28618 int res1 = 0 ;
28619 PyObject *swig_obj[1] ;
28620
28621 if (!args) SWIG_fail;
28622 swig_obj[0] = args;
28623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28624 if (!SWIG_IsOK(res1)) {
28625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28626 }
28627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 result = ((wxDateTime const *)arg1)->FormatISOTime();
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 {
28635 #if wxUSE_UNICODE
28636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28637 #else
28638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28639 #endif
28640 }
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 PyObject *obj;
28649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28650 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28651 return SWIG_Py_Void();
28652 }
28653
28654 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28655 return SWIG_Python_InitShadowInstance(args);
28656 }
28657
28658 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28659 PyObject *resultobj = 0;
28660 long arg1 ;
28661 wxTimeSpan result;
28662 long val1 ;
28663 int ecode1 = 0 ;
28664 PyObject * obj0 = 0 ;
28665 char * kwnames[] = {
28666 (char *) "ms", NULL
28667 };
28668
28669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28670 ecode1 = SWIG_AsVal_long(obj0, &val1);
28671 if (!SWIG_IsOK(ecode1)) {
28672 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28673 }
28674 arg1 = static_cast< long >(val1);
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = wxTimeSpan::Milliseconds(arg1);
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689 PyObject *resultobj = 0;
28690 wxTimeSpan result;
28691
28692 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 result = wxTimeSpan::Millisecond();
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28700 return resultobj;
28701 fail:
28702 return NULL;
28703 }
28704
28705
28706 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28707 PyObject *resultobj = 0;
28708 long arg1 ;
28709 wxTimeSpan result;
28710 long val1 ;
28711 int ecode1 = 0 ;
28712 PyObject * obj0 = 0 ;
28713 char * kwnames[] = {
28714 (char *) "sec", NULL
28715 };
28716
28717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28718 ecode1 = SWIG_AsVal_long(obj0, &val1);
28719 if (!SWIG_IsOK(ecode1)) {
28720 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28721 }
28722 arg1 = static_cast< long >(val1);
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 result = wxTimeSpan::Seconds(arg1);
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 PyObject *resultobj = 0;
28738 wxTimeSpan result;
28739
28740 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 result = wxTimeSpan::Second();
28744 wxPyEndAllowThreads(__tstate);
28745 if (PyErr_Occurred()) SWIG_fail;
28746 }
28747 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28748 return resultobj;
28749 fail:
28750 return NULL;
28751 }
28752
28753
28754 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28755 PyObject *resultobj = 0;
28756 long arg1 ;
28757 wxTimeSpan result;
28758 long val1 ;
28759 int ecode1 = 0 ;
28760 PyObject * obj0 = 0 ;
28761 char * kwnames[] = {
28762 (char *) "min", NULL
28763 };
28764
28765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28766 ecode1 = SWIG_AsVal_long(obj0, &val1);
28767 if (!SWIG_IsOK(ecode1)) {
28768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28769 }
28770 arg1 = static_cast< long >(val1);
28771 {
28772 PyThreadState* __tstate = wxPyBeginAllowThreads();
28773 result = wxTimeSpan::Minutes(arg1);
28774 wxPyEndAllowThreads(__tstate);
28775 if (PyErr_Occurred()) SWIG_fail;
28776 }
28777 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28778 return resultobj;
28779 fail:
28780 return NULL;
28781 }
28782
28783
28784 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28785 PyObject *resultobj = 0;
28786 wxTimeSpan result;
28787
28788 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28789 {
28790 PyThreadState* __tstate = wxPyBeginAllowThreads();
28791 result = wxTimeSpan::Minute();
28792 wxPyEndAllowThreads(__tstate);
28793 if (PyErr_Occurred()) SWIG_fail;
28794 }
28795 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28796 return resultobj;
28797 fail:
28798 return NULL;
28799 }
28800
28801
28802 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28803 PyObject *resultobj = 0;
28804 long arg1 ;
28805 wxTimeSpan result;
28806 long val1 ;
28807 int ecode1 = 0 ;
28808 PyObject * obj0 = 0 ;
28809 char * kwnames[] = {
28810 (char *) "hours", NULL
28811 };
28812
28813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28814 ecode1 = SWIG_AsVal_long(obj0, &val1);
28815 if (!SWIG_IsOK(ecode1)) {
28816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28817 }
28818 arg1 = static_cast< long >(val1);
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = wxTimeSpan::Hours(arg1);
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28826 return resultobj;
28827 fail:
28828 return NULL;
28829 }
28830
28831
28832 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28833 PyObject *resultobj = 0;
28834 wxTimeSpan result;
28835
28836 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = wxTimeSpan::Hour();
28840 wxPyEndAllowThreads(__tstate);
28841 if (PyErr_Occurred()) SWIG_fail;
28842 }
28843 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28844 return resultobj;
28845 fail:
28846 return NULL;
28847 }
28848
28849
28850 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28851 PyObject *resultobj = 0;
28852 long arg1 ;
28853 wxTimeSpan result;
28854 long val1 ;
28855 int ecode1 = 0 ;
28856 PyObject * obj0 = 0 ;
28857 char * kwnames[] = {
28858 (char *) "days", NULL
28859 };
28860
28861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28862 ecode1 = SWIG_AsVal_long(obj0, &val1);
28863 if (!SWIG_IsOK(ecode1)) {
28864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28865 }
28866 arg1 = static_cast< long >(val1);
28867 {
28868 PyThreadState* __tstate = wxPyBeginAllowThreads();
28869 result = wxTimeSpan::Days(arg1);
28870 wxPyEndAllowThreads(__tstate);
28871 if (PyErr_Occurred()) SWIG_fail;
28872 }
28873 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28874 return resultobj;
28875 fail:
28876 return NULL;
28877 }
28878
28879
28880 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28881 PyObject *resultobj = 0;
28882 wxTimeSpan result;
28883
28884 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28885 {
28886 PyThreadState* __tstate = wxPyBeginAllowThreads();
28887 result = wxTimeSpan::Day();
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28899 PyObject *resultobj = 0;
28900 long arg1 ;
28901 wxTimeSpan result;
28902 long val1 ;
28903 int ecode1 = 0 ;
28904 PyObject * obj0 = 0 ;
28905 char * kwnames[] = {
28906 (char *) "days", NULL
28907 };
28908
28909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28910 ecode1 = SWIG_AsVal_long(obj0, &val1);
28911 if (!SWIG_IsOK(ecode1)) {
28912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28913 }
28914 arg1 = static_cast< long >(val1);
28915 {
28916 PyThreadState* __tstate = wxPyBeginAllowThreads();
28917 result = wxTimeSpan::Weeks(arg1);
28918 wxPyEndAllowThreads(__tstate);
28919 if (PyErr_Occurred()) SWIG_fail;
28920 }
28921 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28922 return resultobj;
28923 fail:
28924 return NULL;
28925 }
28926
28927
28928 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28929 PyObject *resultobj = 0;
28930 wxTimeSpan result;
28931
28932 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28933 {
28934 PyThreadState* __tstate = wxPyBeginAllowThreads();
28935 result = wxTimeSpan::Week();
28936 wxPyEndAllowThreads(__tstate);
28937 if (PyErr_Occurred()) SWIG_fail;
28938 }
28939 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28940 return resultobj;
28941 fail:
28942 return NULL;
28943 }
28944
28945
28946 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28947 PyObject *resultobj = 0;
28948 long arg1 = (long) 0 ;
28949 long arg2 = (long) 0 ;
28950 long arg3 = (long) 0 ;
28951 long arg4 = (long) 0 ;
28952 wxTimeSpan *result = 0 ;
28953 long val1 ;
28954 int ecode1 = 0 ;
28955 long val2 ;
28956 int ecode2 = 0 ;
28957 long val3 ;
28958 int ecode3 = 0 ;
28959 long val4 ;
28960 int ecode4 = 0 ;
28961 PyObject * obj0 = 0 ;
28962 PyObject * obj1 = 0 ;
28963 PyObject * obj2 = 0 ;
28964 PyObject * obj3 = 0 ;
28965 char * kwnames[] = {
28966 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28967 };
28968
28969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28970 if (obj0) {
28971 ecode1 = SWIG_AsVal_long(obj0, &val1);
28972 if (!SWIG_IsOK(ecode1)) {
28973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28974 }
28975 arg1 = static_cast< long >(val1);
28976 }
28977 if (obj1) {
28978 ecode2 = SWIG_AsVal_long(obj1, &val2);
28979 if (!SWIG_IsOK(ecode2)) {
28980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28981 }
28982 arg2 = static_cast< long >(val2);
28983 }
28984 if (obj2) {
28985 ecode3 = SWIG_AsVal_long(obj2, &val3);
28986 if (!SWIG_IsOK(ecode3)) {
28987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28988 }
28989 arg3 = static_cast< long >(val3);
28990 }
28991 if (obj3) {
28992 ecode4 = SWIG_AsVal_long(obj3, &val4);
28993 if (!SWIG_IsOK(ecode4)) {
28994 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28995 }
28996 arg4 = static_cast< long >(val4);
28997 }
28998 {
28999 PyThreadState* __tstate = wxPyBeginAllowThreads();
29000 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29001 wxPyEndAllowThreads(__tstate);
29002 if (PyErr_Occurred()) SWIG_fail;
29003 }
29004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29005 return resultobj;
29006 fail:
29007 return NULL;
29008 }
29009
29010
29011 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29012 PyObject *resultobj = 0;
29013 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29014 void *argp1 = 0 ;
29015 int res1 = 0 ;
29016 PyObject *swig_obj[1] ;
29017
29018 if (!args) SWIG_fail;
29019 swig_obj[0] = args;
29020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29021 if (!SWIG_IsOK(res1)) {
29022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29023 }
29024 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29025 {
29026 PyThreadState* __tstate = wxPyBeginAllowThreads();
29027 delete arg1;
29028
29029 wxPyEndAllowThreads(__tstate);
29030 if (PyErr_Occurred()) SWIG_fail;
29031 }
29032 resultobj = SWIG_Py_Void();
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29040 PyObject *resultobj = 0;
29041 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29042 wxTimeSpan *arg2 = 0 ;
29043 wxTimeSpan *result = 0 ;
29044 void *argp1 = 0 ;
29045 int res1 = 0 ;
29046 void *argp2 = 0 ;
29047 int res2 = 0 ;
29048 PyObject * obj0 = 0 ;
29049 PyObject * obj1 = 0 ;
29050 char * kwnames[] = {
29051 (char *) "self",(char *) "diff", NULL
29052 };
29053
29054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29056 if (!SWIG_IsOK(res1)) {
29057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29058 }
29059 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29061 if (!SWIG_IsOK(res2)) {
29062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29063 }
29064 if (!argp2) {
29065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29066 }
29067 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 {
29071 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29072 result = (wxTimeSpan *) &_result_ref;
29073 }
29074 wxPyEndAllowThreads(__tstate);
29075 if (PyErr_Occurred()) SWIG_fail;
29076 }
29077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29078 return resultobj;
29079 fail:
29080 return NULL;
29081 }
29082
29083
29084 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29085 PyObject *resultobj = 0;
29086 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29087 wxTimeSpan *arg2 = 0 ;
29088 wxTimeSpan *result = 0 ;
29089 void *argp1 = 0 ;
29090 int res1 = 0 ;
29091 void *argp2 = 0 ;
29092 int res2 = 0 ;
29093 PyObject * obj0 = 0 ;
29094 PyObject * obj1 = 0 ;
29095 char * kwnames[] = {
29096 (char *) "self",(char *) "diff", NULL
29097 };
29098
29099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29101 if (!SWIG_IsOK(res1)) {
29102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29103 }
29104 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29105 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29106 if (!SWIG_IsOK(res2)) {
29107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29108 }
29109 if (!argp2) {
29110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29111 }
29112 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 {
29116 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29117 result = (wxTimeSpan *) &_result_ref;
29118 }
29119 wxPyEndAllowThreads(__tstate);
29120 if (PyErr_Occurred()) SWIG_fail;
29121 }
29122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29123 return resultobj;
29124 fail:
29125 return NULL;
29126 }
29127
29128
29129 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29130 PyObject *resultobj = 0;
29131 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29132 int arg2 ;
29133 wxTimeSpan *result = 0 ;
29134 void *argp1 = 0 ;
29135 int res1 = 0 ;
29136 int val2 ;
29137 int ecode2 = 0 ;
29138 PyObject * obj0 = 0 ;
29139 PyObject * obj1 = 0 ;
29140 char * kwnames[] = {
29141 (char *) "self",(char *) "n", NULL
29142 };
29143
29144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29146 if (!SWIG_IsOK(res1)) {
29147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29148 }
29149 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29150 ecode2 = SWIG_AsVal_int(obj1, &val2);
29151 if (!SWIG_IsOK(ecode2)) {
29152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29153 }
29154 arg2 = static_cast< int >(val2);
29155 {
29156 PyThreadState* __tstate = wxPyBeginAllowThreads();
29157 {
29158 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29159 result = (wxTimeSpan *) &_result_ref;
29160 }
29161 wxPyEndAllowThreads(__tstate);
29162 if (PyErr_Occurred()) SWIG_fail;
29163 }
29164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29165 return resultobj;
29166 fail:
29167 return NULL;
29168 }
29169
29170
29171 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29172 PyObject *resultobj = 0;
29173 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29174 wxTimeSpan *result = 0 ;
29175 void *argp1 = 0 ;
29176 int res1 = 0 ;
29177 PyObject *swig_obj[1] ;
29178
29179 if (!args) SWIG_fail;
29180 swig_obj[0] = args;
29181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29182 if (!SWIG_IsOK(res1)) {
29183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29184 }
29185 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 {
29189 wxTimeSpan &_result_ref = (arg1)->Neg();
29190 result = (wxTimeSpan *) &_result_ref;
29191 }
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29203 PyObject *resultobj = 0;
29204 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29205 wxTimeSpan result;
29206 void *argp1 = 0 ;
29207 int res1 = 0 ;
29208 PyObject *swig_obj[1] ;
29209
29210 if (!args) SWIG_fail;
29211 swig_obj[0] = args;
29212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29213 if (!SWIG_IsOK(res1)) {
29214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29215 }
29216 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29217 {
29218 PyThreadState* __tstate = wxPyBeginAllowThreads();
29219 result = ((wxTimeSpan const *)arg1)->Abs();
29220 wxPyEndAllowThreads(__tstate);
29221 if (PyErr_Occurred()) SWIG_fail;
29222 }
29223 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29224 return resultobj;
29225 fail:
29226 return NULL;
29227 }
29228
29229
29230 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj = 0;
29232 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29233 wxTimeSpan *arg2 = 0 ;
29234 wxTimeSpan *result = 0 ;
29235 void *argp1 = 0 ;
29236 int res1 = 0 ;
29237 void *argp2 = 0 ;
29238 int res2 = 0 ;
29239 PyObject * obj0 = 0 ;
29240 PyObject * obj1 = 0 ;
29241 char * kwnames[] = {
29242 (char *) "self",(char *) "diff", NULL
29243 };
29244
29245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29247 if (!SWIG_IsOK(res1)) {
29248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29249 }
29250 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29251 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29252 if (!SWIG_IsOK(res2)) {
29253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29254 }
29255 if (!argp2) {
29256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29257 }
29258 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29259 {
29260 PyThreadState* __tstate = wxPyBeginAllowThreads();
29261 {
29262 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29263 result = (wxTimeSpan *) &_result_ref;
29264 }
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29269 return resultobj;
29270 fail:
29271 return NULL;
29272 }
29273
29274
29275 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29276 PyObject *resultobj = 0;
29277 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29278 wxTimeSpan *arg2 = 0 ;
29279 wxTimeSpan *result = 0 ;
29280 void *argp1 = 0 ;
29281 int res1 = 0 ;
29282 void *argp2 = 0 ;
29283 int res2 = 0 ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 char * kwnames[] = {
29287 (char *) "self",(char *) "diff", NULL
29288 };
29289
29290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29294 }
29295 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29297 if (!SWIG_IsOK(res2)) {
29298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29299 }
29300 if (!argp2) {
29301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29302 }
29303 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29304 {
29305 PyThreadState* __tstate = wxPyBeginAllowThreads();
29306 {
29307 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29308 result = (wxTimeSpan *) &_result_ref;
29309 }
29310 wxPyEndAllowThreads(__tstate);
29311 if (PyErr_Occurred()) SWIG_fail;
29312 }
29313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29314 return resultobj;
29315 fail:
29316 return NULL;
29317 }
29318
29319
29320 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29321 PyObject *resultobj = 0;
29322 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29323 int arg2 ;
29324 wxTimeSpan *result = 0 ;
29325 void *argp1 = 0 ;
29326 int res1 = 0 ;
29327 int val2 ;
29328 int ecode2 = 0 ;
29329 PyObject * obj0 = 0 ;
29330 PyObject * obj1 = 0 ;
29331 char * kwnames[] = {
29332 (char *) "self",(char *) "n", NULL
29333 };
29334
29335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29337 if (!SWIG_IsOK(res1)) {
29338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29339 }
29340 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29341 ecode2 = SWIG_AsVal_int(obj1, &val2);
29342 if (!SWIG_IsOK(ecode2)) {
29343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29344 }
29345 arg2 = static_cast< int >(val2);
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 {
29349 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29350 result = (wxTimeSpan *) &_result_ref;
29351 }
29352 wxPyEndAllowThreads(__tstate);
29353 if (PyErr_Occurred()) SWIG_fail;
29354 }
29355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29363 PyObject *resultobj = 0;
29364 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29365 wxTimeSpan *result = 0 ;
29366 void *argp1 = 0 ;
29367 int res1 = 0 ;
29368 PyObject *swig_obj[1] ;
29369
29370 if (!args) SWIG_fail;
29371 swig_obj[0] = args;
29372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29373 if (!SWIG_IsOK(res1)) {
29374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29375 }
29376 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29377 {
29378 PyThreadState* __tstate = wxPyBeginAllowThreads();
29379 {
29380 wxTimeSpan &_result_ref = (arg1)->operator -();
29381 result = (wxTimeSpan *) &_result_ref;
29382 }
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29394 PyObject *resultobj = 0;
29395 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29396 wxTimeSpan *arg2 = 0 ;
29397 wxTimeSpan result;
29398 void *argp1 = 0 ;
29399 int res1 = 0 ;
29400 void *argp2 = 0 ;
29401 int res2 = 0 ;
29402 PyObject * obj0 = 0 ;
29403 PyObject * obj1 = 0 ;
29404 char * kwnames[] = {
29405 (char *) "self",(char *) "other", NULL
29406 };
29407
29408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29412 }
29413 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29414 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29415 if (!SWIG_IsOK(res2)) {
29416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29417 }
29418 if (!argp2) {
29419 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29420 }
29421 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29422 {
29423 PyThreadState* __tstate = wxPyBeginAllowThreads();
29424 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29425 wxPyEndAllowThreads(__tstate);
29426 if (PyErr_Occurred()) SWIG_fail;
29427 }
29428 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29429 return resultobj;
29430 fail:
29431 return NULL;
29432 }
29433
29434
29435 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29436 PyObject *resultobj = 0;
29437 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29438 wxTimeSpan *arg2 = 0 ;
29439 wxTimeSpan result;
29440 void *argp1 = 0 ;
29441 int res1 = 0 ;
29442 void *argp2 = 0 ;
29443 int res2 = 0 ;
29444 PyObject * obj0 = 0 ;
29445 PyObject * obj1 = 0 ;
29446 char * kwnames[] = {
29447 (char *) "self",(char *) "other", NULL
29448 };
29449
29450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29452 if (!SWIG_IsOK(res1)) {
29453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29454 }
29455 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29456 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29457 if (!SWIG_IsOK(res2)) {
29458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29459 }
29460 if (!argp2) {
29461 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29462 }
29463 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29464 {
29465 PyThreadState* __tstate = wxPyBeginAllowThreads();
29466 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29467 wxPyEndAllowThreads(__tstate);
29468 if (PyErr_Occurred()) SWIG_fail;
29469 }
29470 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29478 PyObject *resultobj = 0;
29479 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29480 int arg2 ;
29481 wxTimeSpan result;
29482 void *argp1 = 0 ;
29483 int res1 = 0 ;
29484 int val2 ;
29485 int ecode2 = 0 ;
29486 PyObject * obj0 = 0 ;
29487 PyObject * obj1 = 0 ;
29488 char * kwnames[] = {
29489 (char *) "self",(char *) "n", NULL
29490 };
29491
29492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29494 if (!SWIG_IsOK(res1)) {
29495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29496 }
29497 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29498 ecode2 = SWIG_AsVal_int(obj1, &val2);
29499 if (!SWIG_IsOK(ecode2)) {
29500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29501 }
29502 arg2 = static_cast< int >(val2);
29503 {
29504 PyThreadState* __tstate = wxPyBeginAllowThreads();
29505 result = wxTimeSpan___mul__(arg1,arg2);
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj = 0;
29518 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29519 int arg2 ;
29520 wxTimeSpan result;
29521 void *argp1 = 0 ;
29522 int res1 = 0 ;
29523 int val2 ;
29524 int ecode2 = 0 ;
29525 PyObject * obj0 = 0 ;
29526 PyObject * obj1 = 0 ;
29527 char * kwnames[] = {
29528 (char *) "self",(char *) "n", NULL
29529 };
29530
29531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29533 if (!SWIG_IsOK(res1)) {
29534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29535 }
29536 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29537 ecode2 = SWIG_AsVal_int(obj1, &val2);
29538 if (!SWIG_IsOK(ecode2)) {
29539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29540 }
29541 arg2 = static_cast< int >(val2);
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 result = wxTimeSpan___rmul__(arg1,arg2);
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29556 PyObject *resultobj = 0;
29557 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29558 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29559 bool result;
29560 void *argp1 = 0 ;
29561 int res1 = 0 ;
29562 void *argp2 = 0 ;
29563 int res2 = 0 ;
29564 PyObject * obj0 = 0 ;
29565 PyObject * obj1 = 0 ;
29566 char * kwnames[] = {
29567 (char *) "self",(char *) "other", NULL
29568 };
29569
29570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29572 if (!SWIG_IsOK(res1)) {
29573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29574 }
29575 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29577 if (!SWIG_IsOK(res2)) {
29578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29579 }
29580 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29581 {
29582 PyThreadState* __tstate = wxPyBeginAllowThreads();
29583 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29584 wxPyEndAllowThreads(__tstate);
29585 if (PyErr_Occurred()) SWIG_fail;
29586 }
29587 {
29588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29589 }
29590 return resultobj;
29591 fail:
29592 return NULL;
29593 }
29594
29595
29596 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29597 PyObject *resultobj = 0;
29598 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29599 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29600 bool result;
29601 void *argp1 = 0 ;
29602 int res1 = 0 ;
29603 void *argp2 = 0 ;
29604 int res2 = 0 ;
29605 PyObject * obj0 = 0 ;
29606 PyObject * obj1 = 0 ;
29607 char * kwnames[] = {
29608 (char *) "self",(char *) "other", NULL
29609 };
29610
29611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29613 if (!SWIG_IsOK(res1)) {
29614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29615 }
29616 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29618 if (!SWIG_IsOK(res2)) {
29619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29620 }
29621 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 {
29629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29630 }
29631 return resultobj;
29632 fail:
29633 return NULL;
29634 }
29635
29636
29637 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29638 PyObject *resultobj = 0;
29639 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29640 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29641 bool result;
29642 void *argp1 = 0 ;
29643 int res1 = 0 ;
29644 void *argp2 = 0 ;
29645 int res2 = 0 ;
29646 PyObject * obj0 = 0 ;
29647 PyObject * obj1 = 0 ;
29648 char * kwnames[] = {
29649 (char *) "self",(char *) "other", NULL
29650 };
29651
29652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29654 if (!SWIG_IsOK(res1)) {
29655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29656 }
29657 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29659 if (!SWIG_IsOK(res2)) {
29660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29661 }
29662 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29663 {
29664 PyThreadState* __tstate = wxPyBeginAllowThreads();
29665 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 {
29670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29671 }
29672 return resultobj;
29673 fail:
29674 return NULL;
29675 }
29676
29677
29678 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29679 PyObject *resultobj = 0;
29680 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29681 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29682 bool result;
29683 void *argp1 = 0 ;
29684 int res1 = 0 ;
29685 void *argp2 = 0 ;
29686 int res2 = 0 ;
29687 PyObject * obj0 = 0 ;
29688 PyObject * obj1 = 0 ;
29689 char * kwnames[] = {
29690 (char *) "self",(char *) "other", NULL
29691 };
29692
29693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29695 if (!SWIG_IsOK(res1)) {
29696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29697 }
29698 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29700 if (!SWIG_IsOK(res2)) {
29701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29702 }
29703 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29704 {
29705 PyThreadState* __tstate = wxPyBeginAllowThreads();
29706 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29707 wxPyEndAllowThreads(__tstate);
29708 if (PyErr_Occurred()) SWIG_fail;
29709 }
29710 {
29711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29712 }
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29720 PyObject *resultobj = 0;
29721 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29722 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29723 bool result;
29724 void *argp1 = 0 ;
29725 int res1 = 0 ;
29726 void *argp2 = 0 ;
29727 int res2 = 0 ;
29728 PyObject * obj0 = 0 ;
29729 PyObject * obj1 = 0 ;
29730 char * kwnames[] = {
29731 (char *) "self",(char *) "other", NULL
29732 };
29733
29734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29736 if (!SWIG_IsOK(res1)) {
29737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29738 }
29739 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29740 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29741 if (!SWIG_IsOK(res2)) {
29742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29743 }
29744 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29745 {
29746 PyThreadState* __tstate = wxPyBeginAllowThreads();
29747 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29748 wxPyEndAllowThreads(__tstate);
29749 if (PyErr_Occurred()) SWIG_fail;
29750 }
29751 {
29752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29753 }
29754 return resultobj;
29755 fail:
29756 return NULL;
29757 }
29758
29759
29760 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29761 PyObject *resultobj = 0;
29762 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29763 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29764 bool result;
29765 void *argp1 = 0 ;
29766 int res1 = 0 ;
29767 void *argp2 = 0 ;
29768 int res2 = 0 ;
29769 PyObject * obj0 = 0 ;
29770 PyObject * obj1 = 0 ;
29771 char * kwnames[] = {
29772 (char *) "self",(char *) "other", NULL
29773 };
29774
29775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29777 if (!SWIG_IsOK(res1)) {
29778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29779 }
29780 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29781 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29782 if (!SWIG_IsOK(res2)) {
29783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29784 }
29785 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29789 wxPyEndAllowThreads(__tstate);
29790 if (PyErr_Occurred()) SWIG_fail;
29791 }
29792 {
29793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29794 }
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29802 PyObject *resultobj = 0;
29803 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29804 bool result;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 PyObject *swig_obj[1] ;
29808
29809 if (!args) SWIG_fail;
29810 swig_obj[0] = args;
29811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29812 if (!SWIG_IsOK(res1)) {
29813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29814 }
29815 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29819 wxPyEndAllowThreads(__tstate);
29820 if (PyErr_Occurred()) SWIG_fail;
29821 }
29822 {
29823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29824 }
29825 return resultobj;
29826 fail:
29827 return NULL;
29828 }
29829
29830
29831 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29832 PyObject *resultobj = 0;
29833 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29834 bool result;
29835 void *argp1 = 0 ;
29836 int res1 = 0 ;
29837 PyObject *swig_obj[1] ;
29838
29839 if (!args) SWIG_fail;
29840 swig_obj[0] = args;
29841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29842 if (!SWIG_IsOK(res1)) {
29843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29844 }
29845 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29846 {
29847 PyThreadState* __tstate = wxPyBeginAllowThreads();
29848 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29849 wxPyEndAllowThreads(__tstate);
29850 if (PyErr_Occurred()) SWIG_fail;
29851 }
29852 {
29853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29854 }
29855 return resultobj;
29856 fail:
29857 return NULL;
29858 }
29859
29860
29861 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29862 PyObject *resultobj = 0;
29863 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29864 bool result;
29865 void *argp1 = 0 ;
29866 int res1 = 0 ;
29867 PyObject *swig_obj[1] ;
29868
29869 if (!args) SWIG_fail;
29870 swig_obj[0] = args;
29871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29872 if (!SWIG_IsOK(res1)) {
29873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29874 }
29875 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29876 {
29877 PyThreadState* __tstate = wxPyBeginAllowThreads();
29878 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 {
29883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29884 }
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29892 PyObject *resultobj = 0;
29893 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29894 wxTimeSpan *arg2 = 0 ;
29895 bool result;
29896 void *argp1 = 0 ;
29897 int res1 = 0 ;
29898 void *argp2 = 0 ;
29899 int res2 = 0 ;
29900 PyObject * obj0 = 0 ;
29901 PyObject * obj1 = 0 ;
29902 char * kwnames[] = {
29903 (char *) "self",(char *) "ts", NULL
29904 };
29905
29906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29908 if (!SWIG_IsOK(res1)) {
29909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29910 }
29911 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29912 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29913 if (!SWIG_IsOK(res2)) {
29914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29915 }
29916 if (!argp2) {
29917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29918 }
29919 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29920 {
29921 PyThreadState* __tstate = wxPyBeginAllowThreads();
29922 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29923 wxPyEndAllowThreads(__tstate);
29924 if (PyErr_Occurred()) SWIG_fail;
29925 }
29926 {
29927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29928 }
29929 return resultobj;
29930 fail:
29931 return NULL;
29932 }
29933
29934
29935 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29936 PyObject *resultobj = 0;
29937 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29938 wxTimeSpan *arg2 = 0 ;
29939 bool result;
29940 void *argp1 = 0 ;
29941 int res1 = 0 ;
29942 void *argp2 = 0 ;
29943 int res2 = 0 ;
29944 PyObject * obj0 = 0 ;
29945 PyObject * obj1 = 0 ;
29946 char * kwnames[] = {
29947 (char *) "self",(char *) "ts", NULL
29948 };
29949
29950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29952 if (!SWIG_IsOK(res1)) {
29953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29954 }
29955 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29957 if (!SWIG_IsOK(res2)) {
29958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29959 }
29960 if (!argp2) {
29961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29962 }
29963 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29967 wxPyEndAllowThreads(__tstate);
29968 if (PyErr_Occurred()) SWIG_fail;
29969 }
29970 {
29971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29972 }
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29980 PyObject *resultobj = 0;
29981 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29982 wxTimeSpan *arg2 = 0 ;
29983 bool result;
29984 void *argp1 = 0 ;
29985 int res1 = 0 ;
29986 void *argp2 = 0 ;
29987 int res2 = 0 ;
29988 PyObject * obj0 = 0 ;
29989 PyObject * obj1 = 0 ;
29990 char * kwnames[] = {
29991 (char *) "self",(char *) "t", NULL
29992 };
29993
29994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29996 if (!SWIG_IsOK(res1)) {
29997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29998 }
29999 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30000 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30001 if (!SWIG_IsOK(res2)) {
30002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30003 }
30004 if (!argp2) {
30005 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30006 }
30007 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 {
30015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30016 }
30017 return resultobj;
30018 fail:
30019 return NULL;
30020 }
30021
30022
30023 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30024 PyObject *resultobj = 0;
30025 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30026 int result;
30027 void *argp1 = 0 ;
30028 int res1 = 0 ;
30029 PyObject *swig_obj[1] ;
30030
30031 if (!args) SWIG_fail;
30032 swig_obj[0] = args;
30033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30034 if (!SWIG_IsOK(res1)) {
30035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30036 }
30037 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30038 {
30039 PyThreadState* __tstate = wxPyBeginAllowThreads();
30040 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30041 wxPyEndAllowThreads(__tstate);
30042 if (PyErr_Occurred()) SWIG_fail;
30043 }
30044 resultobj = SWIG_From_int(static_cast< int >(result));
30045 return resultobj;
30046 fail:
30047 return NULL;
30048 }
30049
30050
30051 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30052 PyObject *resultobj = 0;
30053 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30054 int result;
30055 void *argp1 = 0 ;
30056 int res1 = 0 ;
30057 PyObject *swig_obj[1] ;
30058
30059 if (!args) SWIG_fail;
30060 swig_obj[0] = args;
30061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30062 if (!SWIG_IsOK(res1)) {
30063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30064 }
30065 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30066 {
30067 PyThreadState* __tstate = wxPyBeginAllowThreads();
30068 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30069 wxPyEndAllowThreads(__tstate);
30070 if (PyErr_Occurred()) SWIG_fail;
30071 }
30072 resultobj = SWIG_From_int(static_cast< int >(result));
30073 return resultobj;
30074 fail:
30075 return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30080 PyObject *resultobj = 0;
30081 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30082 int result;
30083 void *argp1 = 0 ;
30084 int res1 = 0 ;
30085 PyObject *swig_obj[1] ;
30086
30087 if (!args) SWIG_fail;
30088 swig_obj[0] = args;
30089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30090 if (!SWIG_IsOK(res1)) {
30091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30092 }
30093 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30097 wxPyEndAllowThreads(__tstate);
30098 if (PyErr_Occurred()) SWIG_fail;
30099 }
30100 resultobj = SWIG_From_int(static_cast< int >(result));
30101 return resultobj;
30102 fail:
30103 return NULL;
30104 }
30105
30106
30107 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30108 PyObject *resultobj = 0;
30109 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30110 int result;
30111 void *argp1 = 0 ;
30112 int res1 = 0 ;
30113 PyObject *swig_obj[1] ;
30114
30115 if (!args) SWIG_fail;
30116 swig_obj[0] = args;
30117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30118 if (!SWIG_IsOK(res1)) {
30119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30120 }
30121 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30125 wxPyEndAllowThreads(__tstate);
30126 if (PyErr_Occurred()) SWIG_fail;
30127 }
30128 resultobj = SWIG_From_int(static_cast< int >(result));
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30136 PyObject *resultobj = 0;
30137 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30138 wxLongLong result;
30139 void *argp1 = 0 ;
30140 int res1 = 0 ;
30141 PyObject *swig_obj[1] ;
30142
30143 if (!args) SWIG_fail;
30144 swig_obj[0] = args;
30145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30146 if (!SWIG_IsOK(res1)) {
30147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30148 }
30149 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30150 {
30151 PyThreadState* __tstate = wxPyBeginAllowThreads();
30152 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30153 wxPyEndAllowThreads(__tstate);
30154 if (PyErr_Occurred()) SWIG_fail;
30155 }
30156 {
30157 PyObject *hi, *lo, *shifter, *shifted;
30158 hi = PyLong_FromLong( (&result)->GetHi() );
30159 lo = PyLong_FromLong( (&result)->GetLo() );
30160 shifter = PyLong_FromLong(32);
30161 shifted = PyNumber_Lshift(hi, shifter);
30162 resultobj = PyNumber_Or(shifted, lo);
30163 Py_DECREF(hi);
30164 Py_DECREF(lo);
30165 Py_DECREF(shifter);
30166 Py_DECREF(shifted);
30167 }
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30175 PyObject *resultobj = 0;
30176 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30177 wxLongLong result;
30178 void *argp1 = 0 ;
30179 int res1 = 0 ;
30180 PyObject *swig_obj[1] ;
30181
30182 if (!args) SWIG_fail;
30183 swig_obj[0] = args;
30184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30185 if (!SWIG_IsOK(res1)) {
30186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30187 }
30188 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30192 wxPyEndAllowThreads(__tstate);
30193 if (PyErr_Occurred()) SWIG_fail;
30194 }
30195 {
30196 PyObject *hi, *lo, *shifter, *shifted;
30197 hi = PyLong_FromLong( (&result)->GetHi() );
30198 lo = PyLong_FromLong( (&result)->GetLo() );
30199 shifter = PyLong_FromLong(32);
30200 shifted = PyNumber_Lshift(hi, shifter);
30201 resultobj = PyNumber_Or(shifted, lo);
30202 Py_DECREF(hi);
30203 Py_DECREF(lo);
30204 Py_DECREF(shifter);
30205 Py_DECREF(shifted);
30206 }
30207 return resultobj;
30208 fail:
30209 return NULL;
30210 }
30211
30212
30213 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30214 PyObject *resultobj = 0;
30215 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30216 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30217 wxString *arg2 = (wxString *) &arg2_defvalue ;
30218 wxString result;
30219 void *argp1 = 0 ;
30220 int res1 = 0 ;
30221 bool temp2 = false ;
30222 PyObject * obj0 = 0 ;
30223 PyObject * obj1 = 0 ;
30224 char * kwnames[] = {
30225 (char *) "self",(char *) "format", NULL
30226 };
30227
30228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30230 if (!SWIG_IsOK(res1)) {
30231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30232 }
30233 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30234 if (obj1) {
30235 {
30236 arg2 = wxString_in_helper(obj1);
30237 if (arg2 == NULL) SWIG_fail;
30238 temp2 = true;
30239 }
30240 }
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 {
30248 #if wxUSE_UNICODE
30249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30250 #else
30251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30252 #endif
30253 }
30254 {
30255 if (temp2)
30256 delete arg2;
30257 }
30258 return resultobj;
30259 fail:
30260 {
30261 if (temp2)
30262 delete arg2;
30263 }
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30269 PyObject *obj;
30270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30271 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30272 return SWIG_Py_Void();
30273 }
30274
30275 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30276 return SWIG_Python_InitShadowInstance(args);
30277 }
30278
30279 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30280 PyObject *resultobj = 0;
30281 int arg1 = (int) 0 ;
30282 int arg2 = (int) 0 ;
30283 int arg3 = (int) 0 ;
30284 int arg4 = (int) 0 ;
30285 wxDateSpan *result = 0 ;
30286 int val1 ;
30287 int ecode1 = 0 ;
30288 int val2 ;
30289 int ecode2 = 0 ;
30290 int val3 ;
30291 int ecode3 = 0 ;
30292 int val4 ;
30293 int ecode4 = 0 ;
30294 PyObject * obj0 = 0 ;
30295 PyObject * obj1 = 0 ;
30296 PyObject * obj2 = 0 ;
30297 PyObject * obj3 = 0 ;
30298 char * kwnames[] = {
30299 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30300 };
30301
30302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30303 if (obj0) {
30304 ecode1 = SWIG_AsVal_int(obj0, &val1);
30305 if (!SWIG_IsOK(ecode1)) {
30306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30307 }
30308 arg1 = static_cast< int >(val1);
30309 }
30310 if (obj1) {
30311 ecode2 = SWIG_AsVal_int(obj1, &val2);
30312 if (!SWIG_IsOK(ecode2)) {
30313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30314 }
30315 arg2 = static_cast< int >(val2);
30316 }
30317 if (obj2) {
30318 ecode3 = SWIG_AsVal_int(obj2, &val3);
30319 if (!SWIG_IsOK(ecode3)) {
30320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30321 }
30322 arg3 = static_cast< int >(val3);
30323 }
30324 if (obj3) {
30325 ecode4 = SWIG_AsVal_int(obj3, &val4);
30326 if (!SWIG_IsOK(ecode4)) {
30327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30328 }
30329 arg4 = static_cast< int >(val4);
30330 }
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30334 wxPyEndAllowThreads(__tstate);
30335 if (PyErr_Occurred()) SWIG_fail;
30336 }
30337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30338 return resultobj;
30339 fail:
30340 return NULL;
30341 }
30342
30343
30344 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30345 PyObject *resultobj = 0;
30346 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30347 void *argp1 = 0 ;
30348 int res1 = 0 ;
30349 PyObject *swig_obj[1] ;
30350
30351 if (!args) SWIG_fail;
30352 swig_obj[0] = args;
30353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30354 if (!SWIG_IsOK(res1)) {
30355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30356 }
30357 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30358 {
30359 PyThreadState* __tstate = wxPyBeginAllowThreads();
30360 delete arg1;
30361
30362 wxPyEndAllowThreads(__tstate);
30363 if (PyErr_Occurred()) SWIG_fail;
30364 }
30365 resultobj = SWIG_Py_Void();
30366 return resultobj;
30367 fail:
30368 return NULL;
30369 }
30370
30371
30372 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30373 PyObject *resultobj = 0;
30374 int arg1 ;
30375 wxDateSpan result;
30376 int val1 ;
30377 int ecode1 = 0 ;
30378 PyObject * obj0 = 0 ;
30379 char * kwnames[] = {
30380 (char *) "days", NULL
30381 };
30382
30383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30384 ecode1 = SWIG_AsVal_int(obj0, &val1);
30385 if (!SWIG_IsOK(ecode1)) {
30386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30387 }
30388 arg1 = static_cast< int >(val1);
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 result = wxDateSpan::Days(arg1);
30392 wxPyEndAllowThreads(__tstate);
30393 if (PyErr_Occurred()) SWIG_fail;
30394 }
30395 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30403 PyObject *resultobj = 0;
30404 wxDateSpan result;
30405
30406 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 result = wxDateSpan::Day();
30410 wxPyEndAllowThreads(__tstate);
30411 if (PyErr_Occurred()) SWIG_fail;
30412 }
30413 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30414 return resultobj;
30415 fail:
30416 return NULL;
30417 }
30418
30419
30420 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30421 PyObject *resultobj = 0;
30422 int arg1 ;
30423 wxDateSpan result;
30424 int val1 ;
30425 int ecode1 = 0 ;
30426 PyObject * obj0 = 0 ;
30427 char * kwnames[] = {
30428 (char *) "weeks", NULL
30429 };
30430
30431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30432 ecode1 = SWIG_AsVal_int(obj0, &val1);
30433 if (!SWIG_IsOK(ecode1)) {
30434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30435 }
30436 arg1 = static_cast< int >(val1);
30437 {
30438 PyThreadState* __tstate = wxPyBeginAllowThreads();
30439 result = wxDateSpan::Weeks(arg1);
30440 wxPyEndAllowThreads(__tstate);
30441 if (PyErr_Occurred()) SWIG_fail;
30442 }
30443 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30444 return resultobj;
30445 fail:
30446 return NULL;
30447 }
30448
30449
30450 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30451 PyObject *resultobj = 0;
30452 wxDateSpan result;
30453
30454 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 result = wxDateSpan::Week();
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30469 PyObject *resultobj = 0;
30470 int arg1 ;
30471 wxDateSpan result;
30472 int val1 ;
30473 int ecode1 = 0 ;
30474 PyObject * obj0 = 0 ;
30475 char * kwnames[] = {
30476 (char *) "mon", NULL
30477 };
30478
30479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30480 ecode1 = SWIG_AsVal_int(obj0, &val1);
30481 if (!SWIG_IsOK(ecode1)) {
30482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30483 }
30484 arg1 = static_cast< int >(val1);
30485 {
30486 PyThreadState* __tstate = wxPyBeginAllowThreads();
30487 result = wxDateSpan::Months(arg1);
30488 wxPyEndAllowThreads(__tstate);
30489 if (PyErr_Occurred()) SWIG_fail;
30490 }
30491 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30492 return resultobj;
30493 fail:
30494 return NULL;
30495 }
30496
30497
30498 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30499 PyObject *resultobj = 0;
30500 wxDateSpan result;
30501
30502 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30503 {
30504 PyThreadState* __tstate = wxPyBeginAllowThreads();
30505 result = wxDateSpan::Month();
30506 wxPyEndAllowThreads(__tstate);
30507 if (PyErr_Occurred()) SWIG_fail;
30508 }
30509 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30510 return resultobj;
30511 fail:
30512 return NULL;
30513 }
30514
30515
30516 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30517 PyObject *resultobj = 0;
30518 int arg1 ;
30519 wxDateSpan result;
30520 int val1 ;
30521 int ecode1 = 0 ;
30522 PyObject * obj0 = 0 ;
30523 char * kwnames[] = {
30524 (char *) "years", NULL
30525 };
30526
30527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30528 ecode1 = SWIG_AsVal_int(obj0, &val1);
30529 if (!SWIG_IsOK(ecode1)) {
30530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30531 }
30532 arg1 = static_cast< int >(val1);
30533 {
30534 PyThreadState* __tstate = wxPyBeginAllowThreads();
30535 result = wxDateSpan::Years(arg1);
30536 wxPyEndAllowThreads(__tstate);
30537 if (PyErr_Occurred()) SWIG_fail;
30538 }
30539 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30540 return resultobj;
30541 fail:
30542 return NULL;
30543 }
30544
30545
30546 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30547 PyObject *resultobj = 0;
30548 wxDateSpan result;
30549
30550 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30551 {
30552 PyThreadState* __tstate = wxPyBeginAllowThreads();
30553 result = wxDateSpan::Year();
30554 wxPyEndAllowThreads(__tstate);
30555 if (PyErr_Occurred()) SWIG_fail;
30556 }
30557 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30558 return resultobj;
30559 fail:
30560 return NULL;
30561 }
30562
30563
30564 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30565 PyObject *resultobj = 0;
30566 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30567 int arg2 ;
30568 wxDateSpan *result = 0 ;
30569 void *argp1 = 0 ;
30570 int res1 = 0 ;
30571 int val2 ;
30572 int ecode2 = 0 ;
30573 PyObject * obj0 = 0 ;
30574 PyObject * obj1 = 0 ;
30575 char * kwnames[] = {
30576 (char *) "self",(char *) "n", NULL
30577 };
30578
30579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30581 if (!SWIG_IsOK(res1)) {
30582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30583 }
30584 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30585 ecode2 = SWIG_AsVal_int(obj1, &val2);
30586 if (!SWIG_IsOK(ecode2)) {
30587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30588 }
30589 arg2 = static_cast< int >(val2);
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 {
30593 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30594 result = (wxDateSpan *) &_result_ref;
30595 }
30596 wxPyEndAllowThreads(__tstate);
30597 if (PyErr_Occurred()) SWIG_fail;
30598 }
30599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj = 0;
30608 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30609 int arg2 ;
30610 wxDateSpan *result = 0 ;
30611 void *argp1 = 0 ;
30612 int res1 = 0 ;
30613 int val2 ;
30614 int ecode2 = 0 ;
30615 PyObject * obj0 = 0 ;
30616 PyObject * obj1 = 0 ;
30617 char * kwnames[] = {
30618 (char *) "self",(char *) "n", NULL
30619 };
30620
30621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30623 if (!SWIG_IsOK(res1)) {
30624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30625 }
30626 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30627 ecode2 = SWIG_AsVal_int(obj1, &val2);
30628 if (!SWIG_IsOK(ecode2)) {
30629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30630 }
30631 arg2 = static_cast< int >(val2);
30632 {
30633 PyThreadState* __tstate = wxPyBeginAllowThreads();
30634 {
30635 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30636 result = (wxDateSpan *) &_result_ref;
30637 }
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30642 return resultobj;
30643 fail:
30644 return NULL;
30645 }
30646
30647
30648 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30649 PyObject *resultobj = 0;
30650 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30651 int arg2 ;
30652 wxDateSpan *result = 0 ;
30653 void *argp1 = 0 ;
30654 int res1 = 0 ;
30655 int val2 ;
30656 int ecode2 = 0 ;
30657 PyObject * obj0 = 0 ;
30658 PyObject * obj1 = 0 ;
30659 char * kwnames[] = {
30660 (char *) "self",(char *) "n", NULL
30661 };
30662
30663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30665 if (!SWIG_IsOK(res1)) {
30666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30667 }
30668 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30669 ecode2 = SWIG_AsVal_int(obj1, &val2);
30670 if (!SWIG_IsOK(ecode2)) {
30671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30672 }
30673 arg2 = static_cast< int >(val2);
30674 {
30675 PyThreadState* __tstate = wxPyBeginAllowThreads();
30676 {
30677 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30678 result = (wxDateSpan *) &_result_ref;
30679 }
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30691 PyObject *resultobj = 0;
30692 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30693 int arg2 ;
30694 wxDateSpan *result = 0 ;
30695 void *argp1 = 0 ;
30696 int res1 = 0 ;
30697 int val2 ;
30698 int ecode2 = 0 ;
30699 PyObject * obj0 = 0 ;
30700 PyObject * obj1 = 0 ;
30701 char * kwnames[] = {
30702 (char *) "self",(char *) "n", NULL
30703 };
30704
30705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30707 if (!SWIG_IsOK(res1)) {
30708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30709 }
30710 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30711 ecode2 = SWIG_AsVal_int(obj1, &val2);
30712 if (!SWIG_IsOK(ecode2)) {
30713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30714 }
30715 arg2 = static_cast< int >(val2);
30716 {
30717 PyThreadState* __tstate = wxPyBeginAllowThreads();
30718 {
30719 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30720 result = (wxDateSpan *) &_result_ref;
30721 }
30722 wxPyEndAllowThreads(__tstate);
30723 if (PyErr_Occurred()) SWIG_fail;
30724 }
30725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30733 PyObject *resultobj = 0;
30734 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30735 int result;
30736 void *argp1 = 0 ;
30737 int res1 = 0 ;
30738 PyObject *swig_obj[1] ;
30739
30740 if (!args) SWIG_fail;
30741 swig_obj[0] = args;
30742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30743 if (!SWIG_IsOK(res1)) {
30744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30745 }
30746 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30747 {
30748 PyThreadState* __tstate = wxPyBeginAllowThreads();
30749 result = (int)((wxDateSpan const *)arg1)->GetYears();
30750 wxPyEndAllowThreads(__tstate);
30751 if (PyErr_Occurred()) SWIG_fail;
30752 }
30753 resultobj = SWIG_From_int(static_cast< int >(result));
30754 return resultobj;
30755 fail:
30756 return NULL;
30757 }
30758
30759
30760 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30761 PyObject *resultobj = 0;
30762 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30763 int result;
30764 void *argp1 = 0 ;
30765 int res1 = 0 ;
30766 PyObject *swig_obj[1] ;
30767
30768 if (!args) SWIG_fail;
30769 swig_obj[0] = args;
30770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30771 if (!SWIG_IsOK(res1)) {
30772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30773 }
30774 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30775 {
30776 PyThreadState* __tstate = wxPyBeginAllowThreads();
30777 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30778 wxPyEndAllowThreads(__tstate);
30779 if (PyErr_Occurred()) SWIG_fail;
30780 }
30781 resultobj = SWIG_From_int(static_cast< int >(result));
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30789 PyObject *resultobj = 0;
30790 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30791 int result;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 PyObject *swig_obj[1] ;
30795
30796 if (!args) SWIG_fail;
30797 swig_obj[0] = args;
30798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30799 if (!SWIG_IsOK(res1)) {
30800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30801 }
30802 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30803 {
30804 PyThreadState* __tstate = wxPyBeginAllowThreads();
30805 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30806 wxPyEndAllowThreads(__tstate);
30807 if (PyErr_Occurred()) SWIG_fail;
30808 }
30809 resultobj = SWIG_From_int(static_cast< int >(result));
30810 return resultobj;
30811 fail:
30812 return NULL;
30813 }
30814
30815
30816 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30817 PyObject *resultobj = 0;
30818 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30819 int result;
30820 void *argp1 = 0 ;
30821 int res1 = 0 ;
30822 PyObject *swig_obj[1] ;
30823
30824 if (!args) SWIG_fail;
30825 swig_obj[0] = args;
30826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30827 if (!SWIG_IsOK(res1)) {
30828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30829 }
30830 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30831 {
30832 PyThreadState* __tstate = wxPyBeginAllowThreads();
30833 result = (int)((wxDateSpan const *)arg1)->GetDays();
30834 wxPyEndAllowThreads(__tstate);
30835 if (PyErr_Occurred()) SWIG_fail;
30836 }
30837 resultobj = SWIG_From_int(static_cast< int >(result));
30838 return resultobj;
30839 fail:
30840 return NULL;
30841 }
30842
30843
30844 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30845 PyObject *resultobj = 0;
30846 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30847 int result;
30848 void *argp1 = 0 ;
30849 int res1 = 0 ;
30850 PyObject *swig_obj[1] ;
30851
30852 if (!args) SWIG_fail;
30853 swig_obj[0] = args;
30854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30855 if (!SWIG_IsOK(res1)) {
30856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30857 }
30858 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30859 {
30860 PyThreadState* __tstate = wxPyBeginAllowThreads();
30861 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 resultobj = SWIG_From_int(static_cast< int >(result));
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj = 0;
30874 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30875 wxDateSpan *arg2 = 0 ;
30876 wxDateSpan *result = 0 ;
30877 void *argp1 = 0 ;
30878 int res1 = 0 ;
30879 void *argp2 = 0 ;
30880 int res2 = 0 ;
30881 PyObject * obj0 = 0 ;
30882 PyObject * obj1 = 0 ;
30883 char * kwnames[] = {
30884 (char *) "self",(char *) "other", NULL
30885 };
30886
30887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30889 if (!SWIG_IsOK(res1)) {
30890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30891 }
30892 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30894 if (!SWIG_IsOK(res2)) {
30895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30896 }
30897 if (!argp2) {
30898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30899 }
30900 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30901 {
30902 PyThreadState* __tstate = wxPyBeginAllowThreads();
30903 {
30904 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30905 result = (wxDateSpan *) &_result_ref;
30906 }
30907 wxPyEndAllowThreads(__tstate);
30908 if (PyErr_Occurred()) SWIG_fail;
30909 }
30910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30911 return resultobj;
30912 fail:
30913 return NULL;
30914 }
30915
30916
30917 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30918 PyObject *resultobj = 0;
30919 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30920 wxDateSpan *arg2 = 0 ;
30921 wxDateSpan *result = 0 ;
30922 void *argp1 = 0 ;
30923 int res1 = 0 ;
30924 void *argp2 = 0 ;
30925 int res2 = 0 ;
30926 PyObject * obj0 = 0 ;
30927 PyObject * obj1 = 0 ;
30928 char * kwnames[] = {
30929 (char *) "self",(char *) "other", NULL
30930 };
30931
30932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30934 if (!SWIG_IsOK(res1)) {
30935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30936 }
30937 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30938 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30939 if (!SWIG_IsOK(res2)) {
30940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30941 }
30942 if (!argp2) {
30943 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30944 }
30945 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30946 {
30947 PyThreadState* __tstate = wxPyBeginAllowThreads();
30948 {
30949 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30950 result = (wxDateSpan *) &_result_ref;
30951 }
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30956 return resultobj;
30957 fail:
30958 return NULL;
30959 }
30960
30961
30962 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30963 PyObject *resultobj = 0;
30964 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30965 wxDateSpan *result = 0 ;
30966 void *argp1 = 0 ;
30967 int res1 = 0 ;
30968 PyObject *swig_obj[1] ;
30969
30970 if (!args) SWIG_fail;
30971 swig_obj[0] = args;
30972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30973 if (!SWIG_IsOK(res1)) {
30974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30975 }
30976 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 {
30980 wxDateSpan &_result_ref = (arg1)->Neg();
30981 result = (wxDateSpan *) &_result_ref;
30982 }
30983 wxPyEndAllowThreads(__tstate);
30984 if (PyErr_Occurred()) SWIG_fail;
30985 }
30986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj = 0;
30995 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30996 int arg2 ;
30997 wxDateSpan *result = 0 ;
30998 void *argp1 = 0 ;
30999 int res1 = 0 ;
31000 int val2 ;
31001 int ecode2 = 0 ;
31002 PyObject * obj0 = 0 ;
31003 PyObject * obj1 = 0 ;
31004 char * kwnames[] = {
31005 (char *) "self",(char *) "factor", NULL
31006 };
31007
31008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31010 if (!SWIG_IsOK(res1)) {
31011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31012 }
31013 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31014 ecode2 = SWIG_AsVal_int(obj1, &val2);
31015 if (!SWIG_IsOK(ecode2)) {
31016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31017 }
31018 arg2 = static_cast< int >(val2);
31019 {
31020 PyThreadState* __tstate = wxPyBeginAllowThreads();
31021 {
31022 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31023 result = (wxDateSpan *) &_result_ref;
31024 }
31025 wxPyEndAllowThreads(__tstate);
31026 if (PyErr_Occurred()) SWIG_fail;
31027 }
31028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31029 return resultobj;
31030 fail:
31031 return NULL;
31032 }
31033
31034
31035 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31036 PyObject *resultobj = 0;
31037 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31038 wxDateSpan *arg2 = 0 ;
31039 wxDateSpan *result = 0 ;
31040 void *argp1 = 0 ;
31041 int res1 = 0 ;
31042 void *argp2 = 0 ;
31043 int res2 = 0 ;
31044 PyObject * obj0 = 0 ;
31045 PyObject * obj1 = 0 ;
31046 char * kwnames[] = {
31047 (char *) "self",(char *) "other", NULL
31048 };
31049
31050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31052 if (!SWIG_IsOK(res1)) {
31053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31054 }
31055 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31056 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31057 if (!SWIG_IsOK(res2)) {
31058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31059 }
31060 if (!argp2) {
31061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31062 }
31063 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31064 {
31065 PyThreadState* __tstate = wxPyBeginAllowThreads();
31066 {
31067 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31068 result = (wxDateSpan *) &_result_ref;
31069 }
31070 wxPyEndAllowThreads(__tstate);
31071 if (PyErr_Occurred()) SWIG_fail;
31072 }
31073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31074 return resultobj;
31075 fail:
31076 return NULL;
31077 }
31078
31079
31080 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31081 PyObject *resultobj = 0;
31082 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31083 wxDateSpan *arg2 = 0 ;
31084 wxDateSpan *result = 0 ;
31085 void *argp1 = 0 ;
31086 int res1 = 0 ;
31087 void *argp2 = 0 ;
31088 int res2 = 0 ;
31089 PyObject * obj0 = 0 ;
31090 PyObject * obj1 = 0 ;
31091 char * kwnames[] = {
31092 (char *) "self",(char *) "other", NULL
31093 };
31094
31095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31097 if (!SWIG_IsOK(res1)) {
31098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31099 }
31100 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31102 if (!SWIG_IsOK(res2)) {
31103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31104 }
31105 if (!argp2) {
31106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31107 }
31108 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31109 {
31110 PyThreadState* __tstate = wxPyBeginAllowThreads();
31111 {
31112 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31113 result = (wxDateSpan *) &_result_ref;
31114 }
31115 wxPyEndAllowThreads(__tstate);
31116 if (PyErr_Occurred()) SWIG_fail;
31117 }
31118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31119 return resultobj;
31120 fail:
31121 return NULL;
31122 }
31123
31124
31125 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31126 PyObject *resultobj = 0;
31127 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31128 wxDateSpan *result = 0 ;
31129 void *argp1 = 0 ;
31130 int res1 = 0 ;
31131 PyObject *swig_obj[1] ;
31132
31133 if (!args) SWIG_fail;
31134 swig_obj[0] = args;
31135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31136 if (!SWIG_IsOK(res1)) {
31137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31138 }
31139 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31140 {
31141 PyThreadState* __tstate = wxPyBeginAllowThreads();
31142 {
31143 wxDateSpan &_result_ref = (arg1)->operator -();
31144 result = (wxDateSpan *) &_result_ref;
31145 }
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj = 0;
31158 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31159 int arg2 ;
31160 wxDateSpan *result = 0 ;
31161 void *argp1 = 0 ;
31162 int res1 = 0 ;
31163 int val2 ;
31164 int ecode2 = 0 ;
31165 PyObject * obj0 = 0 ;
31166 PyObject * obj1 = 0 ;
31167 char * kwnames[] = {
31168 (char *) "self",(char *) "factor", NULL
31169 };
31170
31171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31173 if (!SWIG_IsOK(res1)) {
31174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31175 }
31176 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31177 ecode2 = SWIG_AsVal_int(obj1, &val2);
31178 if (!SWIG_IsOK(ecode2)) {
31179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31180 }
31181 arg2 = static_cast< int >(val2);
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 {
31185 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31186 result = (wxDateSpan *) &_result_ref;
31187 }
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31192 return resultobj;
31193 fail:
31194 return NULL;
31195 }
31196
31197
31198 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31199 PyObject *resultobj = 0;
31200 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31201 wxDateSpan *arg2 = 0 ;
31202 wxDateSpan result;
31203 void *argp1 = 0 ;
31204 int res1 = 0 ;
31205 void *argp2 = 0 ;
31206 int res2 = 0 ;
31207 PyObject * obj0 = 0 ;
31208 PyObject * obj1 = 0 ;
31209 char * kwnames[] = {
31210 (char *) "self",(char *) "other", NULL
31211 };
31212
31213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31215 if (!SWIG_IsOK(res1)) {
31216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31217 }
31218 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31219 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31220 if (!SWIG_IsOK(res2)) {
31221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31222 }
31223 if (!argp2) {
31224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31225 }
31226 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31227 {
31228 PyThreadState* __tstate = wxPyBeginAllowThreads();
31229 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31230 wxPyEndAllowThreads(__tstate);
31231 if (PyErr_Occurred()) SWIG_fail;
31232 }
31233 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31234 return resultobj;
31235 fail:
31236 return NULL;
31237 }
31238
31239
31240 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31241 PyObject *resultobj = 0;
31242 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31243 wxDateSpan *arg2 = 0 ;
31244 wxDateSpan result;
31245 void *argp1 = 0 ;
31246 int res1 = 0 ;
31247 void *argp2 = 0 ;
31248 int res2 = 0 ;
31249 PyObject * obj0 = 0 ;
31250 PyObject * obj1 = 0 ;
31251 char * kwnames[] = {
31252 (char *) "self",(char *) "other", NULL
31253 };
31254
31255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31257 if (!SWIG_IsOK(res1)) {
31258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31259 }
31260 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31261 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31262 if (!SWIG_IsOK(res2)) {
31263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31264 }
31265 if (!argp2) {
31266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31267 }
31268 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31269 {
31270 PyThreadState* __tstate = wxPyBeginAllowThreads();
31271 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31283 PyObject *resultobj = 0;
31284 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31285 int arg2 ;
31286 wxDateSpan result;
31287 void *argp1 = 0 ;
31288 int res1 = 0 ;
31289 int val2 ;
31290 int ecode2 = 0 ;
31291 PyObject * obj0 = 0 ;
31292 PyObject * obj1 = 0 ;
31293 char * kwnames[] = {
31294 (char *) "self",(char *) "n", NULL
31295 };
31296
31297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31299 if (!SWIG_IsOK(res1)) {
31300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31301 }
31302 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31303 ecode2 = SWIG_AsVal_int(obj1, &val2);
31304 if (!SWIG_IsOK(ecode2)) {
31305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31306 }
31307 arg2 = static_cast< int >(val2);
31308 {
31309 PyThreadState* __tstate = wxPyBeginAllowThreads();
31310 result = wxDateSpan___mul__(arg1,arg2);
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31315 return resultobj;
31316 fail:
31317 return NULL;
31318 }
31319
31320
31321 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31322 PyObject *resultobj = 0;
31323 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31324 int arg2 ;
31325 wxDateSpan result;
31326 void *argp1 = 0 ;
31327 int res1 = 0 ;
31328 int val2 ;
31329 int ecode2 = 0 ;
31330 PyObject * obj0 = 0 ;
31331 PyObject * obj1 = 0 ;
31332 char * kwnames[] = {
31333 (char *) "self",(char *) "n", NULL
31334 };
31335
31336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31338 if (!SWIG_IsOK(res1)) {
31339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31340 }
31341 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31342 ecode2 = SWIG_AsVal_int(obj1, &val2);
31343 if (!SWIG_IsOK(ecode2)) {
31344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31345 }
31346 arg2 = static_cast< int >(val2);
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 result = wxDateSpan___rmul__(arg1,arg2);
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31354 return resultobj;
31355 fail:
31356 return NULL;
31357 }
31358
31359
31360 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31361 PyObject *resultobj = 0;
31362 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31363 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31364 bool result;
31365 void *argp1 = 0 ;
31366 int res1 = 0 ;
31367 void *argp2 = 0 ;
31368 int res2 = 0 ;
31369 PyObject * obj0 = 0 ;
31370 PyObject * obj1 = 0 ;
31371 char * kwnames[] = {
31372 (char *) "self",(char *) "other", NULL
31373 };
31374
31375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31377 if (!SWIG_IsOK(res1)) {
31378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31379 }
31380 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31382 if (!SWIG_IsOK(res2)) {
31383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31384 }
31385 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31386 {
31387 PyThreadState* __tstate = wxPyBeginAllowThreads();
31388 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 {
31393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31394 }
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31402 PyObject *resultobj = 0;
31403 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31404 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31405 bool result;
31406 void *argp1 = 0 ;
31407 int res1 = 0 ;
31408 void *argp2 = 0 ;
31409 int res2 = 0 ;
31410 PyObject * obj0 = 0 ;
31411 PyObject * obj1 = 0 ;
31412 char * kwnames[] = {
31413 (char *) "self",(char *) "other", NULL
31414 };
31415
31416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31418 if (!SWIG_IsOK(res1)) {
31419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31420 }
31421 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31422 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31423 if (!SWIG_IsOK(res2)) {
31424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31425 }
31426 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31427 {
31428 PyThreadState* __tstate = wxPyBeginAllowThreads();
31429 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31430 wxPyEndAllowThreads(__tstate);
31431 if (PyErr_Occurred()) SWIG_fail;
31432 }
31433 {
31434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31435 }
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31443 PyObject *obj;
31444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31445 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31446 return SWIG_Py_Void();
31447 }
31448
31449 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31450 return SWIG_Python_InitShadowInstance(args);
31451 }
31452
31453 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31454 PyObject *resultobj = 0;
31455 long result;
31456
31457 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 result = (long)wxGetLocalTime();
31461 wxPyEndAllowThreads(__tstate);
31462 if (PyErr_Occurred()) SWIG_fail;
31463 }
31464 resultobj = SWIG_From_long(static_cast< long >(result));
31465 return resultobj;
31466 fail:
31467 return NULL;
31468 }
31469
31470
31471 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31472 PyObject *resultobj = 0;
31473 long result;
31474
31475 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 result = (long)wxGetUTCTime();
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 resultobj = SWIG_From_long(static_cast< long >(result));
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31490 PyObject *resultobj = 0;
31491 long result;
31492
31493 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 result = (long)wxGetCurrentTime();
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 resultobj = SWIG_From_long(static_cast< long >(result));
31501 return resultobj;
31502 fail:
31503 return NULL;
31504 }
31505
31506
31507 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31508 PyObject *resultobj = 0;
31509 wxLongLong result;
31510
31511 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31512 {
31513 PyThreadState* __tstate = wxPyBeginAllowThreads();
31514 result = wxGetLocalTimeMillis();
31515 wxPyEndAllowThreads(__tstate);
31516 if (PyErr_Occurred()) SWIG_fail;
31517 }
31518 {
31519 PyObject *hi, *lo, *shifter, *shifted;
31520 hi = PyLong_FromLong( (&result)->GetHi() );
31521 lo = PyLong_FromLong( (&result)->GetLo() );
31522 shifter = PyLong_FromLong(32);
31523 shifted = PyNumber_Lshift(hi, shifter);
31524 resultobj = PyNumber_Or(shifted, lo);
31525 Py_DECREF(hi);
31526 Py_DECREF(lo);
31527 Py_DECREF(shifter);
31528 Py_DECREF(shifted);
31529 }
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31537 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31538 return 1;
31539 }
31540
31541
31542 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31543 PyObject *pyobj = 0;
31544
31545 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31546 return pyobj;
31547 }
31548
31549
31550 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31551 PyObject *resultobj = 0;
31552 wxDataFormatId arg1 ;
31553 wxDataFormat *result = 0 ;
31554 int val1 ;
31555 int ecode1 = 0 ;
31556 PyObject * obj0 = 0 ;
31557 char * kwnames[] = {
31558 (char *) "type", NULL
31559 };
31560
31561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31562 ecode1 = SWIG_AsVal_int(obj0, &val1);
31563 if (!SWIG_IsOK(ecode1)) {
31564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31565 }
31566 arg1 = static_cast< wxDataFormatId >(val1);
31567 {
31568 PyThreadState* __tstate = wxPyBeginAllowThreads();
31569 result = (wxDataFormat *)new wxDataFormat(arg1);
31570 wxPyEndAllowThreads(__tstate);
31571 if (PyErr_Occurred()) SWIG_fail;
31572 }
31573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31574 return resultobj;
31575 fail:
31576 return NULL;
31577 }
31578
31579
31580 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31581 PyObject *resultobj = 0;
31582 wxString *arg1 = 0 ;
31583 wxDataFormat *result = 0 ;
31584 bool temp1 = false ;
31585 PyObject * obj0 = 0 ;
31586 char * kwnames[] = {
31587 (char *) "format", NULL
31588 };
31589
31590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31591 {
31592 arg1 = wxString_in_helper(obj0);
31593 if (arg1 == NULL) SWIG_fail;
31594 temp1 = true;
31595 }
31596 {
31597 PyThreadState* __tstate = wxPyBeginAllowThreads();
31598 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31599 wxPyEndAllowThreads(__tstate);
31600 if (PyErr_Occurred()) SWIG_fail;
31601 }
31602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31603 {
31604 if (temp1)
31605 delete arg1;
31606 }
31607 return resultobj;
31608 fail:
31609 {
31610 if (temp1)
31611 delete arg1;
31612 }
31613 return NULL;
31614 }
31615
31616
31617 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31618 PyObject *resultobj = 0;
31619 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31620 void *argp1 = 0 ;
31621 int res1 = 0 ;
31622 PyObject *swig_obj[1] ;
31623
31624 if (!args) SWIG_fail;
31625 swig_obj[0] = args;
31626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31627 if (!SWIG_IsOK(res1)) {
31628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31629 }
31630 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31631 {
31632 PyThreadState* __tstate = wxPyBeginAllowThreads();
31633 delete arg1;
31634
31635 wxPyEndAllowThreads(__tstate);
31636 if (PyErr_Occurred()) SWIG_fail;
31637 }
31638 resultobj = SWIG_Py_Void();
31639 return resultobj;
31640 fail:
31641 return NULL;
31642 }
31643
31644
31645 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31646 PyObject *resultobj = 0;
31647 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31648 wxDataFormatId arg2 ;
31649 bool result;
31650 void *argp1 = 0 ;
31651 int res1 = 0 ;
31652 int val2 ;
31653 int ecode2 = 0 ;
31654
31655 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31657 if (!SWIG_IsOK(res1)) {
31658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31659 }
31660 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31661 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31662 if (!SWIG_IsOK(ecode2)) {
31663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31664 }
31665 arg2 = static_cast< wxDataFormatId >(val2);
31666 {
31667 PyThreadState* __tstate = wxPyBeginAllowThreads();
31668 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 {
31673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31674 }
31675 return resultobj;
31676 fail:
31677 return NULL;
31678 }
31679
31680
31681 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31682 PyObject *resultobj = 0;
31683 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31684 wxDataFormatId arg2 ;
31685 bool result;
31686 void *argp1 = 0 ;
31687 int res1 = 0 ;
31688 int val2 ;
31689 int ecode2 = 0 ;
31690
31691 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31693 if (!SWIG_IsOK(res1)) {
31694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31695 }
31696 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31697 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31698 if (!SWIG_IsOK(ecode2)) {
31699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31700 }
31701 arg2 = static_cast< wxDataFormatId >(val2);
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 {
31709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31710 }
31711 return resultobj;
31712 fail:
31713 return NULL;
31714 }
31715
31716
31717 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31718 PyObject *resultobj = 0;
31719 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31720 wxDataFormat *arg2 = 0 ;
31721 bool result;
31722 void *argp1 = 0 ;
31723 int res1 = 0 ;
31724 void *argp2 = 0 ;
31725 int res2 = 0 ;
31726
31727 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31729 if (!SWIG_IsOK(res1)) {
31730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31731 }
31732 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31733 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31734 if (!SWIG_IsOK(res2)) {
31735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31736 }
31737 if (!argp2) {
31738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31739 }
31740 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31741 {
31742 PyThreadState* __tstate = wxPyBeginAllowThreads();
31743 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31744 wxPyEndAllowThreads(__tstate);
31745 if (PyErr_Occurred()) SWIG_fail;
31746 }
31747 {
31748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31749 }
31750 return resultobj;
31751 fail:
31752 return NULL;
31753 }
31754
31755
31756 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31757 int argc;
31758 PyObject *argv[3];
31759
31760 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31761 --argc;
31762 if (argc == 2) {
31763 int _v = 0;
31764 {
31765 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31766 _v = SWIG_CheckState(res);
31767 }
31768 if (!_v) goto check_1;
31769 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31770 }
31771 check_1:
31772
31773 if (argc == 2) {
31774 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31775 }
31776
31777 fail:
31778 Py_INCREF(Py_NotImplemented);
31779 return Py_NotImplemented;
31780 }
31781
31782
31783 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31784 PyObject *resultobj = 0;
31785 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31786 wxDataFormat *arg2 = 0 ;
31787 bool result;
31788 void *argp1 = 0 ;
31789 int res1 = 0 ;
31790 void *argp2 = 0 ;
31791 int res2 = 0 ;
31792
31793 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31795 if (!SWIG_IsOK(res1)) {
31796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31797 }
31798 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31799 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31800 if (!SWIG_IsOK(res2)) {
31801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31802 }
31803 if (!argp2) {
31804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31805 }
31806 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31807 {
31808 PyThreadState* __tstate = wxPyBeginAllowThreads();
31809 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31810 wxPyEndAllowThreads(__tstate);
31811 if (PyErr_Occurred()) SWIG_fail;
31812 }
31813 {
31814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31815 }
31816 return resultobj;
31817 fail:
31818 return NULL;
31819 }
31820
31821
31822 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31823 int argc;
31824 PyObject *argv[3];
31825
31826 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31827 --argc;
31828 if (argc == 2) {
31829 int _v = 0;
31830 {
31831 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31832 _v = SWIG_CheckState(res);
31833 }
31834 if (!_v) goto check_1;
31835 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31836 }
31837 check_1:
31838
31839 if (argc == 2) {
31840 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31841 }
31842
31843 fail:
31844 Py_INCREF(Py_NotImplemented);
31845 return Py_NotImplemented;
31846 }
31847
31848
31849 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj = 0;
31851 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31852 wxDataFormatId arg2 ;
31853 void *argp1 = 0 ;
31854 int res1 = 0 ;
31855 int val2 ;
31856 int ecode2 = 0 ;
31857 PyObject * obj0 = 0 ;
31858 PyObject * obj1 = 0 ;
31859 char * kwnames[] = {
31860 (char *) "self",(char *) "format", NULL
31861 };
31862
31863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31865 if (!SWIG_IsOK(res1)) {
31866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31867 }
31868 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31869 ecode2 = SWIG_AsVal_int(obj1, &val2);
31870 if (!SWIG_IsOK(ecode2)) {
31871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31872 }
31873 arg2 = static_cast< wxDataFormatId >(val2);
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 (arg1)->SetType(arg2);
31877 wxPyEndAllowThreads(__tstate);
31878 if (PyErr_Occurred()) SWIG_fail;
31879 }
31880 resultobj = SWIG_Py_Void();
31881 return resultobj;
31882 fail:
31883 return NULL;
31884 }
31885
31886
31887 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31888 PyObject *resultobj = 0;
31889 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31890 wxDataFormatId result;
31891 void *argp1 = 0 ;
31892 int res1 = 0 ;
31893 PyObject *swig_obj[1] ;
31894
31895 if (!args) SWIG_fail;
31896 swig_obj[0] = args;
31897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31898 if (!SWIG_IsOK(res1)) {
31899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31900 }
31901 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31902 {
31903 PyThreadState* __tstate = wxPyBeginAllowThreads();
31904 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31905 wxPyEndAllowThreads(__tstate);
31906 if (PyErr_Occurred()) SWIG_fail;
31907 }
31908 resultobj = SWIG_From_int(static_cast< int >(result));
31909 return resultobj;
31910 fail:
31911 return NULL;
31912 }
31913
31914
31915 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31916 PyObject *resultobj = 0;
31917 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31918 wxString result;
31919 void *argp1 = 0 ;
31920 int res1 = 0 ;
31921 PyObject *swig_obj[1] ;
31922
31923 if (!args) SWIG_fail;
31924 swig_obj[0] = args;
31925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31926 if (!SWIG_IsOK(res1)) {
31927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31928 }
31929 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31930 {
31931 PyThreadState* __tstate = wxPyBeginAllowThreads();
31932 result = ((wxDataFormat const *)arg1)->GetId();
31933 wxPyEndAllowThreads(__tstate);
31934 if (PyErr_Occurred()) SWIG_fail;
31935 }
31936 {
31937 #if wxUSE_UNICODE
31938 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31939 #else
31940 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31941 #endif
31942 }
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31950 PyObject *resultobj = 0;
31951 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31952 wxString *arg2 = 0 ;
31953 void *argp1 = 0 ;
31954 int res1 = 0 ;
31955 bool temp2 = false ;
31956 PyObject * obj0 = 0 ;
31957 PyObject * obj1 = 0 ;
31958 char * kwnames[] = {
31959 (char *) "self",(char *) "format", NULL
31960 };
31961
31962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31964 if (!SWIG_IsOK(res1)) {
31965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31966 }
31967 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31968 {
31969 arg2 = wxString_in_helper(obj1);
31970 if (arg2 == NULL) SWIG_fail;
31971 temp2 = true;
31972 }
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 (arg1)->SetId((wxString const &)*arg2);
31976 wxPyEndAllowThreads(__tstate);
31977 if (PyErr_Occurred()) SWIG_fail;
31978 }
31979 resultobj = SWIG_Py_Void();
31980 {
31981 if (temp2)
31982 delete arg2;
31983 }
31984 return resultobj;
31985 fail:
31986 {
31987 if (temp2)
31988 delete arg2;
31989 }
31990 return NULL;
31991 }
31992
31993
31994 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31995 PyObject *obj;
31996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31997 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31998 return SWIG_Py_Void();
31999 }
32000
32001 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32002 return SWIG_Python_InitShadowInstance(args);
32003 }
32004
32005 SWIGINTERN int FormatInvalid_set(PyObject *) {
32006 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32007 return 1;
32008 }
32009
32010
32011 SWIGINTERN PyObject *FormatInvalid_get(void) {
32012 PyObject *pyobj = 0;
32013
32014 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32015 return pyobj;
32016 }
32017
32018
32019 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32020 PyObject *resultobj = 0;
32021 wxDataObject *arg1 = (wxDataObject *) 0 ;
32022 void *argp1 = 0 ;
32023 int res1 = 0 ;
32024 PyObject *swig_obj[1] ;
32025
32026 if (!args) SWIG_fail;
32027 swig_obj[0] = args;
32028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32029 if (!SWIG_IsOK(res1)) {
32030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32031 }
32032 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 delete arg1;
32036
32037 wxPyEndAllowThreads(__tstate);
32038 if (PyErr_Occurred()) SWIG_fail;
32039 }
32040 resultobj = SWIG_Py_Void();
32041 return resultobj;
32042 fail:
32043 return NULL;
32044 }
32045
32046
32047 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32048 PyObject *resultobj = 0;
32049 wxDataObject *arg1 = (wxDataObject *) 0 ;
32050 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32051 SwigValueWrapper<wxDataFormat > result;
32052 void *argp1 = 0 ;
32053 int res1 = 0 ;
32054 int val2 ;
32055 int ecode2 = 0 ;
32056 PyObject * obj0 = 0 ;
32057 PyObject * obj1 = 0 ;
32058 char * kwnames[] = {
32059 (char *) "self",(char *) "dir", NULL
32060 };
32061
32062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32064 if (!SWIG_IsOK(res1)) {
32065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32066 }
32067 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32068 if (obj1) {
32069 ecode2 = SWIG_AsVal_int(obj1, &val2);
32070 if (!SWIG_IsOK(ecode2)) {
32071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32072 }
32073 arg2 = static_cast< wxDataObject::Direction >(val2);
32074 }
32075 {
32076 PyThreadState* __tstate = wxPyBeginAllowThreads();
32077 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32078 wxPyEndAllowThreads(__tstate);
32079 if (PyErr_Occurred()) SWIG_fail;
32080 }
32081 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32089 PyObject *resultobj = 0;
32090 wxDataObject *arg1 = (wxDataObject *) 0 ;
32091 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32092 size_t result;
32093 void *argp1 = 0 ;
32094 int res1 = 0 ;
32095 int val2 ;
32096 int ecode2 = 0 ;
32097 PyObject * obj0 = 0 ;
32098 PyObject * obj1 = 0 ;
32099 char * kwnames[] = {
32100 (char *) "self",(char *) "dir", NULL
32101 };
32102
32103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32105 if (!SWIG_IsOK(res1)) {
32106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32107 }
32108 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32109 if (obj1) {
32110 ecode2 = SWIG_AsVal_int(obj1, &val2);
32111 if (!SWIG_IsOK(ecode2)) {
32112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32113 }
32114 arg2 = static_cast< wxDataObject::Direction >(val2);
32115 }
32116 {
32117 PyThreadState* __tstate = wxPyBeginAllowThreads();
32118 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32123 return resultobj;
32124 fail:
32125 return NULL;
32126 }
32127
32128
32129 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32130 PyObject *resultobj = 0;
32131 wxDataObject *arg1 = (wxDataObject *) 0 ;
32132 wxDataFormat *arg2 = 0 ;
32133 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32134 bool result;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 void *argp2 = 0 ;
32138 int res2 = 0 ;
32139 int val3 ;
32140 int ecode3 = 0 ;
32141 PyObject * obj0 = 0 ;
32142 PyObject * obj1 = 0 ;
32143 PyObject * obj2 = 0 ;
32144 char * kwnames[] = {
32145 (char *) "self",(char *) "format",(char *) "dir", NULL
32146 };
32147
32148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32150 if (!SWIG_IsOK(res1)) {
32151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32152 }
32153 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32154 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32155 if (!SWIG_IsOK(res2)) {
32156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32157 }
32158 if (!argp2) {
32159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32160 }
32161 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32162 if (obj2) {
32163 ecode3 = SWIG_AsVal_int(obj2, &val3);
32164 if (!SWIG_IsOK(ecode3)) {
32165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32166 }
32167 arg3 = static_cast< wxDataObject::Direction >(val3);
32168 }
32169 {
32170 PyThreadState* __tstate = wxPyBeginAllowThreads();
32171 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32172 wxPyEndAllowThreads(__tstate);
32173 if (PyErr_Occurred()) SWIG_fail;
32174 }
32175 {
32176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32177 }
32178 return resultobj;
32179 fail:
32180 return NULL;
32181 }
32182
32183
32184 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32185 PyObject *resultobj = 0;
32186 wxDataObject *arg1 = (wxDataObject *) 0 ;
32187 wxDataFormat *arg2 = 0 ;
32188 size_t result;
32189 void *argp1 = 0 ;
32190 int res1 = 0 ;
32191 void *argp2 = 0 ;
32192 int res2 = 0 ;
32193 PyObject * obj0 = 0 ;
32194 PyObject * obj1 = 0 ;
32195 char * kwnames[] = {
32196 (char *) "self",(char *) "format", NULL
32197 };
32198
32199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32201 if (!SWIG_IsOK(res1)) {
32202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32203 }
32204 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32206 if (!SWIG_IsOK(res2)) {
32207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32208 }
32209 if (!argp2) {
32210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32211 }
32212 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32213 {
32214 PyThreadState* __tstate = wxPyBeginAllowThreads();
32215 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32216 wxPyEndAllowThreads(__tstate);
32217 if (PyErr_Occurred()) SWIG_fail;
32218 }
32219 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32220 return resultobj;
32221 fail:
32222 return NULL;
32223 }
32224
32225
32226 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32227 PyObject *resultobj = 0;
32228 wxDataObject *arg1 = (wxDataObject *) 0 ;
32229 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32230 PyObject *result = 0 ;
32231 void *argp1 = 0 ;
32232 int res1 = 0 ;
32233 int val2 ;
32234 int ecode2 = 0 ;
32235 PyObject * obj0 = 0 ;
32236 PyObject * obj1 = 0 ;
32237 char * kwnames[] = {
32238 (char *) "self",(char *) "dir", NULL
32239 };
32240
32241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32243 if (!SWIG_IsOK(res1)) {
32244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32245 }
32246 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32247 if (obj1) {
32248 ecode2 = SWIG_AsVal_int(obj1, &val2);
32249 if (!SWIG_IsOK(ecode2)) {
32250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32251 }
32252 arg2 = static_cast< wxDataObject::Direction >(val2);
32253 }
32254 {
32255 PyThreadState* __tstate = wxPyBeginAllowThreads();
32256 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32257 wxPyEndAllowThreads(__tstate);
32258 if (PyErr_Occurred()) SWIG_fail;
32259 }
32260 resultobj = result;
32261 return resultobj;
32262 fail:
32263 return NULL;
32264 }
32265
32266
32267 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32268 PyObject *resultobj = 0;
32269 wxDataObject *arg1 = (wxDataObject *) 0 ;
32270 wxDataFormat *arg2 = 0 ;
32271 PyObject *result = 0 ;
32272 void *argp1 = 0 ;
32273 int res1 = 0 ;
32274 void *argp2 = 0 ;
32275 int res2 = 0 ;
32276 PyObject * obj0 = 0 ;
32277 PyObject * obj1 = 0 ;
32278 char * kwnames[] = {
32279 (char *) "self",(char *) "format", NULL
32280 };
32281
32282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32284 if (!SWIG_IsOK(res1)) {
32285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32286 }
32287 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32289 if (!SWIG_IsOK(res2)) {
32290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32291 }
32292 if (!argp2) {
32293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32294 }
32295 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32296 {
32297 PyThreadState* __tstate = wxPyBeginAllowThreads();
32298 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32299 wxPyEndAllowThreads(__tstate);
32300 if (PyErr_Occurred()) SWIG_fail;
32301 }
32302 resultobj = result;
32303 return resultobj;
32304 fail:
32305 return NULL;
32306 }
32307
32308
32309 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32310 PyObject *resultobj = 0;
32311 wxDataObject *arg1 = (wxDataObject *) 0 ;
32312 wxDataFormat *arg2 = 0 ;
32313 PyObject *arg3 = (PyObject *) 0 ;
32314 bool result;
32315 void *argp1 = 0 ;
32316 int res1 = 0 ;
32317 void *argp2 = 0 ;
32318 int res2 = 0 ;
32319 PyObject * obj0 = 0 ;
32320 PyObject * obj1 = 0 ;
32321 PyObject * obj2 = 0 ;
32322 char * kwnames[] = {
32323 (char *) "self",(char *) "format",(char *) "data", NULL
32324 };
32325
32326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32328 if (!SWIG_IsOK(res1)) {
32329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32330 }
32331 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32332 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32333 if (!SWIG_IsOK(res2)) {
32334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32335 }
32336 if (!argp2) {
32337 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32338 }
32339 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32340 arg3 = obj2;
32341 {
32342 PyThreadState* __tstate = wxPyBeginAllowThreads();
32343 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32344 wxPyEndAllowThreads(__tstate);
32345 if (PyErr_Occurred()) SWIG_fail;
32346 }
32347 {
32348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32349 }
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32357 PyObject *obj;
32358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32359 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32360 return SWIG_Py_Void();
32361 }
32362
32363 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32364 PyObject *resultobj = 0;
32365 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32366 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32367 wxDataObjectSimple *result = 0 ;
32368 void *argp1 = 0 ;
32369 int res1 = 0 ;
32370 PyObject * obj0 = 0 ;
32371 char * kwnames[] = {
32372 (char *) "format", NULL
32373 };
32374
32375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32376 if (obj0) {
32377 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32378 if (!SWIG_IsOK(res1)) {
32379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32380 }
32381 if (!argp1) {
32382 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32383 }
32384 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32385 }
32386 {
32387 PyThreadState* __tstate = wxPyBeginAllowThreads();
32388 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32389 wxPyEndAllowThreads(__tstate);
32390 if (PyErr_Occurred()) SWIG_fail;
32391 }
32392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32393 return resultobj;
32394 fail:
32395 return NULL;
32396 }
32397
32398
32399 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32400 PyObject *resultobj = 0;
32401 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32402 wxDataFormat *result = 0 ;
32403 void *argp1 = 0 ;
32404 int res1 = 0 ;
32405 PyObject *swig_obj[1] ;
32406
32407 if (!args) SWIG_fail;
32408 swig_obj[0] = args;
32409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32412 }
32413 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32414 {
32415 PyThreadState* __tstate = wxPyBeginAllowThreads();
32416 {
32417 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32418 result = (wxDataFormat *) &_result_ref;
32419 }
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32431 PyObject *resultobj = 0;
32432 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32433 wxDataFormat *arg2 = 0 ;
32434 void *argp1 = 0 ;
32435 int res1 = 0 ;
32436 void *argp2 = 0 ;
32437 int res2 = 0 ;
32438 PyObject * obj0 = 0 ;
32439 PyObject * obj1 = 0 ;
32440 char * kwnames[] = {
32441 (char *) "self",(char *) "format", NULL
32442 };
32443
32444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32446 if (!SWIG_IsOK(res1)) {
32447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32448 }
32449 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32451 if (!SWIG_IsOK(res2)) {
32452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32453 }
32454 if (!argp2) {
32455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32456 }
32457 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32458 {
32459 PyThreadState* __tstate = wxPyBeginAllowThreads();
32460 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32461 wxPyEndAllowThreads(__tstate);
32462 if (PyErr_Occurred()) SWIG_fail;
32463 }
32464 resultobj = SWIG_Py_Void();
32465 return resultobj;
32466 fail:
32467 return NULL;
32468 }
32469
32470
32471 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32472 PyObject *resultobj = 0;
32473 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32474 size_t result;
32475 void *argp1 = 0 ;
32476 int res1 = 0 ;
32477 PyObject *swig_obj[1] ;
32478
32479 if (!args) SWIG_fail;
32480 swig_obj[0] = args;
32481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32482 if (!SWIG_IsOK(res1)) {
32483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32484 }
32485 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32486 {
32487 PyThreadState* __tstate = wxPyBeginAllowThreads();
32488 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32489 wxPyEndAllowThreads(__tstate);
32490 if (PyErr_Occurred()) SWIG_fail;
32491 }
32492 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32493 return resultobj;
32494 fail:
32495 return NULL;
32496 }
32497
32498
32499 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32500 PyObject *resultobj = 0;
32501 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32502 PyObject *result = 0 ;
32503 void *argp1 = 0 ;
32504 int res1 = 0 ;
32505 PyObject *swig_obj[1] ;
32506
32507 if (!args) SWIG_fail;
32508 swig_obj[0] = args;
32509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32510 if (!SWIG_IsOK(res1)) {
32511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32512 }
32513 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32514 {
32515 PyThreadState* __tstate = wxPyBeginAllowThreads();
32516 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32517 wxPyEndAllowThreads(__tstate);
32518 if (PyErr_Occurred()) SWIG_fail;
32519 }
32520 resultobj = result;
32521 return resultobj;
32522 fail:
32523 return NULL;
32524 }
32525
32526
32527 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32528 PyObject *resultobj = 0;
32529 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32530 PyObject *arg2 = (PyObject *) 0 ;
32531 bool result;
32532 void *argp1 = 0 ;
32533 int res1 = 0 ;
32534 PyObject * obj0 = 0 ;
32535 PyObject * obj1 = 0 ;
32536 char * kwnames[] = {
32537 (char *) "self",(char *) "data", NULL
32538 };
32539
32540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32542 if (!SWIG_IsOK(res1)) {
32543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32544 }
32545 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32546 arg2 = obj1;
32547 {
32548 PyThreadState* __tstate = wxPyBeginAllowThreads();
32549 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32550 wxPyEndAllowThreads(__tstate);
32551 if (PyErr_Occurred()) SWIG_fail;
32552 }
32553 {
32554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32555 }
32556 return resultobj;
32557 fail:
32558 return NULL;
32559 }
32560
32561
32562 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32563 PyObject *obj;
32564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32565 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32566 return SWIG_Py_Void();
32567 }
32568
32569 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32570 return SWIG_Python_InitShadowInstance(args);
32571 }
32572
32573 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32574 PyObject *resultobj = 0;
32575 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32576 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32577 wxPyDataObjectSimple *result = 0 ;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 PyObject * obj0 = 0 ;
32581 char * kwnames[] = {
32582 (char *) "format", NULL
32583 };
32584
32585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32586 if (obj0) {
32587 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32588 if (!SWIG_IsOK(res1)) {
32589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32590 }
32591 if (!argp1) {
32592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32593 }
32594 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32595 }
32596 {
32597 PyThreadState* __tstate = wxPyBeginAllowThreads();
32598 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32599 wxPyEndAllowThreads(__tstate);
32600 if (PyErr_Occurred()) SWIG_fail;
32601 }
32602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32603 return resultobj;
32604 fail:
32605 return NULL;
32606 }
32607
32608
32609 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32610 PyObject *resultobj = 0;
32611 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32612 PyObject *arg2 = (PyObject *) 0 ;
32613 PyObject *arg3 = (PyObject *) 0 ;
32614 void *argp1 = 0 ;
32615 int res1 = 0 ;
32616 PyObject * obj0 = 0 ;
32617 PyObject * obj1 = 0 ;
32618 PyObject * obj2 = 0 ;
32619 char * kwnames[] = {
32620 (char *) "self",(char *) "self",(char *) "_class", NULL
32621 };
32622
32623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32625 if (!SWIG_IsOK(res1)) {
32626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32627 }
32628 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32629 arg2 = obj1;
32630 arg3 = obj2;
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 (arg1)->_setCallbackInfo(arg2,arg3);
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 resultobj = SWIG_Py_Void();
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32645 PyObject *obj;
32646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32647 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32648 return SWIG_Py_Void();
32649 }
32650
32651 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32652 return SWIG_Python_InitShadowInstance(args);
32653 }
32654
32655 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32656 PyObject *resultobj = 0;
32657 wxDataObjectComposite *result = 0 ;
32658
32659 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32660 {
32661 PyThreadState* __tstate = wxPyBeginAllowThreads();
32662 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32663 wxPyEndAllowThreads(__tstate);
32664 if (PyErr_Occurred()) SWIG_fail;
32665 }
32666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32667 return resultobj;
32668 fail:
32669 return NULL;
32670 }
32671
32672
32673 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj = 0;
32675 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32676 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32677 bool arg3 = (bool) false ;
32678 void *argp1 = 0 ;
32679 int res1 = 0 ;
32680 int res2 = 0 ;
32681 bool val3 ;
32682 int ecode3 = 0 ;
32683 PyObject * obj0 = 0 ;
32684 PyObject * obj1 = 0 ;
32685 PyObject * obj2 = 0 ;
32686 char * kwnames[] = {
32687 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32688 };
32689
32690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32692 if (!SWIG_IsOK(res1)) {
32693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32694 }
32695 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32696 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32697 if (!SWIG_IsOK(res2)) {
32698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32699 }
32700 if (obj2) {
32701 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32702 if (!SWIG_IsOK(ecode3)) {
32703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32704 }
32705 arg3 = static_cast< bool >(val3);
32706 }
32707 {
32708 PyThreadState* __tstate = wxPyBeginAllowThreads();
32709 (arg1)->Add(arg2,arg3);
32710 wxPyEndAllowThreads(__tstate);
32711 if (PyErr_Occurred()) SWIG_fail;
32712 }
32713 resultobj = SWIG_Py_Void();
32714 return resultobj;
32715 fail:
32716 return NULL;
32717 }
32718
32719
32720 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32721 PyObject *resultobj = 0;
32722 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32723 SwigValueWrapper<wxDataFormat > result;
32724 void *argp1 = 0 ;
32725 int res1 = 0 ;
32726 PyObject *swig_obj[1] ;
32727
32728 if (!args) SWIG_fail;
32729 swig_obj[0] = args;
32730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32731 if (!SWIG_IsOK(res1)) {
32732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32733 }
32734 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32735 {
32736 PyThreadState* __tstate = wxPyBeginAllowThreads();
32737 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32738 wxPyEndAllowThreads(__tstate);
32739 if (PyErr_Occurred()) SWIG_fail;
32740 }
32741 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32742 return resultobj;
32743 fail:
32744 return NULL;
32745 }
32746
32747
32748 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32749 PyObject *obj;
32750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32751 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32752 return SWIG_Py_Void();
32753 }
32754
32755 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32756 return SWIG_Python_InitShadowInstance(args);
32757 }
32758
32759 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32760 PyObject *resultobj = 0;
32761 wxString const &arg1_defvalue = wxPyEmptyString ;
32762 wxString *arg1 = (wxString *) &arg1_defvalue ;
32763 wxTextDataObject *result = 0 ;
32764 bool temp1 = false ;
32765 PyObject * obj0 = 0 ;
32766 char * kwnames[] = {
32767 (char *) "text", NULL
32768 };
32769
32770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32771 if (obj0) {
32772 {
32773 arg1 = wxString_in_helper(obj0);
32774 if (arg1 == NULL) SWIG_fail;
32775 temp1 = true;
32776 }
32777 }
32778 {
32779 PyThreadState* __tstate = wxPyBeginAllowThreads();
32780 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32781 wxPyEndAllowThreads(__tstate);
32782 if (PyErr_Occurred()) SWIG_fail;
32783 }
32784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32785 {
32786 if (temp1)
32787 delete arg1;
32788 }
32789 return resultobj;
32790 fail:
32791 {
32792 if (temp1)
32793 delete arg1;
32794 }
32795 return NULL;
32796 }
32797
32798
32799 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32800 PyObject *resultobj = 0;
32801 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32802 size_t result;
32803 void *argp1 = 0 ;
32804 int res1 = 0 ;
32805 PyObject *swig_obj[1] ;
32806
32807 if (!args) SWIG_fail;
32808 swig_obj[0] = args;
32809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32810 if (!SWIG_IsOK(res1)) {
32811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32812 }
32813 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32814 {
32815 PyThreadState* __tstate = wxPyBeginAllowThreads();
32816 result = (size_t)(arg1)->GetTextLength();
32817 wxPyEndAllowThreads(__tstate);
32818 if (PyErr_Occurred()) SWIG_fail;
32819 }
32820 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32821 return resultobj;
32822 fail:
32823 return NULL;
32824 }
32825
32826
32827 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32828 PyObject *resultobj = 0;
32829 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32830 wxString result;
32831 void *argp1 = 0 ;
32832 int res1 = 0 ;
32833 PyObject *swig_obj[1] ;
32834
32835 if (!args) SWIG_fail;
32836 swig_obj[0] = args;
32837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32838 if (!SWIG_IsOK(res1)) {
32839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32840 }
32841 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32842 {
32843 PyThreadState* __tstate = wxPyBeginAllowThreads();
32844 result = (arg1)->GetText();
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 {
32849 #if wxUSE_UNICODE
32850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32851 #else
32852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32853 #endif
32854 }
32855 return resultobj;
32856 fail:
32857 return NULL;
32858 }
32859
32860
32861 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32862 PyObject *resultobj = 0;
32863 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32864 wxString *arg2 = 0 ;
32865 void *argp1 = 0 ;
32866 int res1 = 0 ;
32867 bool temp2 = false ;
32868 PyObject * obj0 = 0 ;
32869 PyObject * obj1 = 0 ;
32870 char * kwnames[] = {
32871 (char *) "self",(char *) "text", NULL
32872 };
32873
32874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32876 if (!SWIG_IsOK(res1)) {
32877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32878 }
32879 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32880 {
32881 arg2 = wxString_in_helper(obj1);
32882 if (arg2 == NULL) SWIG_fail;
32883 temp2 = true;
32884 }
32885 {
32886 PyThreadState* __tstate = wxPyBeginAllowThreads();
32887 (arg1)->SetText((wxString const &)*arg2);
32888 wxPyEndAllowThreads(__tstate);
32889 if (PyErr_Occurred()) SWIG_fail;
32890 }
32891 resultobj = SWIG_Py_Void();
32892 {
32893 if (temp2)
32894 delete arg2;
32895 }
32896 return resultobj;
32897 fail:
32898 {
32899 if (temp2)
32900 delete arg2;
32901 }
32902 return NULL;
32903 }
32904
32905
32906 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32907 PyObject *obj;
32908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32909 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32910 return SWIG_Py_Void();
32911 }
32912
32913 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32914 return SWIG_Python_InitShadowInstance(args);
32915 }
32916
32917 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32918 PyObject *resultobj = 0;
32919 wxString const &arg1_defvalue = wxPyEmptyString ;
32920 wxString *arg1 = (wxString *) &arg1_defvalue ;
32921 wxPyTextDataObject *result = 0 ;
32922 bool temp1 = false ;
32923 PyObject * obj0 = 0 ;
32924 char * kwnames[] = {
32925 (char *) "text", NULL
32926 };
32927
32928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32929 if (obj0) {
32930 {
32931 arg1 = wxString_in_helper(obj0);
32932 if (arg1 == NULL) SWIG_fail;
32933 temp1 = true;
32934 }
32935 }
32936 {
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32943 {
32944 if (temp1)
32945 delete arg1;
32946 }
32947 return resultobj;
32948 fail:
32949 {
32950 if (temp1)
32951 delete arg1;
32952 }
32953 return NULL;
32954 }
32955
32956
32957 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32958 PyObject *resultobj = 0;
32959 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32960 PyObject *arg2 = (PyObject *) 0 ;
32961 PyObject *arg3 = (PyObject *) 0 ;
32962 void *argp1 = 0 ;
32963 int res1 = 0 ;
32964 PyObject * obj0 = 0 ;
32965 PyObject * obj1 = 0 ;
32966 PyObject * obj2 = 0 ;
32967 char * kwnames[] = {
32968 (char *) "self",(char *) "self",(char *) "_class", NULL
32969 };
32970
32971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32973 if (!SWIG_IsOK(res1)) {
32974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32975 }
32976 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32977 arg2 = obj1;
32978 arg3 = obj2;
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 (arg1)->_setCallbackInfo(arg2,arg3);
32982 wxPyEndAllowThreads(__tstate);
32983 if (PyErr_Occurred()) SWIG_fail;
32984 }
32985 resultobj = SWIG_Py_Void();
32986 return resultobj;
32987 fail:
32988 return NULL;
32989 }
32990
32991
32992 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32993 PyObject *obj;
32994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32995 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32996 return SWIG_Py_Void();
32997 }
32998
32999 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33000 return SWIG_Python_InitShadowInstance(args);
33001 }
33002
33003 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33004 PyObject *resultobj = 0;
33005 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33006 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33007 wxBitmapDataObject *result = 0 ;
33008 void *argp1 = 0 ;
33009 int res1 = 0 ;
33010 PyObject * obj0 = 0 ;
33011 char * kwnames[] = {
33012 (char *) "bitmap", NULL
33013 };
33014
33015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33016 if (obj0) {
33017 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33018 if (!SWIG_IsOK(res1)) {
33019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33020 }
33021 if (!argp1) {
33022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33023 }
33024 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33025 }
33026 {
33027 PyThreadState* __tstate = wxPyBeginAllowThreads();
33028 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33029 wxPyEndAllowThreads(__tstate);
33030 if (PyErr_Occurred()) SWIG_fail;
33031 }
33032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33033 return resultobj;
33034 fail:
33035 return NULL;
33036 }
33037
33038
33039 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33040 PyObject *resultobj = 0;
33041 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33042 wxBitmap result;
33043 void *argp1 = 0 ;
33044 int res1 = 0 ;
33045 PyObject *swig_obj[1] ;
33046
33047 if (!args) SWIG_fail;
33048 swig_obj[0] = args;
33049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33050 if (!SWIG_IsOK(res1)) {
33051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33052 }
33053 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33054 {
33055 PyThreadState* __tstate = wxPyBeginAllowThreads();
33056 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33057 wxPyEndAllowThreads(__tstate);
33058 if (PyErr_Occurred()) SWIG_fail;
33059 }
33060 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33061 return resultobj;
33062 fail:
33063 return NULL;
33064 }
33065
33066
33067 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33068 PyObject *resultobj = 0;
33069 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33070 wxBitmap *arg2 = 0 ;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073 void *argp2 = 0 ;
33074 int res2 = 0 ;
33075 PyObject * obj0 = 0 ;
33076 PyObject * obj1 = 0 ;
33077 char * kwnames[] = {
33078 (char *) "self",(char *) "bitmap", NULL
33079 };
33080
33081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33083 if (!SWIG_IsOK(res1)) {
33084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33085 }
33086 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33088 if (!SWIG_IsOK(res2)) {
33089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33090 }
33091 if (!argp2) {
33092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33093 }
33094 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33095 {
33096 PyThreadState* __tstate = wxPyBeginAllowThreads();
33097 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33098 wxPyEndAllowThreads(__tstate);
33099 if (PyErr_Occurred()) SWIG_fail;
33100 }
33101 resultobj = SWIG_Py_Void();
33102 return resultobj;
33103 fail:
33104 return NULL;
33105 }
33106
33107
33108 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33109 PyObject *obj;
33110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33111 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33112 return SWIG_Py_Void();
33113 }
33114
33115 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33116 return SWIG_Python_InitShadowInstance(args);
33117 }
33118
33119 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33120 PyObject *resultobj = 0;
33121 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33122 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33123 wxPyBitmapDataObject *result = 0 ;
33124 void *argp1 = 0 ;
33125 int res1 = 0 ;
33126 PyObject * obj0 = 0 ;
33127 char * kwnames[] = {
33128 (char *) "bitmap", NULL
33129 };
33130
33131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33132 if (obj0) {
33133 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33134 if (!SWIG_IsOK(res1)) {
33135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33136 }
33137 if (!argp1) {
33138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33139 }
33140 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33141 }
33142 {
33143 PyThreadState* __tstate = wxPyBeginAllowThreads();
33144 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33145 wxPyEndAllowThreads(__tstate);
33146 if (PyErr_Occurred()) SWIG_fail;
33147 }
33148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33149 return resultobj;
33150 fail:
33151 return NULL;
33152 }
33153
33154
33155 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33156 PyObject *resultobj = 0;
33157 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33158 PyObject *arg2 = (PyObject *) 0 ;
33159 PyObject *arg3 = (PyObject *) 0 ;
33160 void *argp1 = 0 ;
33161 int res1 = 0 ;
33162 PyObject * obj0 = 0 ;
33163 PyObject * obj1 = 0 ;
33164 PyObject * obj2 = 0 ;
33165 char * kwnames[] = {
33166 (char *) "self",(char *) "self",(char *) "_class", NULL
33167 };
33168
33169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33171 if (!SWIG_IsOK(res1)) {
33172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33173 }
33174 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33175 arg2 = obj1;
33176 arg3 = obj2;
33177 {
33178 PyThreadState* __tstate = wxPyBeginAllowThreads();
33179 (arg1)->_setCallbackInfo(arg2,arg3);
33180 wxPyEndAllowThreads(__tstate);
33181 if (PyErr_Occurred()) SWIG_fail;
33182 }
33183 resultobj = SWIG_Py_Void();
33184 return resultobj;
33185 fail:
33186 return NULL;
33187 }
33188
33189
33190 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33191 PyObject *obj;
33192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33193 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33194 return SWIG_Py_Void();
33195 }
33196
33197 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33198 return SWIG_Python_InitShadowInstance(args);
33199 }
33200
33201 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33202 PyObject *resultobj = 0;
33203 wxFileDataObject *result = 0 ;
33204
33205 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33206 {
33207 PyThreadState* __tstate = wxPyBeginAllowThreads();
33208 result = (wxFileDataObject *)new wxFileDataObject();
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33213 return resultobj;
33214 fail:
33215 return NULL;
33216 }
33217
33218
33219 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33220 PyObject *resultobj = 0;
33221 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33222 wxArrayString *result = 0 ;
33223 void *argp1 = 0 ;
33224 int res1 = 0 ;
33225 PyObject *swig_obj[1] ;
33226
33227 if (!args) SWIG_fail;
33228 swig_obj[0] = args;
33229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33230 if (!SWIG_IsOK(res1)) {
33231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33232 }
33233 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33234 {
33235 PyThreadState* __tstate = wxPyBeginAllowThreads();
33236 {
33237 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33238 result = (wxArrayString *) &_result_ref;
33239 }
33240 wxPyEndAllowThreads(__tstate);
33241 if (PyErr_Occurred()) SWIG_fail;
33242 }
33243 {
33244 resultobj = wxArrayString2PyList_helper(*result);
33245 }
33246 return resultobj;
33247 fail:
33248 return NULL;
33249 }
33250
33251
33252 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33253 PyObject *resultobj = 0;
33254 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33255 wxString *arg2 = 0 ;
33256 void *argp1 = 0 ;
33257 int res1 = 0 ;
33258 bool temp2 = false ;
33259 PyObject * obj0 = 0 ;
33260 PyObject * obj1 = 0 ;
33261 char * kwnames[] = {
33262 (char *) "self",(char *) "filename", NULL
33263 };
33264
33265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33267 if (!SWIG_IsOK(res1)) {
33268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33269 }
33270 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33271 {
33272 arg2 = wxString_in_helper(obj1);
33273 if (arg2 == NULL) SWIG_fail;
33274 temp2 = true;
33275 }
33276 {
33277 PyThreadState* __tstate = wxPyBeginAllowThreads();
33278 (arg1)->AddFile((wxString const &)*arg2);
33279 wxPyEndAllowThreads(__tstate);
33280 if (PyErr_Occurred()) SWIG_fail;
33281 }
33282 resultobj = SWIG_Py_Void();
33283 {
33284 if (temp2)
33285 delete arg2;
33286 }
33287 return resultobj;
33288 fail:
33289 {
33290 if (temp2)
33291 delete arg2;
33292 }
33293 return NULL;
33294 }
33295
33296
33297 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33298 PyObject *obj;
33299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33300 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33301 return SWIG_Py_Void();
33302 }
33303
33304 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33305 return SWIG_Python_InitShadowInstance(args);
33306 }
33307
33308 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33309 PyObject *resultobj = 0;
33310 wxDataFormat *arg1 = 0 ;
33311 wxCustomDataObject *result = 0 ;
33312 void *argp1 = 0 ;
33313 int res1 = 0 ;
33314
33315 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33317 if (!SWIG_IsOK(res1)) {
33318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33319 }
33320 if (!argp1) {
33321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33322 }
33323 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33324 {
33325 PyThreadState* __tstate = wxPyBeginAllowThreads();
33326 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33327 wxPyEndAllowThreads(__tstate);
33328 if (PyErr_Occurred()) SWIG_fail;
33329 }
33330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33331 return resultobj;
33332 fail:
33333 return NULL;
33334 }
33335
33336
33337 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33338 PyObject *resultobj = 0;
33339 wxString *arg1 = 0 ;
33340 wxCustomDataObject *result = 0 ;
33341 bool temp1 = false ;
33342
33343 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33344 {
33345 arg1 = wxString_in_helper(swig_obj[0]);
33346 if (arg1 == NULL) SWIG_fail;
33347 temp1 = true;
33348 }
33349 {
33350 PyThreadState* __tstate = wxPyBeginAllowThreads();
33351 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33352 wxPyEndAllowThreads(__tstate);
33353 if (PyErr_Occurred()) SWIG_fail;
33354 }
33355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33356 {
33357 if (temp1)
33358 delete arg1;
33359 }
33360 return resultobj;
33361 fail:
33362 {
33363 if (temp1)
33364 delete arg1;
33365 }
33366 return NULL;
33367 }
33368
33369
33370 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33371 PyObject *resultobj = 0;
33372 wxCustomDataObject *result = 0 ;
33373
33374 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33375 {
33376 PyThreadState* __tstate = wxPyBeginAllowThreads();
33377 result = (wxCustomDataObject *)new wxCustomDataObject();
33378 wxPyEndAllowThreads(__tstate);
33379 if (PyErr_Occurred()) SWIG_fail;
33380 }
33381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33382 return resultobj;
33383 fail:
33384 return NULL;
33385 }
33386
33387
33388 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33389 int argc;
33390 PyObject *argv[2];
33391
33392 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33393 --argc;
33394 if (argc == 0) {
33395 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33396 }
33397 if (argc == 1) {
33398 int _v = 0;
33399 {
33400 {
33401 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33402 }
33403 }
33404 if (!_v) goto check_2;
33405 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33406 }
33407 check_2:
33408
33409 if (argc == 1) {
33410 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33411 }
33412
33413 fail:
33414 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33415 return NULL;
33416 }
33417
33418
33419 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33420 PyObject *resultobj = 0;
33421 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33422 PyObject *arg2 = (PyObject *) 0 ;
33423 bool result;
33424 void *argp1 = 0 ;
33425 int res1 = 0 ;
33426 PyObject * obj0 = 0 ;
33427 PyObject * obj1 = 0 ;
33428 char * kwnames[] = {
33429 (char *) "self",(char *) "data", NULL
33430 };
33431
33432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33434 if (!SWIG_IsOK(res1)) {
33435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33436 }
33437 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33438 arg2 = obj1;
33439 {
33440 PyThreadState* __tstate = wxPyBeginAllowThreads();
33441 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33442 wxPyEndAllowThreads(__tstate);
33443 if (PyErr_Occurred()) SWIG_fail;
33444 }
33445 {
33446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33447 }
33448 return resultobj;
33449 fail:
33450 return NULL;
33451 }
33452
33453
33454 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33455 PyObject *resultobj = 0;
33456 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33457 size_t result;
33458 void *argp1 = 0 ;
33459 int res1 = 0 ;
33460 PyObject *swig_obj[1] ;
33461
33462 if (!args) SWIG_fail;
33463 swig_obj[0] = args;
33464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33465 if (!SWIG_IsOK(res1)) {
33466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33467 }
33468 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33469 {
33470 PyThreadState* __tstate = wxPyBeginAllowThreads();
33471 result = (size_t)(arg1)->GetSize();
33472 wxPyEndAllowThreads(__tstate);
33473 if (PyErr_Occurred()) SWIG_fail;
33474 }
33475 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33476 return resultobj;
33477 fail:
33478 return NULL;
33479 }
33480
33481
33482 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33483 PyObject *resultobj = 0;
33484 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33485 PyObject *result = 0 ;
33486 void *argp1 = 0 ;
33487 int res1 = 0 ;
33488 PyObject *swig_obj[1] ;
33489
33490 if (!args) SWIG_fail;
33491 swig_obj[0] = args;
33492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33493 if (!SWIG_IsOK(res1)) {
33494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33495 }
33496 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33497 {
33498 PyThreadState* __tstate = wxPyBeginAllowThreads();
33499 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33500 wxPyEndAllowThreads(__tstate);
33501 if (PyErr_Occurred()) SWIG_fail;
33502 }
33503 resultobj = result;
33504 return resultobj;
33505 fail:
33506 return NULL;
33507 }
33508
33509
33510 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33511 PyObject *obj;
33512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33513 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33514 return SWIG_Py_Void();
33515 }
33516
33517 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33518 return SWIG_Python_InitShadowInstance(args);
33519 }
33520
33521 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33522 PyObject *resultobj = 0;
33523 wxString const &arg1_defvalue = wxPyEmptyString ;
33524 wxString *arg1 = (wxString *) &arg1_defvalue ;
33525 wxURLDataObject *result = 0 ;
33526 bool temp1 = false ;
33527 PyObject * obj0 = 0 ;
33528 char * kwnames[] = {
33529 (char *) "url", NULL
33530 };
33531
33532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33533 if (obj0) {
33534 {
33535 arg1 = wxString_in_helper(obj0);
33536 if (arg1 == NULL) SWIG_fail;
33537 temp1 = true;
33538 }
33539 }
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33547 {
33548 if (temp1)
33549 delete arg1;
33550 }
33551 return resultobj;
33552 fail:
33553 {
33554 if (temp1)
33555 delete arg1;
33556 }
33557 return NULL;
33558 }
33559
33560
33561 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33562 PyObject *resultobj = 0;
33563 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33564 wxString result;
33565 void *argp1 = 0 ;
33566 int res1 = 0 ;
33567 PyObject *swig_obj[1] ;
33568
33569 if (!args) SWIG_fail;
33570 swig_obj[0] = args;
33571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33572 if (!SWIG_IsOK(res1)) {
33573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33574 }
33575 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33576 {
33577 PyThreadState* __tstate = wxPyBeginAllowThreads();
33578 result = (arg1)->GetURL();
33579 wxPyEndAllowThreads(__tstate);
33580 if (PyErr_Occurred()) SWIG_fail;
33581 }
33582 {
33583 #if wxUSE_UNICODE
33584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33585 #else
33586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33587 #endif
33588 }
33589 return resultobj;
33590 fail:
33591 return NULL;
33592 }
33593
33594
33595 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33596 PyObject *resultobj = 0;
33597 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33598 wxString *arg2 = 0 ;
33599 void *argp1 = 0 ;
33600 int res1 = 0 ;
33601 bool temp2 = false ;
33602 PyObject * obj0 = 0 ;
33603 PyObject * obj1 = 0 ;
33604 char * kwnames[] = {
33605 (char *) "self",(char *) "url", NULL
33606 };
33607
33608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33610 if (!SWIG_IsOK(res1)) {
33611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33612 }
33613 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33614 {
33615 arg2 = wxString_in_helper(obj1);
33616 if (arg2 == NULL) SWIG_fail;
33617 temp2 = true;
33618 }
33619 {
33620 PyThreadState* __tstate = wxPyBeginAllowThreads();
33621 (arg1)->SetURL((wxString const &)*arg2);
33622 wxPyEndAllowThreads(__tstate);
33623 if (PyErr_Occurred()) SWIG_fail;
33624 }
33625 resultobj = SWIG_Py_Void();
33626 {
33627 if (temp2)
33628 delete arg2;
33629 }
33630 return resultobj;
33631 fail:
33632 {
33633 if (temp2)
33634 delete arg2;
33635 }
33636 return NULL;
33637 }
33638
33639
33640 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33641 PyObject *obj;
33642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33643 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33644 return SWIG_Py_Void();
33645 }
33646
33647 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33648 return SWIG_Python_InitShadowInstance(args);
33649 }
33650
33651 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33652 PyObject *resultobj = 0;
33653 wxMetafileDataObject *result = 0 ;
33654
33655 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33656 {
33657 PyThreadState* __tstate = wxPyBeginAllowThreads();
33658 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33659 wxPyEndAllowThreads(__tstate);
33660 if (PyErr_Occurred()) SWIG_fail;
33661 }
33662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33663 return resultobj;
33664 fail:
33665 return NULL;
33666 }
33667
33668
33669 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33670 PyObject *obj;
33671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33672 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33673 return SWIG_Py_Void();
33674 }
33675
33676 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33677 return SWIG_Python_InitShadowInstance(args);
33678 }
33679
33680 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33681 PyObject *resultobj = 0;
33682 wxDragResult arg1 ;
33683 bool result;
33684 int val1 ;
33685 int ecode1 = 0 ;
33686 PyObject * obj0 = 0 ;
33687 char * kwnames[] = {
33688 (char *) "res", NULL
33689 };
33690
33691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33692 ecode1 = SWIG_AsVal_int(obj0, &val1);
33693 if (!SWIG_IsOK(ecode1)) {
33694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33695 }
33696 arg1 = static_cast< wxDragResult >(val1);
33697 {
33698 PyThreadState* __tstate = wxPyBeginAllowThreads();
33699 result = (bool)wxIsDragResultOk(arg1);
33700 wxPyEndAllowThreads(__tstate);
33701 if (PyErr_Occurred()) SWIG_fail;
33702 }
33703 {
33704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33705 }
33706 return resultobj;
33707 fail:
33708 return NULL;
33709 }
33710
33711
33712 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33713 PyObject *resultobj = 0;
33714 wxWindow *arg1 = (wxWindow *) 0 ;
33715 wxIcon const &arg2_defvalue = wxNullIcon ;
33716 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33717 wxIcon const &arg3_defvalue = wxNullIcon ;
33718 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33719 wxIcon const &arg4_defvalue = wxNullIcon ;
33720 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33721 wxPyDropSource *result = 0 ;
33722 void *argp1 = 0 ;
33723 int res1 = 0 ;
33724 void *argp2 = 0 ;
33725 int res2 = 0 ;
33726 void *argp3 = 0 ;
33727 int res3 = 0 ;
33728 void *argp4 = 0 ;
33729 int res4 = 0 ;
33730 PyObject * obj0 = 0 ;
33731 PyObject * obj1 = 0 ;
33732 PyObject * obj2 = 0 ;
33733 PyObject * obj3 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33742 }
33743 arg1 = reinterpret_cast< wxWindow * >(argp1);
33744 if (obj1) {
33745 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33746 if (!SWIG_IsOK(res2)) {
33747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33748 }
33749 if (!argp2) {
33750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33751 }
33752 arg2 = reinterpret_cast< wxIcon * >(argp2);
33753 }
33754 if (obj2) {
33755 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33756 if (!SWIG_IsOK(res3)) {
33757 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33758 }
33759 if (!argp3) {
33760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33761 }
33762 arg3 = reinterpret_cast< wxIcon * >(argp3);
33763 }
33764 if (obj3) {
33765 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33766 if (!SWIG_IsOK(res4)) {
33767 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33768 }
33769 if (!argp4) {
33770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33771 }
33772 arg4 = reinterpret_cast< wxIcon * >(argp4);
33773 }
33774 {
33775 PyThreadState* __tstate = wxPyBeginAllowThreads();
33776 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33777 wxPyEndAllowThreads(__tstate);
33778 if (PyErr_Occurred()) SWIG_fail;
33779 }
33780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33781 return resultobj;
33782 fail:
33783 return NULL;
33784 }
33785
33786
33787 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33788 PyObject *resultobj = 0;
33789 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33790 PyObject *arg2 = (PyObject *) 0 ;
33791 PyObject *arg3 = (PyObject *) 0 ;
33792 int arg4 = (int) 0 ;
33793 void *argp1 = 0 ;
33794 int res1 = 0 ;
33795 int val4 ;
33796 int ecode4 = 0 ;
33797 PyObject * obj0 = 0 ;
33798 PyObject * obj1 = 0 ;
33799 PyObject * obj2 = 0 ;
33800 PyObject * obj3 = 0 ;
33801 char * kwnames[] = {
33802 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33803 };
33804
33805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33807 if (!SWIG_IsOK(res1)) {
33808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33809 }
33810 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33811 arg2 = obj1;
33812 arg3 = obj2;
33813 if (obj3) {
33814 ecode4 = SWIG_AsVal_int(obj3, &val4);
33815 if (!SWIG_IsOK(ecode4)) {
33816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33817 }
33818 arg4 = static_cast< int >(val4);
33819 }
33820 {
33821 PyThreadState* __tstate = wxPyBeginAllowThreads();
33822 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33823 wxPyEndAllowThreads(__tstate);
33824 if (PyErr_Occurred()) SWIG_fail;
33825 }
33826 resultobj = SWIG_Py_Void();
33827 return resultobj;
33828 fail:
33829 return NULL;
33830 }
33831
33832
33833 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33834 PyObject *resultobj = 0;
33835 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33836 void *argp1 = 0 ;
33837 int res1 = 0 ;
33838 PyObject *swig_obj[1] ;
33839
33840 if (!args) SWIG_fail;
33841 swig_obj[0] = args;
33842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33843 if (!SWIG_IsOK(res1)) {
33844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33845 }
33846 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33847 {
33848 PyThreadState* __tstate = wxPyBeginAllowThreads();
33849 delete arg1;
33850
33851 wxPyEndAllowThreads(__tstate);
33852 if (PyErr_Occurred()) SWIG_fail;
33853 }
33854 resultobj = SWIG_Py_Void();
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33862 PyObject *resultobj = 0;
33863 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33864 wxDataObject *arg2 = 0 ;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 void *argp2 = 0 ;
33868 int res2 = 0 ;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 char * kwnames[] = {
33872 (char *) "self",(char *) "data", NULL
33873 };
33874
33875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33877 if (!SWIG_IsOK(res1)) {
33878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33879 }
33880 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33881 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33882 if (!SWIG_IsOK(res2)) {
33883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33884 }
33885 if (!argp2) {
33886 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33887 }
33888 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33889 {
33890 PyThreadState* __tstate = wxPyBeginAllowThreads();
33891 (arg1)->SetData(*arg2);
33892 wxPyEndAllowThreads(__tstate);
33893 if (PyErr_Occurred()) SWIG_fail;
33894 }
33895 resultobj = SWIG_Py_Void();
33896 return resultobj;
33897 fail:
33898 return NULL;
33899 }
33900
33901
33902 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33903 PyObject *resultobj = 0;
33904 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33905 wxDataObject *result = 0 ;
33906 void *argp1 = 0 ;
33907 int res1 = 0 ;
33908 PyObject *swig_obj[1] ;
33909
33910 if (!args) SWIG_fail;
33911 swig_obj[0] = args;
33912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33913 if (!SWIG_IsOK(res1)) {
33914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33915 }
33916 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33917 {
33918 PyThreadState* __tstate = wxPyBeginAllowThreads();
33919 result = (wxDataObject *)(arg1)->GetDataObject();
33920 wxPyEndAllowThreads(__tstate);
33921 if (PyErr_Occurred()) SWIG_fail;
33922 }
33923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33924 return resultobj;
33925 fail:
33926 return NULL;
33927 }
33928
33929
33930 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33931 PyObject *resultobj = 0;
33932 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33933 wxDragResult arg2 ;
33934 wxCursor *arg3 = 0 ;
33935 void *argp1 = 0 ;
33936 int res1 = 0 ;
33937 int val2 ;
33938 int ecode2 = 0 ;
33939 void *argp3 = 0 ;
33940 int res3 = 0 ;
33941 PyObject * obj0 = 0 ;
33942 PyObject * obj1 = 0 ;
33943 PyObject * obj2 = 0 ;
33944 char * kwnames[] = {
33945 (char *) "self",(char *) "res",(char *) "cursor", NULL
33946 };
33947
33948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33950 if (!SWIG_IsOK(res1)) {
33951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33952 }
33953 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33954 ecode2 = SWIG_AsVal_int(obj1, &val2);
33955 if (!SWIG_IsOK(ecode2)) {
33956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33957 }
33958 arg2 = static_cast< wxDragResult >(val2);
33959 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33960 if (!SWIG_IsOK(res3)) {
33961 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33962 }
33963 if (!argp3) {
33964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33965 }
33966 arg3 = reinterpret_cast< wxCursor * >(argp3);
33967 {
33968 PyThreadState* __tstate = wxPyBeginAllowThreads();
33969 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33970 wxPyEndAllowThreads(__tstate);
33971 if (PyErr_Occurred()) SWIG_fail;
33972 }
33973 resultobj = SWIG_Py_Void();
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj = 0;
33982 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33983 int arg2 = (int) wxDrag_CopyOnly ;
33984 wxDragResult result;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 int val2 ;
33988 int ecode2 = 0 ;
33989 PyObject * obj0 = 0 ;
33990 PyObject * obj1 = 0 ;
33991 char * kwnames[] = {
33992 (char *) "self",(char *) "flags", NULL
33993 };
33994
33995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33997 if (!SWIG_IsOK(res1)) {
33998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33999 }
34000 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34001 if (obj1) {
34002 ecode2 = SWIG_AsVal_int(obj1, &val2);
34003 if (!SWIG_IsOK(ecode2)) {
34004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34005 }
34006 arg2 = static_cast< int >(val2);
34007 }
34008 {
34009 PyThreadState* __tstate = wxPyBeginAllowThreads();
34010 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34011 wxPyEndAllowThreads(__tstate);
34012 if (PyErr_Occurred()) SWIG_fail;
34013 }
34014 resultobj = SWIG_From_int(static_cast< int >(result));
34015 return resultobj;
34016 fail:
34017 return NULL;
34018 }
34019
34020
34021 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34022 PyObject *resultobj = 0;
34023 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34024 wxDragResult arg2 ;
34025 bool result;
34026 void *argp1 = 0 ;
34027 int res1 = 0 ;
34028 int val2 ;
34029 int ecode2 = 0 ;
34030 PyObject * obj0 = 0 ;
34031 PyObject * obj1 = 0 ;
34032 char * kwnames[] = {
34033 (char *) "self",(char *) "effect", NULL
34034 };
34035
34036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34038 if (!SWIG_IsOK(res1)) {
34039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34040 }
34041 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34042 ecode2 = SWIG_AsVal_int(obj1, &val2);
34043 if (!SWIG_IsOK(ecode2)) {
34044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34045 }
34046 arg2 = static_cast< wxDragResult >(val2);
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 result = (bool)(arg1)->GiveFeedback(arg2);
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 {
34054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34055 }
34056 return resultobj;
34057 fail:
34058 return NULL;
34059 }
34060
34061
34062 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34063 PyObject *obj;
34064 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34065 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34066 return SWIG_Py_Void();
34067 }
34068
34069 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34070 return SWIG_Python_InitShadowInstance(args);
34071 }
34072
34073 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34074 PyObject *resultobj = 0;
34075 wxDataObject *arg1 = (wxDataObject *) NULL ;
34076 wxPyDropTarget *result = 0 ;
34077 int res1 = 0 ;
34078 PyObject * obj0 = 0 ;
34079 char * kwnames[] = {
34080 (char *) "dataObject", NULL
34081 };
34082
34083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34084 if (obj0) {
34085 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34088 }
34089 }
34090 {
34091 PyThreadState* __tstate = wxPyBeginAllowThreads();
34092 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34093 wxPyEndAllowThreads(__tstate);
34094 if (PyErr_Occurred()) SWIG_fail;
34095 }
34096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34097 return resultobj;
34098 fail:
34099 return NULL;
34100 }
34101
34102
34103 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34104 PyObject *resultobj = 0;
34105 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34106 PyObject *arg2 = (PyObject *) 0 ;
34107 PyObject *arg3 = (PyObject *) 0 ;
34108 void *argp1 = 0 ;
34109 int res1 = 0 ;
34110 PyObject * obj0 = 0 ;
34111 PyObject * obj1 = 0 ;
34112 PyObject * obj2 = 0 ;
34113 char * kwnames[] = {
34114 (char *) "self",(char *) "self",(char *) "_class", NULL
34115 };
34116
34117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34119 if (!SWIG_IsOK(res1)) {
34120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34121 }
34122 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34123 arg2 = obj1;
34124 arg3 = obj2;
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 (arg1)->_setCallbackInfo(arg2,arg3);
34128 wxPyEndAllowThreads(__tstate);
34129 if (PyErr_Occurred()) SWIG_fail;
34130 }
34131 resultobj = SWIG_Py_Void();
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34139 PyObject *resultobj = 0;
34140 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34141 void *argp1 = 0 ;
34142 int res1 = 0 ;
34143 PyObject *swig_obj[1] ;
34144
34145 if (!args) SWIG_fail;
34146 swig_obj[0] = args;
34147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34148 if (!SWIG_IsOK(res1)) {
34149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34150 }
34151 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34152 {
34153 PyThreadState* __tstate = wxPyBeginAllowThreads();
34154 delete arg1;
34155
34156 wxPyEndAllowThreads(__tstate);
34157 if (PyErr_Occurred()) SWIG_fail;
34158 }
34159 resultobj = SWIG_Py_Void();
34160 return resultobj;
34161 fail:
34162 return NULL;
34163 }
34164
34165
34166 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34167 PyObject *resultobj = 0;
34168 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34169 wxDataObject *result = 0 ;
34170 void *argp1 = 0 ;
34171 int res1 = 0 ;
34172 PyObject *swig_obj[1] ;
34173
34174 if (!args) SWIG_fail;
34175 swig_obj[0] = args;
34176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34177 if (!SWIG_IsOK(res1)) {
34178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34179 }
34180 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34181 {
34182 PyThreadState* __tstate = wxPyBeginAllowThreads();
34183 result = (wxDataObject *)(arg1)->GetDataObject();
34184 wxPyEndAllowThreads(__tstate);
34185 if (PyErr_Occurred()) SWIG_fail;
34186 }
34187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34188 return resultobj;
34189 fail:
34190 return NULL;
34191 }
34192
34193
34194 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34195 PyObject *resultobj = 0;
34196 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34197 wxDataObject *arg2 = (wxDataObject *) 0 ;
34198 void *argp1 = 0 ;
34199 int res1 = 0 ;
34200 int res2 = 0 ;
34201 PyObject * obj0 = 0 ;
34202 PyObject * obj1 = 0 ;
34203 char * kwnames[] = {
34204 (char *) "self",(char *) "dataObject", NULL
34205 };
34206
34207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34209 if (!SWIG_IsOK(res1)) {
34210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34211 }
34212 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34213 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34214 if (!SWIG_IsOK(res2)) {
34215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34216 }
34217 {
34218 PyThreadState* __tstate = wxPyBeginAllowThreads();
34219 (arg1)->SetDataObject(arg2);
34220 wxPyEndAllowThreads(__tstate);
34221 if (PyErr_Occurred()) SWIG_fail;
34222 }
34223 resultobj = SWIG_Py_Void();
34224 return resultobj;
34225 fail:
34226 return NULL;
34227 }
34228
34229
34230 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34231 PyObject *resultobj = 0;
34232 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34233 int arg2 ;
34234 int arg3 ;
34235 wxDragResult arg4 ;
34236 wxDragResult result;
34237 void *argp1 = 0 ;
34238 int res1 = 0 ;
34239 int val2 ;
34240 int ecode2 = 0 ;
34241 int val3 ;
34242 int ecode3 = 0 ;
34243 int val4 ;
34244 int ecode4 = 0 ;
34245 PyObject * obj0 = 0 ;
34246 PyObject * obj1 = 0 ;
34247 PyObject * obj2 = 0 ;
34248 PyObject * obj3 = 0 ;
34249 char * kwnames[] = {
34250 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34251 };
34252
34253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34255 if (!SWIG_IsOK(res1)) {
34256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34257 }
34258 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34259 ecode2 = SWIG_AsVal_int(obj1, &val2);
34260 if (!SWIG_IsOK(ecode2)) {
34261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34262 }
34263 arg2 = static_cast< int >(val2);
34264 ecode3 = SWIG_AsVal_int(obj2, &val3);
34265 if (!SWIG_IsOK(ecode3)) {
34266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34267 }
34268 arg3 = static_cast< int >(val3);
34269 ecode4 = SWIG_AsVal_int(obj3, &val4);
34270 if (!SWIG_IsOK(ecode4)) {
34271 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34272 }
34273 arg4 = static_cast< wxDragResult >(val4);
34274 {
34275 PyThreadState* __tstate = wxPyBeginAllowThreads();
34276 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 resultobj = SWIG_From_int(static_cast< int >(result));
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34288 PyObject *resultobj = 0;
34289 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34290 int arg2 ;
34291 int arg3 ;
34292 wxDragResult arg4 ;
34293 wxDragResult result;
34294 void *argp1 = 0 ;
34295 int res1 = 0 ;
34296 int val2 ;
34297 int ecode2 = 0 ;
34298 int val3 ;
34299 int ecode3 = 0 ;
34300 int val4 ;
34301 int ecode4 = 0 ;
34302 PyObject * obj0 = 0 ;
34303 PyObject * obj1 = 0 ;
34304 PyObject * obj2 = 0 ;
34305 PyObject * obj3 = 0 ;
34306 char * kwnames[] = {
34307 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34308 };
34309
34310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34312 if (!SWIG_IsOK(res1)) {
34313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34314 }
34315 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34316 ecode2 = SWIG_AsVal_int(obj1, &val2);
34317 if (!SWIG_IsOK(ecode2)) {
34318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34319 }
34320 arg2 = static_cast< int >(val2);
34321 ecode3 = SWIG_AsVal_int(obj2, &val3);
34322 if (!SWIG_IsOK(ecode3)) {
34323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34324 }
34325 arg3 = static_cast< int >(val3);
34326 ecode4 = SWIG_AsVal_int(obj3, &val4);
34327 if (!SWIG_IsOK(ecode4)) {
34328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34329 }
34330 arg4 = static_cast< wxDragResult >(val4);
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 resultobj = SWIG_From_int(static_cast< int >(result));
34338 return resultobj;
34339 fail:
34340 return NULL;
34341 }
34342
34343
34344 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34345 PyObject *resultobj = 0;
34346 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34347 void *argp1 = 0 ;
34348 int res1 = 0 ;
34349 PyObject *swig_obj[1] ;
34350
34351 if (!args) SWIG_fail;
34352 swig_obj[0] = args;
34353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34354 if (!SWIG_IsOK(res1)) {
34355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34356 }
34357 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34358 {
34359 PyThreadState* __tstate = wxPyBeginAllowThreads();
34360 (arg1)->OnLeave();
34361 wxPyEndAllowThreads(__tstate);
34362 if (PyErr_Occurred()) SWIG_fail;
34363 }
34364 resultobj = SWIG_Py_Void();
34365 return resultobj;
34366 fail:
34367 return NULL;
34368 }
34369
34370
34371 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34372 PyObject *resultobj = 0;
34373 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34374 int arg2 ;
34375 int arg3 ;
34376 bool result;
34377 void *argp1 = 0 ;
34378 int res1 = 0 ;
34379 int val2 ;
34380 int ecode2 = 0 ;
34381 int val3 ;
34382 int ecode3 = 0 ;
34383 PyObject * obj0 = 0 ;
34384 PyObject * obj1 = 0 ;
34385 PyObject * obj2 = 0 ;
34386 char * kwnames[] = {
34387 (char *) "self",(char *) "x",(char *) "y", NULL
34388 };
34389
34390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34392 if (!SWIG_IsOK(res1)) {
34393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34394 }
34395 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34396 ecode2 = SWIG_AsVal_int(obj1, &val2);
34397 if (!SWIG_IsOK(ecode2)) {
34398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34399 }
34400 arg2 = static_cast< int >(val2);
34401 ecode3 = SWIG_AsVal_int(obj2, &val3);
34402 if (!SWIG_IsOK(ecode3)) {
34403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34404 }
34405 arg3 = static_cast< int >(val3);
34406 {
34407 PyThreadState* __tstate = wxPyBeginAllowThreads();
34408 result = (bool)(arg1)->OnDrop(arg2,arg3);
34409 wxPyEndAllowThreads(__tstate);
34410 if (PyErr_Occurred()) SWIG_fail;
34411 }
34412 {
34413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34414 }
34415 return resultobj;
34416 fail:
34417 return NULL;
34418 }
34419
34420
34421 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34422 PyObject *resultobj = 0;
34423 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34424 bool result;
34425 void *argp1 = 0 ;
34426 int res1 = 0 ;
34427 PyObject *swig_obj[1] ;
34428
34429 if (!args) SWIG_fail;
34430 swig_obj[0] = args;
34431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34432 if (!SWIG_IsOK(res1)) {
34433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34434 }
34435 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34436 {
34437 PyThreadState* __tstate = wxPyBeginAllowThreads();
34438 result = (bool)(arg1)->GetData();
34439 wxPyEndAllowThreads(__tstate);
34440 if (PyErr_Occurred()) SWIG_fail;
34441 }
34442 {
34443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34444 }
34445 return resultobj;
34446 fail:
34447 return NULL;
34448 }
34449
34450
34451 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34452 PyObject *resultobj = 0;
34453 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34454 wxDragResult arg2 ;
34455 void *argp1 = 0 ;
34456 int res1 = 0 ;
34457 int val2 ;
34458 int ecode2 = 0 ;
34459 PyObject * obj0 = 0 ;
34460 PyObject * obj1 = 0 ;
34461 char * kwnames[] = {
34462 (char *) "self",(char *) "action", NULL
34463 };
34464
34465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34467 if (!SWIG_IsOK(res1)) {
34468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34469 }
34470 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34471 ecode2 = SWIG_AsVal_int(obj1, &val2);
34472 if (!SWIG_IsOK(ecode2)) {
34473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34474 }
34475 arg2 = static_cast< wxDragResult >(val2);
34476 {
34477 PyThreadState* __tstate = wxPyBeginAllowThreads();
34478 (arg1)->SetDefaultAction(arg2);
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 resultobj = SWIG_Py_Void();
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34490 PyObject *resultobj = 0;
34491 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34492 wxDragResult result;
34493 void *argp1 = 0 ;
34494 int res1 = 0 ;
34495 PyObject *swig_obj[1] ;
34496
34497 if (!args) SWIG_fail;
34498 swig_obj[0] = args;
34499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34500 if (!SWIG_IsOK(res1)) {
34501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34502 }
34503 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34504 {
34505 PyThreadState* __tstate = wxPyBeginAllowThreads();
34506 result = (wxDragResult)(arg1)->GetDefaultAction();
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 resultobj = SWIG_From_int(static_cast< int >(result));
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34518 PyObject *obj;
34519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34520 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34521 return SWIG_Py_Void();
34522 }
34523
34524 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34525 return SWIG_Python_InitShadowInstance(args);
34526 }
34527
34528 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34529 PyObject *resultobj = 0;
34530 wxPyTextDropTarget *result = 0 ;
34531
34532 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34533 {
34534 PyThreadState* __tstate = wxPyBeginAllowThreads();
34535 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34536 wxPyEndAllowThreads(__tstate);
34537 if (PyErr_Occurred()) SWIG_fail;
34538 }
34539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34540 return resultobj;
34541 fail:
34542 return NULL;
34543 }
34544
34545
34546 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34547 PyObject *resultobj = 0;
34548 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34549 PyObject *arg2 = (PyObject *) 0 ;
34550 PyObject *arg3 = (PyObject *) 0 ;
34551 void *argp1 = 0 ;
34552 int res1 = 0 ;
34553 PyObject * obj0 = 0 ;
34554 PyObject * obj1 = 0 ;
34555 PyObject * obj2 = 0 ;
34556 char * kwnames[] = {
34557 (char *) "self",(char *) "self",(char *) "_class", NULL
34558 };
34559
34560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34562 if (!SWIG_IsOK(res1)) {
34563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34564 }
34565 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34566 arg2 = obj1;
34567 arg3 = obj2;
34568 {
34569 PyThreadState* __tstate = wxPyBeginAllowThreads();
34570 (arg1)->_setCallbackInfo(arg2,arg3);
34571 wxPyEndAllowThreads(__tstate);
34572 if (PyErr_Occurred()) SWIG_fail;
34573 }
34574 resultobj = SWIG_Py_Void();
34575 return resultobj;
34576 fail:
34577 return NULL;
34578 }
34579
34580
34581 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34582 PyObject *resultobj = 0;
34583 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34584 int arg2 ;
34585 int arg3 ;
34586 wxString *arg4 = 0 ;
34587 bool result;
34588 void *argp1 = 0 ;
34589 int res1 = 0 ;
34590 int val2 ;
34591 int ecode2 = 0 ;
34592 int val3 ;
34593 int ecode3 = 0 ;
34594 bool temp4 = false ;
34595 PyObject * obj0 = 0 ;
34596 PyObject * obj1 = 0 ;
34597 PyObject * obj2 = 0 ;
34598 PyObject * obj3 = 0 ;
34599 char * kwnames[] = {
34600 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34601 };
34602
34603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34607 }
34608 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34609 ecode2 = SWIG_AsVal_int(obj1, &val2);
34610 if (!SWIG_IsOK(ecode2)) {
34611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34612 }
34613 arg2 = static_cast< int >(val2);
34614 ecode3 = SWIG_AsVal_int(obj2, &val3);
34615 if (!SWIG_IsOK(ecode3)) {
34616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34617 }
34618 arg3 = static_cast< int >(val3);
34619 {
34620 arg4 = wxString_in_helper(obj3);
34621 if (arg4 == NULL) SWIG_fail;
34622 temp4 = true;
34623 }
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 {
34631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34632 }
34633 {
34634 if (temp4)
34635 delete arg4;
34636 }
34637 return resultobj;
34638 fail:
34639 {
34640 if (temp4)
34641 delete arg4;
34642 }
34643 return NULL;
34644 }
34645
34646
34647 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34648 PyObject *resultobj = 0;
34649 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34650 int arg2 ;
34651 int arg3 ;
34652 wxDragResult arg4 ;
34653 wxDragResult result;
34654 void *argp1 = 0 ;
34655 int res1 = 0 ;
34656 int val2 ;
34657 int ecode2 = 0 ;
34658 int val3 ;
34659 int ecode3 = 0 ;
34660 int val4 ;
34661 int ecode4 = 0 ;
34662 PyObject * obj0 = 0 ;
34663 PyObject * obj1 = 0 ;
34664 PyObject * obj2 = 0 ;
34665 PyObject * obj3 = 0 ;
34666 char * kwnames[] = {
34667 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34668 };
34669
34670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34672 if (!SWIG_IsOK(res1)) {
34673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34674 }
34675 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34676 ecode2 = SWIG_AsVal_int(obj1, &val2);
34677 if (!SWIG_IsOK(ecode2)) {
34678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34679 }
34680 arg2 = static_cast< int >(val2);
34681 ecode3 = SWIG_AsVal_int(obj2, &val3);
34682 if (!SWIG_IsOK(ecode3)) {
34683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34684 }
34685 arg3 = static_cast< int >(val3);
34686 ecode4 = SWIG_AsVal_int(obj3, &val4);
34687 if (!SWIG_IsOK(ecode4)) {
34688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34689 }
34690 arg4 = static_cast< wxDragResult >(val4);
34691 {
34692 PyThreadState* __tstate = wxPyBeginAllowThreads();
34693 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 resultobj = SWIG_From_int(static_cast< int >(result));
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34705 PyObject *resultobj = 0;
34706 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34707 int arg2 ;
34708 int arg3 ;
34709 wxDragResult arg4 ;
34710 wxDragResult result;
34711 void *argp1 = 0 ;
34712 int res1 = 0 ;
34713 int val2 ;
34714 int ecode2 = 0 ;
34715 int val3 ;
34716 int ecode3 = 0 ;
34717 int val4 ;
34718 int ecode4 = 0 ;
34719 PyObject * obj0 = 0 ;
34720 PyObject * obj1 = 0 ;
34721 PyObject * obj2 = 0 ;
34722 PyObject * obj3 = 0 ;
34723 char * kwnames[] = {
34724 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34725 };
34726
34727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34729 if (!SWIG_IsOK(res1)) {
34730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34731 }
34732 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34733 ecode2 = SWIG_AsVal_int(obj1, &val2);
34734 if (!SWIG_IsOK(ecode2)) {
34735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34736 }
34737 arg2 = static_cast< int >(val2);
34738 ecode3 = SWIG_AsVal_int(obj2, &val3);
34739 if (!SWIG_IsOK(ecode3)) {
34740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34741 }
34742 arg3 = static_cast< int >(val3);
34743 ecode4 = SWIG_AsVal_int(obj3, &val4);
34744 if (!SWIG_IsOK(ecode4)) {
34745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34746 }
34747 arg4 = static_cast< wxDragResult >(val4);
34748 {
34749 PyThreadState* __tstate = wxPyBeginAllowThreads();
34750 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34751 wxPyEndAllowThreads(__tstate);
34752 if (PyErr_Occurred()) SWIG_fail;
34753 }
34754 resultobj = SWIG_From_int(static_cast< int >(result));
34755 return resultobj;
34756 fail:
34757 return NULL;
34758 }
34759
34760
34761 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34762 PyObject *resultobj = 0;
34763 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34764 void *argp1 = 0 ;
34765 int res1 = 0 ;
34766 PyObject *swig_obj[1] ;
34767
34768 if (!args) SWIG_fail;
34769 swig_obj[0] = args;
34770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34771 if (!SWIG_IsOK(res1)) {
34772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34773 }
34774 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 (arg1)->OnLeave();
34778 wxPyEndAllowThreads(__tstate);
34779 if (PyErr_Occurred()) SWIG_fail;
34780 }
34781 resultobj = SWIG_Py_Void();
34782 return resultobj;
34783 fail:
34784 return NULL;
34785 }
34786
34787
34788 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34789 PyObject *resultobj = 0;
34790 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34791 int arg2 ;
34792 int arg3 ;
34793 bool result;
34794 void *argp1 = 0 ;
34795 int res1 = 0 ;
34796 int val2 ;
34797 int ecode2 = 0 ;
34798 int val3 ;
34799 int ecode3 = 0 ;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 PyObject * obj2 = 0 ;
34803 char * kwnames[] = {
34804 (char *) "self",(char *) "x",(char *) "y", NULL
34805 };
34806
34807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34809 if (!SWIG_IsOK(res1)) {
34810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34811 }
34812 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34813 ecode2 = SWIG_AsVal_int(obj1, &val2);
34814 if (!SWIG_IsOK(ecode2)) {
34815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34816 }
34817 arg2 = static_cast< int >(val2);
34818 ecode3 = SWIG_AsVal_int(obj2, &val3);
34819 if (!SWIG_IsOK(ecode3)) {
34820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34821 }
34822 arg3 = static_cast< int >(val3);
34823 {
34824 PyThreadState* __tstate = wxPyBeginAllowThreads();
34825 result = (bool)(arg1)->OnDrop(arg2,arg3);
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 {
34830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34831 }
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34839 PyObject *resultobj = 0;
34840 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34841 int arg2 ;
34842 int arg3 ;
34843 wxDragResult arg4 ;
34844 wxDragResult result;
34845 void *argp1 = 0 ;
34846 int res1 = 0 ;
34847 int val2 ;
34848 int ecode2 = 0 ;
34849 int val3 ;
34850 int ecode3 = 0 ;
34851 int val4 ;
34852 int ecode4 = 0 ;
34853 PyObject * obj0 = 0 ;
34854 PyObject * obj1 = 0 ;
34855 PyObject * obj2 = 0 ;
34856 PyObject * obj3 = 0 ;
34857 char * kwnames[] = {
34858 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34859 };
34860
34861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34863 if (!SWIG_IsOK(res1)) {
34864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34865 }
34866 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34867 ecode2 = SWIG_AsVal_int(obj1, &val2);
34868 if (!SWIG_IsOK(ecode2)) {
34869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34870 }
34871 arg2 = static_cast< int >(val2);
34872 ecode3 = SWIG_AsVal_int(obj2, &val3);
34873 if (!SWIG_IsOK(ecode3)) {
34874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34875 }
34876 arg3 = static_cast< int >(val3);
34877 ecode4 = SWIG_AsVal_int(obj3, &val4);
34878 if (!SWIG_IsOK(ecode4)) {
34879 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34880 }
34881 arg4 = static_cast< wxDragResult >(val4);
34882 {
34883 PyThreadState* __tstate = wxPyBeginAllowThreads();
34884 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34885 wxPyEndAllowThreads(__tstate);
34886 if (PyErr_Occurred()) SWIG_fail;
34887 }
34888 resultobj = SWIG_From_int(static_cast< int >(result));
34889 return resultobj;
34890 fail:
34891 return NULL;
34892 }
34893
34894
34895 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34896 PyObject *obj;
34897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34898 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34899 return SWIG_Py_Void();
34900 }
34901
34902 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34903 return SWIG_Python_InitShadowInstance(args);
34904 }
34905
34906 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34907 PyObject *resultobj = 0;
34908 wxPyFileDropTarget *result = 0 ;
34909
34910 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34911 {
34912 PyThreadState* __tstate = wxPyBeginAllowThreads();
34913 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34914 wxPyEndAllowThreads(__tstate);
34915 if (PyErr_Occurred()) SWIG_fail;
34916 }
34917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34918 return resultobj;
34919 fail:
34920 return NULL;
34921 }
34922
34923
34924 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34925 PyObject *resultobj = 0;
34926 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34927 PyObject *arg2 = (PyObject *) 0 ;
34928 PyObject *arg3 = (PyObject *) 0 ;
34929 void *argp1 = 0 ;
34930 int res1 = 0 ;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 PyObject * obj2 = 0 ;
34934 char * kwnames[] = {
34935 (char *) "self",(char *) "self",(char *) "_class", NULL
34936 };
34937
34938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34940 if (!SWIG_IsOK(res1)) {
34941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34942 }
34943 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34944 arg2 = obj1;
34945 arg3 = obj2;
34946 {
34947 PyThreadState* __tstate = wxPyBeginAllowThreads();
34948 (arg1)->_setCallbackInfo(arg2,arg3);
34949 wxPyEndAllowThreads(__tstate);
34950 if (PyErr_Occurred()) SWIG_fail;
34951 }
34952 resultobj = SWIG_Py_Void();
34953 return resultobj;
34954 fail:
34955 return NULL;
34956 }
34957
34958
34959 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34960 PyObject *resultobj = 0;
34961 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34962 int arg2 ;
34963 int arg3 ;
34964 wxArrayString *arg4 = 0 ;
34965 bool result;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 int val2 ;
34969 int ecode2 = 0 ;
34970 int val3 ;
34971 int ecode3 = 0 ;
34972 bool temp4 = false ;
34973 PyObject * obj0 = 0 ;
34974 PyObject * obj1 = 0 ;
34975 PyObject * obj2 = 0 ;
34976 PyObject * obj3 = 0 ;
34977 char * kwnames[] = {
34978 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34979 };
34980
34981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34983 if (!SWIG_IsOK(res1)) {
34984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34985 }
34986 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34987 ecode2 = SWIG_AsVal_int(obj1, &val2);
34988 if (!SWIG_IsOK(ecode2)) {
34989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34990 }
34991 arg2 = static_cast< int >(val2);
34992 ecode3 = SWIG_AsVal_int(obj2, &val3);
34993 if (!SWIG_IsOK(ecode3)) {
34994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34995 }
34996 arg3 = static_cast< int >(val3);
34997 {
34998 if (! PySequence_Check(obj3)) {
34999 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35000 SWIG_fail;
35001 }
35002 arg4 = new wxArrayString;
35003 temp4 = true;
35004 int i, len=PySequence_Length(obj3);
35005 for (i=0; i<len; i++) {
35006 PyObject* item = PySequence_GetItem(obj3, i);
35007 wxString* s = wxString_in_helper(item);
35008 if (PyErr_Occurred()) SWIG_fail;
35009 arg4->Add(*s);
35010 delete s;
35011 Py_DECREF(item);
35012 }
35013 }
35014 {
35015 PyThreadState* __tstate = wxPyBeginAllowThreads();
35016 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 {
35021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35022 }
35023 {
35024 if (temp4) delete arg4;
35025 }
35026 return resultobj;
35027 fail:
35028 {
35029 if (temp4) delete arg4;
35030 }
35031 return NULL;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj = 0;
35037 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35038 int arg2 ;
35039 int arg3 ;
35040 wxDragResult arg4 ;
35041 wxDragResult result;
35042 void *argp1 = 0 ;
35043 int res1 = 0 ;
35044 int val2 ;
35045 int ecode2 = 0 ;
35046 int val3 ;
35047 int ecode3 = 0 ;
35048 int val4 ;
35049 int ecode4 = 0 ;
35050 PyObject * obj0 = 0 ;
35051 PyObject * obj1 = 0 ;
35052 PyObject * obj2 = 0 ;
35053 PyObject * obj3 = 0 ;
35054 char * kwnames[] = {
35055 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35056 };
35057
35058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35060 if (!SWIG_IsOK(res1)) {
35061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35062 }
35063 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35064 ecode2 = SWIG_AsVal_int(obj1, &val2);
35065 if (!SWIG_IsOK(ecode2)) {
35066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35067 }
35068 arg2 = static_cast< int >(val2);
35069 ecode3 = SWIG_AsVal_int(obj2, &val3);
35070 if (!SWIG_IsOK(ecode3)) {
35071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35072 }
35073 arg3 = static_cast< int >(val3);
35074 ecode4 = SWIG_AsVal_int(obj3, &val4);
35075 if (!SWIG_IsOK(ecode4)) {
35076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35077 }
35078 arg4 = static_cast< wxDragResult >(val4);
35079 {
35080 PyThreadState* __tstate = wxPyBeginAllowThreads();
35081 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35082 wxPyEndAllowThreads(__tstate);
35083 if (PyErr_Occurred()) SWIG_fail;
35084 }
35085 resultobj = SWIG_From_int(static_cast< int >(result));
35086 return resultobj;
35087 fail:
35088 return NULL;
35089 }
35090
35091
35092 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35093 PyObject *resultobj = 0;
35094 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35095 int arg2 ;
35096 int arg3 ;
35097 wxDragResult arg4 ;
35098 wxDragResult result;
35099 void *argp1 = 0 ;
35100 int res1 = 0 ;
35101 int val2 ;
35102 int ecode2 = 0 ;
35103 int val3 ;
35104 int ecode3 = 0 ;
35105 int val4 ;
35106 int ecode4 = 0 ;
35107 PyObject * obj0 = 0 ;
35108 PyObject * obj1 = 0 ;
35109 PyObject * obj2 = 0 ;
35110 PyObject * obj3 = 0 ;
35111 char * kwnames[] = {
35112 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35113 };
35114
35115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35117 if (!SWIG_IsOK(res1)) {
35118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35119 }
35120 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35121 ecode2 = SWIG_AsVal_int(obj1, &val2);
35122 if (!SWIG_IsOK(ecode2)) {
35123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35124 }
35125 arg2 = static_cast< int >(val2);
35126 ecode3 = SWIG_AsVal_int(obj2, &val3);
35127 if (!SWIG_IsOK(ecode3)) {
35128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35129 }
35130 arg3 = static_cast< int >(val3);
35131 ecode4 = SWIG_AsVal_int(obj3, &val4);
35132 if (!SWIG_IsOK(ecode4)) {
35133 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35134 }
35135 arg4 = static_cast< wxDragResult >(val4);
35136 {
35137 PyThreadState* __tstate = wxPyBeginAllowThreads();
35138 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35139 wxPyEndAllowThreads(__tstate);
35140 if (PyErr_Occurred()) SWIG_fail;
35141 }
35142 resultobj = SWIG_From_int(static_cast< int >(result));
35143 return resultobj;
35144 fail:
35145 return NULL;
35146 }
35147
35148
35149 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35150 PyObject *resultobj = 0;
35151 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35152 void *argp1 = 0 ;
35153 int res1 = 0 ;
35154 PyObject *swig_obj[1] ;
35155
35156 if (!args) SWIG_fail;
35157 swig_obj[0] = args;
35158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35159 if (!SWIG_IsOK(res1)) {
35160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35161 }
35162 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35163 {
35164 PyThreadState* __tstate = wxPyBeginAllowThreads();
35165 (arg1)->OnLeave();
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 resultobj = SWIG_Py_Void();
35170 return resultobj;
35171 fail:
35172 return NULL;
35173 }
35174
35175
35176 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35177 PyObject *resultobj = 0;
35178 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35179 int arg2 ;
35180 int arg3 ;
35181 bool result;
35182 void *argp1 = 0 ;
35183 int res1 = 0 ;
35184 int val2 ;
35185 int ecode2 = 0 ;
35186 int val3 ;
35187 int ecode3 = 0 ;
35188 PyObject * obj0 = 0 ;
35189 PyObject * obj1 = 0 ;
35190 PyObject * obj2 = 0 ;
35191 char * kwnames[] = {
35192 (char *) "self",(char *) "x",(char *) "y", NULL
35193 };
35194
35195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35197 if (!SWIG_IsOK(res1)) {
35198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35199 }
35200 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35201 ecode2 = SWIG_AsVal_int(obj1, &val2);
35202 if (!SWIG_IsOK(ecode2)) {
35203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35204 }
35205 arg2 = static_cast< int >(val2);
35206 ecode3 = SWIG_AsVal_int(obj2, &val3);
35207 if (!SWIG_IsOK(ecode3)) {
35208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35209 }
35210 arg3 = static_cast< int >(val3);
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = (bool)(arg1)->OnDrop(arg2,arg3);
35214 wxPyEndAllowThreads(__tstate);
35215 if (PyErr_Occurred()) SWIG_fail;
35216 }
35217 {
35218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35219 }
35220 return resultobj;
35221 fail:
35222 return NULL;
35223 }
35224
35225
35226 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35227 PyObject *resultobj = 0;
35228 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35229 int arg2 ;
35230 int arg3 ;
35231 wxDragResult arg4 ;
35232 wxDragResult result;
35233 void *argp1 = 0 ;
35234 int res1 = 0 ;
35235 int val2 ;
35236 int ecode2 = 0 ;
35237 int val3 ;
35238 int ecode3 = 0 ;
35239 int val4 ;
35240 int ecode4 = 0 ;
35241 PyObject * obj0 = 0 ;
35242 PyObject * obj1 = 0 ;
35243 PyObject * obj2 = 0 ;
35244 PyObject * obj3 = 0 ;
35245 char * kwnames[] = {
35246 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35247 };
35248
35249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35251 if (!SWIG_IsOK(res1)) {
35252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35253 }
35254 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35255 ecode2 = SWIG_AsVal_int(obj1, &val2);
35256 if (!SWIG_IsOK(ecode2)) {
35257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35258 }
35259 arg2 = static_cast< int >(val2);
35260 ecode3 = SWIG_AsVal_int(obj2, &val3);
35261 if (!SWIG_IsOK(ecode3)) {
35262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35263 }
35264 arg3 = static_cast< int >(val3);
35265 ecode4 = SWIG_AsVal_int(obj3, &val4);
35266 if (!SWIG_IsOK(ecode4)) {
35267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35268 }
35269 arg4 = static_cast< wxDragResult >(val4);
35270 {
35271 PyThreadState* __tstate = wxPyBeginAllowThreads();
35272 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35273 wxPyEndAllowThreads(__tstate);
35274 if (PyErr_Occurred()) SWIG_fail;
35275 }
35276 resultobj = SWIG_From_int(static_cast< int >(result));
35277 return resultobj;
35278 fail:
35279 return NULL;
35280 }
35281
35282
35283 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35284 PyObject *obj;
35285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35286 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35287 return SWIG_Py_Void();
35288 }
35289
35290 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35291 return SWIG_Python_InitShadowInstance(args);
35292 }
35293
35294 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35295 PyObject *resultobj = 0;
35296 wxClipboard *result = 0 ;
35297
35298 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 result = (wxClipboard *)new wxClipboard();
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35306 return resultobj;
35307 fail:
35308 return NULL;
35309 }
35310
35311
35312 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35313 PyObject *resultobj = 0;
35314 wxClipboard *arg1 = (wxClipboard *) 0 ;
35315 void *argp1 = 0 ;
35316 int res1 = 0 ;
35317 PyObject *swig_obj[1] ;
35318
35319 if (!args) SWIG_fail;
35320 swig_obj[0] = args;
35321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35322 if (!SWIG_IsOK(res1)) {
35323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35324 }
35325 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35326 {
35327 PyThreadState* __tstate = wxPyBeginAllowThreads();
35328 delete arg1;
35329
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 resultobj = SWIG_Py_Void();
35334 return resultobj;
35335 fail:
35336 return NULL;
35337 }
35338
35339
35340 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35341 PyObject *resultobj = 0;
35342 wxClipboard *arg1 = (wxClipboard *) 0 ;
35343 bool result;
35344 void *argp1 = 0 ;
35345 int res1 = 0 ;
35346 PyObject *swig_obj[1] ;
35347
35348 if (!args) SWIG_fail;
35349 swig_obj[0] = args;
35350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35351 if (!SWIG_IsOK(res1)) {
35352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35353 }
35354 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35355 {
35356 PyThreadState* __tstate = wxPyBeginAllowThreads();
35357 result = (bool)(arg1)->Open();
35358 wxPyEndAllowThreads(__tstate);
35359 if (PyErr_Occurred()) SWIG_fail;
35360 }
35361 {
35362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35363 }
35364 return resultobj;
35365 fail:
35366 return NULL;
35367 }
35368
35369
35370 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35371 PyObject *resultobj = 0;
35372 wxClipboard *arg1 = (wxClipboard *) 0 ;
35373 void *argp1 = 0 ;
35374 int res1 = 0 ;
35375 PyObject *swig_obj[1] ;
35376
35377 if (!args) SWIG_fail;
35378 swig_obj[0] = args;
35379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35380 if (!SWIG_IsOK(res1)) {
35381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35382 }
35383 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35384 {
35385 PyThreadState* __tstate = wxPyBeginAllowThreads();
35386 (arg1)->Close();
35387 wxPyEndAllowThreads(__tstate);
35388 if (PyErr_Occurred()) SWIG_fail;
35389 }
35390 resultobj = SWIG_Py_Void();
35391 return resultobj;
35392 fail:
35393 return NULL;
35394 }
35395
35396
35397 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35398 PyObject *resultobj = 0;
35399 wxClipboard *arg1 = (wxClipboard *) 0 ;
35400 bool result;
35401 void *argp1 = 0 ;
35402 int res1 = 0 ;
35403 PyObject *swig_obj[1] ;
35404
35405 if (!args) SWIG_fail;
35406 swig_obj[0] = args;
35407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35408 if (!SWIG_IsOK(res1)) {
35409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35410 }
35411 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35412 {
35413 PyThreadState* __tstate = wxPyBeginAllowThreads();
35414 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35415 wxPyEndAllowThreads(__tstate);
35416 if (PyErr_Occurred()) SWIG_fail;
35417 }
35418 {
35419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35420 }
35421 return resultobj;
35422 fail:
35423 return NULL;
35424 }
35425
35426
35427 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35428 PyObject *resultobj = 0;
35429 wxClipboard *arg1 = (wxClipboard *) 0 ;
35430 wxDataObject *arg2 = (wxDataObject *) 0 ;
35431 bool result;
35432 void *argp1 = 0 ;
35433 int res1 = 0 ;
35434 int res2 = 0 ;
35435 PyObject * obj0 = 0 ;
35436 PyObject * obj1 = 0 ;
35437 char * kwnames[] = {
35438 (char *) "self",(char *) "data", NULL
35439 };
35440
35441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35443 if (!SWIG_IsOK(res1)) {
35444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35445 }
35446 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35447 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35448 if (!SWIG_IsOK(res2)) {
35449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35450 }
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = (bool)(arg1)->AddData(arg2);
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 {
35458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35459 }
35460 return resultobj;
35461 fail:
35462 return NULL;
35463 }
35464
35465
35466 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35467 PyObject *resultobj = 0;
35468 wxClipboard *arg1 = (wxClipboard *) 0 ;
35469 wxDataObject *arg2 = (wxDataObject *) 0 ;
35470 bool result;
35471 void *argp1 = 0 ;
35472 int res1 = 0 ;
35473 int res2 = 0 ;
35474 PyObject * obj0 = 0 ;
35475 PyObject * obj1 = 0 ;
35476 char * kwnames[] = {
35477 (char *) "self",(char *) "data", NULL
35478 };
35479
35480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35484 }
35485 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35486 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35487 if (!SWIG_IsOK(res2)) {
35488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35489 }
35490 {
35491 PyThreadState* __tstate = wxPyBeginAllowThreads();
35492 result = (bool)(arg1)->SetData(arg2);
35493 wxPyEndAllowThreads(__tstate);
35494 if (PyErr_Occurred()) SWIG_fail;
35495 }
35496 {
35497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35498 }
35499 return resultobj;
35500 fail:
35501 return NULL;
35502 }
35503
35504
35505 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35506 PyObject *resultobj = 0;
35507 wxClipboard *arg1 = (wxClipboard *) 0 ;
35508 wxDataFormat *arg2 = 0 ;
35509 bool result;
35510 void *argp1 = 0 ;
35511 int res1 = 0 ;
35512 void *argp2 = 0 ;
35513 int res2 = 0 ;
35514 PyObject * obj0 = 0 ;
35515 PyObject * obj1 = 0 ;
35516 char * kwnames[] = {
35517 (char *) "self",(char *) "format", NULL
35518 };
35519
35520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35522 if (!SWIG_IsOK(res1)) {
35523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35524 }
35525 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35526 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35527 if (!SWIG_IsOK(res2)) {
35528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35529 }
35530 if (!argp2) {
35531 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35532 }
35533 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35534 {
35535 PyThreadState* __tstate = wxPyBeginAllowThreads();
35536 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35537 wxPyEndAllowThreads(__tstate);
35538 if (PyErr_Occurred()) SWIG_fail;
35539 }
35540 {
35541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35542 }
35543 return resultobj;
35544 fail:
35545 return NULL;
35546 }
35547
35548
35549 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35550 PyObject *resultobj = 0;
35551 wxClipboard *arg1 = (wxClipboard *) 0 ;
35552 wxDataObject *arg2 = 0 ;
35553 bool result;
35554 void *argp1 = 0 ;
35555 int res1 = 0 ;
35556 void *argp2 = 0 ;
35557 int res2 = 0 ;
35558 PyObject * obj0 = 0 ;
35559 PyObject * obj1 = 0 ;
35560 char * kwnames[] = {
35561 (char *) "self",(char *) "data", NULL
35562 };
35563
35564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35566 if (!SWIG_IsOK(res1)) {
35567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35568 }
35569 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35570 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35571 if (!SWIG_IsOK(res2)) {
35572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35573 }
35574 if (!argp2) {
35575 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35576 }
35577 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35578 {
35579 PyThreadState* __tstate = wxPyBeginAllowThreads();
35580 result = (bool)(arg1)->GetData(*arg2);
35581 wxPyEndAllowThreads(__tstate);
35582 if (PyErr_Occurred()) SWIG_fail;
35583 }
35584 {
35585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35586 }
35587 return resultobj;
35588 fail:
35589 return NULL;
35590 }
35591
35592
35593 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35594 PyObject *resultobj = 0;
35595 wxClipboard *arg1 = (wxClipboard *) 0 ;
35596 void *argp1 = 0 ;
35597 int res1 = 0 ;
35598 PyObject *swig_obj[1] ;
35599
35600 if (!args) SWIG_fail;
35601 swig_obj[0] = args;
35602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35603 if (!SWIG_IsOK(res1)) {
35604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35605 }
35606 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35607 {
35608 PyThreadState* __tstate = wxPyBeginAllowThreads();
35609 (arg1)->Clear();
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 resultobj = SWIG_Py_Void();
35614 return resultobj;
35615 fail:
35616 return NULL;
35617 }
35618
35619
35620 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35621 PyObject *resultobj = 0;
35622 wxClipboard *arg1 = (wxClipboard *) 0 ;
35623 bool result;
35624 void *argp1 = 0 ;
35625 int res1 = 0 ;
35626 PyObject *swig_obj[1] ;
35627
35628 if (!args) SWIG_fail;
35629 swig_obj[0] = args;
35630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35631 if (!SWIG_IsOK(res1)) {
35632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35633 }
35634 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35635 {
35636 PyThreadState* __tstate = wxPyBeginAllowThreads();
35637 result = (bool)(arg1)->Flush();
35638 wxPyEndAllowThreads(__tstate);
35639 if (PyErr_Occurred()) SWIG_fail;
35640 }
35641 {
35642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35643 }
35644 return resultobj;
35645 fail:
35646 return NULL;
35647 }
35648
35649
35650 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35651 PyObject *resultobj = 0;
35652 wxClipboard *arg1 = (wxClipboard *) 0 ;
35653 bool arg2 = (bool) true ;
35654 void *argp1 = 0 ;
35655 int res1 = 0 ;
35656 bool val2 ;
35657 int ecode2 = 0 ;
35658 PyObject * obj0 = 0 ;
35659 PyObject * obj1 = 0 ;
35660 char * kwnames[] = {
35661 (char *) "self",(char *) "primary", NULL
35662 };
35663
35664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35666 if (!SWIG_IsOK(res1)) {
35667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35668 }
35669 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35670 if (obj1) {
35671 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35672 if (!SWIG_IsOK(ecode2)) {
35673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35674 }
35675 arg2 = static_cast< bool >(val2);
35676 }
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 (arg1)->UsePrimarySelection(arg2);
35680 wxPyEndAllowThreads(__tstate);
35681 if (PyErr_Occurred()) SWIG_fail;
35682 }
35683 resultobj = SWIG_Py_Void();
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35691 PyObject *resultobj = 0;
35692 wxClipboard *result = 0 ;
35693
35694 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 result = (wxClipboard *)wxClipboard::Get();
35698 wxPyEndAllowThreads(__tstate);
35699 if (PyErr_Occurred()) SWIG_fail;
35700 }
35701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35702 return resultobj;
35703 fail:
35704 return NULL;
35705 }
35706
35707
35708 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35709 PyObject *obj;
35710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35711 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35712 return SWIG_Py_Void();
35713 }
35714
35715 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35716 return SWIG_Python_InitShadowInstance(args);
35717 }
35718
35719 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35720 PyObject *resultobj = 0;
35721 wxClipboard *arg1 = (wxClipboard *) NULL ;
35722 wxClipboardLocker *result = 0 ;
35723 void *argp1 = 0 ;
35724 int res1 = 0 ;
35725 PyObject * obj0 = 0 ;
35726 char * kwnames[] = {
35727 (char *) "clipboard", NULL
35728 };
35729
35730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35731 if (obj0) {
35732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35733 if (!SWIG_IsOK(res1)) {
35734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35735 }
35736 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35737 }
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35745 return resultobj;
35746 fail:
35747 return NULL;
35748 }
35749
35750
35751 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35752 PyObject *resultobj = 0;
35753 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35754 void *argp1 = 0 ;
35755 int res1 = 0 ;
35756 PyObject *swig_obj[1] ;
35757
35758 if (!args) SWIG_fail;
35759 swig_obj[0] = args;
35760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35761 if (!SWIG_IsOK(res1)) {
35762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35763 }
35764 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35765 {
35766 PyThreadState* __tstate = wxPyBeginAllowThreads();
35767 delete arg1;
35768
35769 wxPyEndAllowThreads(__tstate);
35770 if (PyErr_Occurred()) SWIG_fail;
35771 }
35772 resultobj = SWIG_Py_Void();
35773 return resultobj;
35774 fail:
35775 return NULL;
35776 }
35777
35778
35779 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35780 PyObject *resultobj = 0;
35781 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35782 bool result;
35783 void *argp1 = 0 ;
35784 int res1 = 0 ;
35785 PyObject *swig_obj[1] ;
35786
35787 if (!args) SWIG_fail;
35788 swig_obj[0] = args;
35789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35790 if (!SWIG_IsOK(res1)) {
35791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35792 }
35793 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35794 {
35795 PyThreadState* __tstate = wxPyBeginAllowThreads();
35796 result = (bool)wxClipboardLocker___nonzero__(arg1);
35797 wxPyEndAllowThreads(__tstate);
35798 if (PyErr_Occurred()) SWIG_fail;
35799 }
35800 {
35801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35802 }
35803 return resultobj;
35804 fail:
35805 return NULL;
35806 }
35807
35808
35809 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35810 PyObject *obj;
35811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35812 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35813 return SWIG_Py_Void();
35814 }
35815
35816 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35817 return SWIG_Python_InitShadowInstance(args);
35818 }
35819
35820 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35821 PyObject *resultobj = 0;
35822 int arg1 = (int) 0 ;
35823 int arg2 = (int) 0 ;
35824 int arg3 = (int) 0 ;
35825 int arg4 = (int) 0 ;
35826 wxVideoMode *result = 0 ;
35827 int val1 ;
35828 int ecode1 = 0 ;
35829 int val2 ;
35830 int ecode2 = 0 ;
35831 int val3 ;
35832 int ecode3 = 0 ;
35833 int val4 ;
35834 int ecode4 = 0 ;
35835 PyObject * obj0 = 0 ;
35836 PyObject * obj1 = 0 ;
35837 PyObject * obj2 = 0 ;
35838 PyObject * obj3 = 0 ;
35839 char * kwnames[] = {
35840 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35841 };
35842
35843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35844 if (obj0) {
35845 ecode1 = SWIG_AsVal_int(obj0, &val1);
35846 if (!SWIG_IsOK(ecode1)) {
35847 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35848 }
35849 arg1 = static_cast< int >(val1);
35850 }
35851 if (obj1) {
35852 ecode2 = SWIG_AsVal_int(obj1, &val2);
35853 if (!SWIG_IsOK(ecode2)) {
35854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35855 }
35856 arg2 = static_cast< int >(val2);
35857 }
35858 if (obj2) {
35859 ecode3 = SWIG_AsVal_int(obj2, &val3);
35860 if (!SWIG_IsOK(ecode3)) {
35861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35862 }
35863 arg3 = static_cast< int >(val3);
35864 }
35865 if (obj3) {
35866 ecode4 = SWIG_AsVal_int(obj3, &val4);
35867 if (!SWIG_IsOK(ecode4)) {
35868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35869 }
35870 arg4 = static_cast< int >(val4);
35871 }
35872 {
35873 PyThreadState* __tstate = wxPyBeginAllowThreads();
35874 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35875 wxPyEndAllowThreads(__tstate);
35876 if (PyErr_Occurred()) SWIG_fail;
35877 }
35878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35879 return resultobj;
35880 fail:
35881 return NULL;
35882 }
35883
35884
35885 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35886 PyObject *resultobj = 0;
35887 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35888 void *argp1 = 0 ;
35889 int res1 = 0 ;
35890 PyObject *swig_obj[1] ;
35891
35892 if (!args) SWIG_fail;
35893 swig_obj[0] = args;
35894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35895 if (!SWIG_IsOK(res1)) {
35896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35897 }
35898 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35899 {
35900 PyThreadState* __tstate = wxPyBeginAllowThreads();
35901 delete arg1;
35902
35903 wxPyEndAllowThreads(__tstate);
35904 if (PyErr_Occurred()) SWIG_fail;
35905 }
35906 resultobj = SWIG_Py_Void();
35907 return resultobj;
35908 fail:
35909 return NULL;
35910 }
35911
35912
35913 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35914 PyObject *resultobj = 0;
35915 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35916 wxVideoMode *arg2 = 0 ;
35917 bool result;
35918 void *argp1 = 0 ;
35919 int res1 = 0 ;
35920 void *argp2 = 0 ;
35921 int res2 = 0 ;
35922 PyObject * obj0 = 0 ;
35923 PyObject * obj1 = 0 ;
35924 char * kwnames[] = {
35925 (char *) "self",(char *) "other", NULL
35926 };
35927
35928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35930 if (!SWIG_IsOK(res1)) {
35931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35932 }
35933 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35935 if (!SWIG_IsOK(res2)) {
35936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35937 }
35938 if (!argp2) {
35939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35940 }
35941 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35942 {
35943 PyThreadState* __tstate = wxPyBeginAllowThreads();
35944 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35945 wxPyEndAllowThreads(__tstate);
35946 if (PyErr_Occurred()) SWIG_fail;
35947 }
35948 {
35949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35950 }
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35958 PyObject *resultobj = 0;
35959 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35960 int result;
35961 void *argp1 = 0 ;
35962 int res1 = 0 ;
35963 PyObject *swig_obj[1] ;
35964
35965 if (!args) SWIG_fail;
35966 swig_obj[0] = args;
35967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35968 if (!SWIG_IsOK(res1)) {
35969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35970 }
35971 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_From_int(static_cast< int >(result));
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35986 PyObject *resultobj = 0;
35987 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35988 int result;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 PyObject *swig_obj[1] ;
35992
35993 if (!args) SWIG_fail;
35994 swig_obj[0] = args;
35995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35996 if (!SWIG_IsOK(res1)) {
35997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35998 }
35999 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36000 {
36001 PyThreadState* __tstate = wxPyBeginAllowThreads();
36002 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36003 wxPyEndAllowThreads(__tstate);
36004 if (PyErr_Occurred()) SWIG_fail;
36005 }
36006 resultobj = SWIG_From_int(static_cast< int >(result));
36007 return resultobj;
36008 fail:
36009 return NULL;
36010 }
36011
36012
36013 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36014 PyObject *resultobj = 0;
36015 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36016 int result;
36017 void *argp1 = 0 ;
36018 int res1 = 0 ;
36019 PyObject *swig_obj[1] ;
36020
36021 if (!args) SWIG_fail;
36022 swig_obj[0] = args;
36023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36024 if (!SWIG_IsOK(res1)) {
36025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36026 }
36027 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36028 {
36029 PyThreadState* __tstate = wxPyBeginAllowThreads();
36030 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36031 wxPyEndAllowThreads(__tstate);
36032 if (PyErr_Occurred()) SWIG_fail;
36033 }
36034 resultobj = SWIG_From_int(static_cast< int >(result));
36035 return resultobj;
36036 fail:
36037 return NULL;
36038 }
36039
36040
36041 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36042 PyObject *resultobj = 0;
36043 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36044 bool result;
36045 void *argp1 = 0 ;
36046 int res1 = 0 ;
36047 PyObject *swig_obj[1] ;
36048
36049 if (!args) SWIG_fail;
36050 swig_obj[0] = args;
36051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36052 if (!SWIG_IsOK(res1)) {
36053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36054 }
36055 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36056 {
36057 PyThreadState* __tstate = wxPyBeginAllowThreads();
36058 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36059 wxPyEndAllowThreads(__tstate);
36060 if (PyErr_Occurred()) SWIG_fail;
36061 }
36062 {
36063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36064 }
36065 return resultobj;
36066 fail:
36067 return NULL;
36068 }
36069
36070
36071 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36072 PyObject *resultobj = 0;
36073 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36074 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36075 bool result;
36076 void *argp1 = 0 ;
36077 int res1 = 0 ;
36078 void *argp2 = 0 ;
36079 int res2 = 0 ;
36080 PyObject * obj0 = 0 ;
36081 PyObject * obj1 = 0 ;
36082 char * kwnames[] = {
36083 (char *) "self",(char *) "other", NULL
36084 };
36085
36086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36088 if (!SWIG_IsOK(res1)) {
36089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36090 }
36091 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36093 if (!SWIG_IsOK(res2)) {
36094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36095 }
36096 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36097 {
36098 PyThreadState* __tstate = wxPyBeginAllowThreads();
36099 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36100 wxPyEndAllowThreads(__tstate);
36101 if (PyErr_Occurred()) SWIG_fail;
36102 }
36103 {
36104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36105 }
36106 return resultobj;
36107 fail:
36108 return NULL;
36109 }
36110
36111
36112 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36113 PyObject *resultobj = 0;
36114 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36115 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36116 bool result;
36117 void *argp1 = 0 ;
36118 int res1 = 0 ;
36119 void *argp2 = 0 ;
36120 int res2 = 0 ;
36121 PyObject * obj0 = 0 ;
36122 PyObject * obj1 = 0 ;
36123 char * kwnames[] = {
36124 (char *) "self",(char *) "other", NULL
36125 };
36126
36127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36129 if (!SWIG_IsOK(res1)) {
36130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36131 }
36132 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36133 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36134 if (!SWIG_IsOK(res2)) {
36135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36136 }
36137 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36138 {
36139 PyThreadState* __tstate = wxPyBeginAllowThreads();
36140 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36141 wxPyEndAllowThreads(__tstate);
36142 if (PyErr_Occurred()) SWIG_fail;
36143 }
36144 {
36145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36146 }
36147 return resultobj;
36148 fail:
36149 return NULL;
36150 }
36151
36152
36153 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36154 PyObject *resultobj = 0;
36155 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36156 int arg2 ;
36157 void *argp1 = 0 ;
36158 int res1 = 0 ;
36159 int val2 ;
36160 int ecode2 = 0 ;
36161 PyObject *swig_obj[2] ;
36162
36163 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36165 if (!SWIG_IsOK(res1)) {
36166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36167 }
36168 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36169 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36170 if (!SWIG_IsOK(ecode2)) {
36171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36172 }
36173 arg2 = static_cast< int >(val2);
36174 if (arg1) (arg1)->w = arg2;
36175
36176 resultobj = SWIG_Py_Void();
36177 return resultobj;
36178 fail:
36179 return NULL;
36180 }
36181
36182
36183 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36184 PyObject *resultobj = 0;
36185 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36186 int result;
36187 void *argp1 = 0 ;
36188 int res1 = 0 ;
36189 PyObject *swig_obj[1] ;
36190
36191 if (!args) SWIG_fail;
36192 swig_obj[0] = args;
36193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36194 if (!SWIG_IsOK(res1)) {
36195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36196 }
36197 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36198 result = (int) ((arg1)->w);
36199 resultobj = SWIG_From_int(static_cast< int >(result));
36200 return resultobj;
36201 fail:
36202 return NULL;
36203 }
36204
36205
36206 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36207 PyObject *resultobj = 0;
36208 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36209 int arg2 ;
36210 void *argp1 = 0 ;
36211 int res1 = 0 ;
36212 int val2 ;
36213 int ecode2 = 0 ;
36214 PyObject *swig_obj[2] ;
36215
36216 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36218 if (!SWIG_IsOK(res1)) {
36219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36220 }
36221 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36222 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36223 if (!SWIG_IsOK(ecode2)) {
36224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36225 }
36226 arg2 = static_cast< int >(val2);
36227 if (arg1) (arg1)->h = arg2;
36228
36229 resultobj = SWIG_Py_Void();
36230 return resultobj;
36231 fail:
36232 return NULL;
36233 }
36234
36235
36236 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36237 PyObject *resultobj = 0;
36238 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36239 int result;
36240 void *argp1 = 0 ;
36241 int res1 = 0 ;
36242 PyObject *swig_obj[1] ;
36243
36244 if (!args) SWIG_fail;
36245 swig_obj[0] = args;
36246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36247 if (!SWIG_IsOK(res1)) {
36248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36249 }
36250 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36251 result = (int) ((arg1)->h);
36252 resultobj = SWIG_From_int(static_cast< int >(result));
36253 return resultobj;
36254 fail:
36255 return NULL;
36256 }
36257
36258
36259 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36260 PyObject *resultobj = 0;
36261 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36262 int arg2 ;
36263 void *argp1 = 0 ;
36264 int res1 = 0 ;
36265 int val2 ;
36266 int ecode2 = 0 ;
36267 PyObject *swig_obj[2] ;
36268
36269 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36271 if (!SWIG_IsOK(res1)) {
36272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36273 }
36274 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36275 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36276 if (!SWIG_IsOK(ecode2)) {
36277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36278 }
36279 arg2 = static_cast< int >(val2);
36280 if (arg1) (arg1)->bpp = arg2;
36281
36282 resultobj = SWIG_Py_Void();
36283 return resultobj;
36284 fail:
36285 return NULL;
36286 }
36287
36288
36289 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36290 PyObject *resultobj = 0;
36291 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36292 int result;
36293 void *argp1 = 0 ;
36294 int res1 = 0 ;
36295 PyObject *swig_obj[1] ;
36296
36297 if (!args) SWIG_fail;
36298 swig_obj[0] = args;
36299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36300 if (!SWIG_IsOK(res1)) {
36301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36302 }
36303 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36304 result = (int) ((arg1)->bpp);
36305 resultobj = SWIG_From_int(static_cast< int >(result));
36306 return resultobj;
36307 fail:
36308 return NULL;
36309 }
36310
36311
36312 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36313 PyObject *resultobj = 0;
36314 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36315 int arg2 ;
36316 void *argp1 = 0 ;
36317 int res1 = 0 ;
36318 int val2 ;
36319 int ecode2 = 0 ;
36320 PyObject *swig_obj[2] ;
36321
36322 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36324 if (!SWIG_IsOK(res1)) {
36325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36326 }
36327 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36328 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36329 if (!SWIG_IsOK(ecode2)) {
36330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36331 }
36332 arg2 = static_cast< int >(val2);
36333 if (arg1) (arg1)->refresh = arg2;
36334
36335 resultobj = SWIG_Py_Void();
36336 return resultobj;
36337 fail:
36338 return NULL;
36339 }
36340
36341
36342 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36343 PyObject *resultobj = 0;
36344 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36345 int result;
36346 void *argp1 = 0 ;
36347 int res1 = 0 ;
36348 PyObject *swig_obj[1] ;
36349
36350 if (!args) SWIG_fail;
36351 swig_obj[0] = args;
36352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36353 if (!SWIG_IsOK(res1)) {
36354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36355 }
36356 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36357 result = (int) ((arg1)->refresh);
36358 resultobj = SWIG_From_int(static_cast< int >(result));
36359 return resultobj;
36360 fail:
36361 return NULL;
36362 }
36363
36364
36365 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36366 PyObject *obj;
36367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36368 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36369 return SWIG_Py_Void();
36370 }
36371
36372 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36373 return SWIG_Python_InitShadowInstance(args);
36374 }
36375
36376 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36377 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36378 return 1;
36379 }
36380
36381
36382 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36383 PyObject *pyobj = 0;
36384
36385 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36386 return pyobj;
36387 }
36388
36389
36390 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36391 PyObject *resultobj = 0;
36392 unsigned int arg1 = (unsigned int) 0 ;
36393 wxDisplay *result = 0 ;
36394 unsigned int val1 ;
36395 int ecode1 = 0 ;
36396 PyObject * obj0 = 0 ;
36397 char * kwnames[] = {
36398 (char *) "index", NULL
36399 };
36400
36401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36402 if (obj0) {
36403 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36404 if (!SWIG_IsOK(ecode1)) {
36405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36406 }
36407 arg1 = static_cast< unsigned int >(val1);
36408 }
36409 {
36410 PyThreadState* __tstate = wxPyBeginAllowThreads();
36411 result = (wxDisplay *)new wxDisplay(arg1);
36412 wxPyEndAllowThreads(__tstate);
36413 if (PyErr_Occurred()) SWIG_fail;
36414 }
36415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36416 return resultobj;
36417 fail:
36418 return NULL;
36419 }
36420
36421
36422 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36423 PyObject *resultobj = 0;
36424 wxDisplay *arg1 = (wxDisplay *) 0 ;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 PyObject *swig_obj[1] ;
36428
36429 if (!args) SWIG_fail;
36430 swig_obj[0] = args;
36431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36434 }
36435 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36436 {
36437 PyThreadState* __tstate = wxPyBeginAllowThreads();
36438 delete arg1;
36439
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 resultobj = SWIG_Py_Void();
36444 return resultobj;
36445 fail:
36446 return NULL;
36447 }
36448
36449
36450 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36451 PyObject *resultobj = 0;
36452 unsigned int result;
36453
36454 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36455 {
36456 PyThreadState* __tstate = wxPyBeginAllowThreads();
36457 result = (unsigned int)wxDisplay::GetCount();
36458 wxPyEndAllowThreads(__tstate);
36459 if (PyErr_Occurred()) SWIG_fail;
36460 }
36461 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36462 return resultobj;
36463 fail:
36464 return NULL;
36465 }
36466
36467
36468 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36469 PyObject *resultobj = 0;
36470 wxPoint *arg1 = 0 ;
36471 int result;
36472 wxPoint temp1 ;
36473 PyObject * obj0 = 0 ;
36474 char * kwnames[] = {
36475 (char *) "pt", NULL
36476 };
36477
36478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36479 {
36480 arg1 = &temp1;
36481 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36482 }
36483 {
36484 PyThreadState* __tstate = wxPyBeginAllowThreads();
36485 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36486 wxPyEndAllowThreads(__tstate);
36487 if (PyErr_Occurred()) SWIG_fail;
36488 }
36489 resultobj = SWIG_From_int(static_cast< int >(result));
36490 return resultobj;
36491 fail:
36492 return NULL;
36493 }
36494
36495
36496 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36497 PyObject *resultobj = 0;
36498 wxWindow *arg1 = (wxWindow *) 0 ;
36499 int result;
36500 void *argp1 = 0 ;
36501 int res1 = 0 ;
36502 PyObject * obj0 = 0 ;
36503 char * kwnames[] = {
36504 (char *) "window", NULL
36505 };
36506
36507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36509 if (!SWIG_IsOK(res1)) {
36510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36511 }
36512 arg1 = reinterpret_cast< wxWindow * >(argp1);
36513 {
36514 PyThreadState* __tstate = wxPyBeginAllowThreads();
36515 result = (int)wxDisplay::GetFromWindow(arg1);
36516 wxPyEndAllowThreads(__tstate);
36517 if (PyErr_Occurred()) SWIG_fail;
36518 }
36519 resultobj = SWIG_From_int(static_cast< int >(result));
36520 return resultobj;
36521 fail:
36522 return NULL;
36523 }
36524
36525
36526 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36527 PyObject *resultobj = 0;
36528 wxDisplay *arg1 = (wxDisplay *) 0 ;
36529 bool result;
36530 void *argp1 = 0 ;
36531 int res1 = 0 ;
36532 PyObject *swig_obj[1] ;
36533
36534 if (!args) SWIG_fail;
36535 swig_obj[0] = args;
36536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36537 if (!SWIG_IsOK(res1)) {
36538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36539 }
36540 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36541 {
36542 PyThreadState* __tstate = wxPyBeginAllowThreads();
36543 result = (bool)((wxDisplay const *)arg1)->IsOk();
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 {
36548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36549 }
36550 return resultobj;
36551 fail:
36552 return NULL;
36553 }
36554
36555
36556 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36557 PyObject *resultobj = 0;
36558 wxDisplay *arg1 = (wxDisplay *) 0 ;
36559 wxRect result;
36560 void *argp1 = 0 ;
36561 int res1 = 0 ;
36562 PyObject *swig_obj[1] ;
36563
36564 if (!args) SWIG_fail;
36565 swig_obj[0] = args;
36566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36567 if (!SWIG_IsOK(res1)) {
36568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36569 }
36570 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 result = ((wxDisplay const *)arg1)->GetGeometry();
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36578 return resultobj;
36579 fail:
36580 return NULL;
36581 }
36582
36583
36584 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36585 PyObject *resultobj = 0;
36586 wxDisplay *arg1 = (wxDisplay *) 0 ;
36587 wxRect result;
36588 void *argp1 = 0 ;
36589 int res1 = 0 ;
36590 PyObject *swig_obj[1] ;
36591
36592 if (!args) SWIG_fail;
36593 swig_obj[0] = args;
36594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36595 if (!SWIG_IsOK(res1)) {
36596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36597 }
36598 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = ((wxDisplay const *)arg1)->GetClientArea();
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36613 PyObject *resultobj = 0;
36614 wxDisplay *arg1 = (wxDisplay *) 0 ;
36615 wxString result;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 PyObject *swig_obj[1] ;
36619
36620 if (!args) SWIG_fail;
36621 swig_obj[0] = args;
36622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36623 if (!SWIG_IsOK(res1)) {
36624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36625 }
36626 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36627 {
36628 PyThreadState* __tstate = wxPyBeginAllowThreads();
36629 result = ((wxDisplay const *)arg1)->GetName();
36630 wxPyEndAllowThreads(__tstate);
36631 if (PyErr_Occurred()) SWIG_fail;
36632 }
36633 {
36634 #if wxUSE_UNICODE
36635 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36636 #else
36637 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36638 #endif
36639 }
36640 return resultobj;
36641 fail:
36642 return NULL;
36643 }
36644
36645
36646 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36647 PyObject *resultobj = 0;
36648 wxDisplay *arg1 = (wxDisplay *) 0 ;
36649 bool result;
36650 void *argp1 = 0 ;
36651 int res1 = 0 ;
36652 PyObject *swig_obj[1] ;
36653
36654 if (!args) SWIG_fail;
36655 swig_obj[0] = args;
36656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36657 if (!SWIG_IsOK(res1)) {
36658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36659 }
36660 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36661 {
36662 PyThreadState* __tstate = wxPyBeginAllowThreads();
36663 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36664 wxPyEndAllowThreads(__tstate);
36665 if (PyErr_Occurred()) SWIG_fail;
36666 }
36667 {
36668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36669 }
36670 return resultobj;
36671 fail:
36672 return NULL;
36673 }
36674
36675
36676 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36677 PyObject *resultobj = 0;
36678 wxDisplay *arg1 = (wxDisplay *) 0 ;
36679 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36680 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36681 PyObject *result = 0 ;
36682 void *argp1 = 0 ;
36683 int res1 = 0 ;
36684 void *argp2 = 0 ;
36685 int res2 = 0 ;
36686 PyObject * obj0 = 0 ;
36687 PyObject * obj1 = 0 ;
36688 char * kwnames[] = {
36689 (char *) "self",(char *) "mode", NULL
36690 };
36691
36692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36694 if (!SWIG_IsOK(res1)) {
36695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36696 }
36697 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36698 if (obj1) {
36699 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36700 if (!SWIG_IsOK(res2)) {
36701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36702 }
36703 if (!argp2) {
36704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36705 }
36706 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36707 }
36708 {
36709 PyThreadState* __tstate = wxPyBeginAllowThreads();
36710 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36711 wxPyEndAllowThreads(__tstate);
36712 if (PyErr_Occurred()) SWIG_fail;
36713 }
36714 resultobj = result;
36715 return resultobj;
36716 fail:
36717 return NULL;
36718 }
36719
36720
36721 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36722 PyObject *resultobj = 0;
36723 wxDisplay *arg1 = (wxDisplay *) 0 ;
36724 wxVideoMode result;
36725 void *argp1 = 0 ;
36726 int res1 = 0 ;
36727 PyObject *swig_obj[1] ;
36728
36729 if (!args) SWIG_fail;
36730 swig_obj[0] = args;
36731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36732 if (!SWIG_IsOK(res1)) {
36733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36734 }
36735 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36736 {
36737 PyThreadState* __tstate = wxPyBeginAllowThreads();
36738 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36739 wxPyEndAllowThreads(__tstate);
36740 if (PyErr_Occurred()) SWIG_fail;
36741 }
36742 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36743 return resultobj;
36744 fail:
36745 return NULL;
36746 }
36747
36748
36749 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36750 PyObject *resultobj = 0;
36751 wxDisplay *arg1 = (wxDisplay *) 0 ;
36752 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36753 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36754 bool result;
36755 void *argp1 = 0 ;
36756 int res1 = 0 ;
36757 void *argp2 = 0 ;
36758 int res2 = 0 ;
36759 PyObject * obj0 = 0 ;
36760 PyObject * obj1 = 0 ;
36761 char * kwnames[] = {
36762 (char *) "self",(char *) "mode", NULL
36763 };
36764
36765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36767 if (!SWIG_IsOK(res1)) {
36768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36769 }
36770 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36771 if (obj1) {
36772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36773 if (!SWIG_IsOK(res2)) {
36774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36775 }
36776 if (!argp2) {
36777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36778 }
36779 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36780 }
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 {
36788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36789 }
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36797 PyObject *resultobj = 0;
36798 wxDisplay *arg1 = (wxDisplay *) 0 ;
36799 void *argp1 = 0 ;
36800 int res1 = 0 ;
36801 PyObject *swig_obj[1] ;
36802
36803 if (!args) SWIG_fail;
36804 swig_obj[0] = args;
36805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36806 if (!SWIG_IsOK(res1)) {
36807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36808 }
36809 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36810 {
36811 PyThreadState* __tstate = wxPyBeginAllowThreads();
36812 wxDisplay_ResetMode(arg1);
36813 wxPyEndAllowThreads(__tstate);
36814 if (PyErr_Occurred()) SWIG_fail;
36815 }
36816 resultobj = SWIG_Py_Void();
36817 return resultobj;
36818 fail:
36819 return NULL;
36820 }
36821
36822
36823 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36824 PyObject *obj;
36825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36826 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36827 return SWIG_Py_Void();
36828 }
36829
36830 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36831 return SWIG_Python_InitShadowInstance(args);
36832 }
36833
36834 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36835 PyObject *resultobj = 0;
36836 wxStandardPaths *result = 0 ;
36837
36838 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36839 {
36840 PyThreadState* __tstate = wxPyBeginAllowThreads();
36841 result = (wxStandardPaths *)wxStandardPaths_Get();
36842 wxPyEndAllowThreads(__tstate);
36843 if (PyErr_Occurred()) SWIG_fail;
36844 }
36845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36846 return resultobj;
36847 fail:
36848 return NULL;
36849 }
36850
36851
36852 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36853 PyObject *resultobj = 0;
36854 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36855 wxString result;
36856 void *argp1 = 0 ;
36857 int res1 = 0 ;
36858 PyObject *swig_obj[1] ;
36859
36860 if (!args) SWIG_fail;
36861 swig_obj[0] = args;
36862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36863 if (!SWIG_IsOK(res1)) {
36864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36865 }
36866 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36867 {
36868 PyThreadState* __tstate = wxPyBeginAllowThreads();
36869 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36870 wxPyEndAllowThreads(__tstate);
36871 if (PyErr_Occurred()) SWIG_fail;
36872 }
36873 {
36874 #if wxUSE_UNICODE
36875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36876 #else
36877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36878 #endif
36879 }
36880 return resultobj;
36881 fail:
36882 return NULL;
36883 }
36884
36885
36886 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36887 PyObject *resultobj = 0;
36888 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36889 wxString result;
36890 void *argp1 = 0 ;
36891 int res1 = 0 ;
36892 PyObject *swig_obj[1] ;
36893
36894 if (!args) SWIG_fail;
36895 swig_obj[0] = args;
36896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36897 if (!SWIG_IsOK(res1)) {
36898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36899 }
36900 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36901 {
36902 PyThreadState* __tstate = wxPyBeginAllowThreads();
36903 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36904 wxPyEndAllowThreads(__tstate);
36905 if (PyErr_Occurred()) SWIG_fail;
36906 }
36907 {
36908 #if wxUSE_UNICODE
36909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36910 #else
36911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36912 #endif
36913 }
36914 return resultobj;
36915 fail:
36916 return NULL;
36917 }
36918
36919
36920 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36921 PyObject *resultobj = 0;
36922 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36923 wxString result;
36924 void *argp1 = 0 ;
36925 int res1 = 0 ;
36926 PyObject *swig_obj[1] ;
36927
36928 if (!args) SWIG_fail;
36929 swig_obj[0] = args;
36930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36931 if (!SWIG_IsOK(res1)) {
36932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36933 }
36934 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36935 {
36936 PyThreadState* __tstate = wxPyBeginAllowThreads();
36937 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36938 wxPyEndAllowThreads(__tstate);
36939 if (PyErr_Occurred()) SWIG_fail;
36940 }
36941 {
36942 #if wxUSE_UNICODE
36943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36944 #else
36945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36946 #endif
36947 }
36948 return resultobj;
36949 fail:
36950 return NULL;
36951 }
36952
36953
36954 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36955 PyObject *resultobj = 0;
36956 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36957 wxString result;
36958 void *argp1 = 0 ;
36959 int res1 = 0 ;
36960 PyObject *swig_obj[1] ;
36961
36962 if (!args) SWIG_fail;
36963 swig_obj[0] = args;
36964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36965 if (!SWIG_IsOK(res1)) {
36966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36967 }
36968 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36969 {
36970 PyThreadState* __tstate = wxPyBeginAllowThreads();
36971 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36972 wxPyEndAllowThreads(__tstate);
36973 if (PyErr_Occurred()) SWIG_fail;
36974 }
36975 {
36976 #if wxUSE_UNICODE
36977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36978 #else
36979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36980 #endif
36981 }
36982 return resultobj;
36983 fail:
36984 return NULL;
36985 }
36986
36987
36988 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36989 PyObject *resultobj = 0;
36990 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36991 wxString result;
36992 void *argp1 = 0 ;
36993 int res1 = 0 ;
36994 PyObject *swig_obj[1] ;
36995
36996 if (!args) SWIG_fail;
36997 swig_obj[0] = args;
36998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36999 if (!SWIG_IsOK(res1)) {
37000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37001 }
37002 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37003 {
37004 PyThreadState* __tstate = wxPyBeginAllowThreads();
37005 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37006 wxPyEndAllowThreads(__tstate);
37007 if (PyErr_Occurred()) SWIG_fail;
37008 }
37009 {
37010 #if wxUSE_UNICODE
37011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37012 #else
37013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37014 #endif
37015 }
37016 return resultobj;
37017 fail:
37018 return NULL;
37019 }
37020
37021
37022 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37023 PyObject *resultobj = 0;
37024 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37025 wxString result;
37026 void *argp1 = 0 ;
37027 int res1 = 0 ;
37028 PyObject *swig_obj[1] ;
37029
37030 if (!args) SWIG_fail;
37031 swig_obj[0] = args;
37032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37033 if (!SWIG_IsOK(res1)) {
37034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37035 }
37036 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37037 {
37038 PyThreadState* __tstate = wxPyBeginAllowThreads();
37039 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37040 wxPyEndAllowThreads(__tstate);
37041 if (PyErr_Occurred()) SWIG_fail;
37042 }
37043 {
37044 #if wxUSE_UNICODE
37045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37046 #else
37047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37048 #endif
37049 }
37050 return resultobj;
37051 fail:
37052 return NULL;
37053 }
37054
37055
37056 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37057 PyObject *resultobj = 0;
37058 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37059 wxString result;
37060 void *argp1 = 0 ;
37061 int res1 = 0 ;
37062 PyObject *swig_obj[1] ;
37063
37064 if (!args) SWIG_fail;
37065 swig_obj[0] = args;
37066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37067 if (!SWIG_IsOK(res1)) {
37068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37069 }
37070 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37071 {
37072 PyThreadState* __tstate = wxPyBeginAllowThreads();
37073 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37074 wxPyEndAllowThreads(__tstate);
37075 if (PyErr_Occurred()) SWIG_fail;
37076 }
37077 {
37078 #if wxUSE_UNICODE
37079 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37080 #else
37081 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37082 #endif
37083 }
37084 return resultobj;
37085 fail:
37086 return NULL;
37087 }
37088
37089
37090 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37091 PyObject *resultobj = 0;
37092 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37093 wxString result;
37094 void *argp1 = 0 ;
37095 int res1 = 0 ;
37096 PyObject *swig_obj[1] ;
37097
37098 if (!args) SWIG_fail;
37099 swig_obj[0] = args;
37100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37101 if (!SWIG_IsOK(res1)) {
37102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37103 }
37104 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37105 {
37106 PyThreadState* __tstate = wxPyBeginAllowThreads();
37107 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37108 wxPyEndAllowThreads(__tstate);
37109 if (PyErr_Occurred()) SWIG_fail;
37110 }
37111 {
37112 #if wxUSE_UNICODE
37113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37114 #else
37115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37116 #endif
37117 }
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37125 PyObject *resultobj = 0;
37126 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37127 wxString result;
37128 void *argp1 = 0 ;
37129 int res1 = 0 ;
37130 PyObject *swig_obj[1] ;
37131
37132 if (!args) SWIG_fail;
37133 swig_obj[0] = args;
37134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37135 if (!SWIG_IsOK(res1)) {
37136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37137 }
37138 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37139 {
37140 PyThreadState* __tstate = wxPyBeginAllowThreads();
37141 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37142 wxPyEndAllowThreads(__tstate);
37143 if (PyErr_Occurred()) SWIG_fail;
37144 }
37145 {
37146 #if wxUSE_UNICODE
37147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37148 #else
37149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37150 #endif
37151 }
37152 return resultobj;
37153 fail:
37154 return NULL;
37155 }
37156
37157
37158 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37159 PyObject *resultobj = 0;
37160 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37161 wxString *arg2 = 0 ;
37162 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37163 wxString result;
37164 void *argp1 = 0 ;
37165 int res1 = 0 ;
37166 bool temp2 = false ;
37167 int val3 ;
37168 int ecode3 = 0 ;
37169 PyObject * obj0 = 0 ;
37170 PyObject * obj1 = 0 ;
37171 PyObject * obj2 = 0 ;
37172 char * kwnames[] = {
37173 (char *) "self",(char *) "lang",(char *) "category", NULL
37174 };
37175
37176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37178 if (!SWIG_IsOK(res1)) {
37179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37180 }
37181 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37182 {
37183 arg2 = wxString_in_helper(obj1);
37184 if (arg2 == NULL) SWIG_fail;
37185 temp2 = true;
37186 }
37187 if (obj2) {
37188 ecode3 = SWIG_AsVal_int(obj2, &val3);
37189 if (!SWIG_IsOK(ecode3)) {
37190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37191 }
37192 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37193 }
37194 {
37195 PyThreadState* __tstate = wxPyBeginAllowThreads();
37196 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 {
37201 #if wxUSE_UNICODE
37202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37203 #else
37204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37205 #endif
37206 }
37207 {
37208 if (temp2)
37209 delete arg2;
37210 }
37211 return resultobj;
37212 fail:
37213 {
37214 if (temp2)
37215 delete arg2;
37216 }
37217 return NULL;
37218 }
37219
37220
37221 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37222 PyObject *resultobj = 0;
37223 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37224 wxString result;
37225 void *argp1 = 0 ;
37226 int res1 = 0 ;
37227 PyObject *swig_obj[1] ;
37228
37229 if (!args) SWIG_fail;
37230 swig_obj[0] = args;
37231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37232 if (!SWIG_IsOK(res1)) {
37233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37234 }
37235 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37236 {
37237 PyThreadState* __tstate = wxPyBeginAllowThreads();
37238 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37239 wxPyEndAllowThreads(__tstate);
37240 if (PyErr_Occurred()) SWIG_fail;
37241 }
37242 {
37243 #if wxUSE_UNICODE
37244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37245 #else
37246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37247 #endif
37248 }
37249 return resultobj;
37250 fail:
37251 return NULL;
37252 }
37253
37254
37255 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37256 PyObject *resultobj = 0;
37257 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37258 wxString result;
37259 void *argp1 = 0 ;
37260 int res1 = 0 ;
37261 PyObject *swig_obj[1] ;
37262
37263 if (!args) SWIG_fail;
37264 swig_obj[0] = args;
37265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37266 if (!SWIG_IsOK(res1)) {
37267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37268 }
37269 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 {
37277 #if wxUSE_UNICODE
37278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37279 #else
37280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37281 #endif
37282 }
37283 return resultobj;
37284 fail:
37285 return NULL;
37286 }
37287
37288
37289 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37290 PyObject *resultobj = 0;
37291 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37292 wxString *arg2 = 0 ;
37293 void *argp1 = 0 ;
37294 int res1 = 0 ;
37295 bool temp2 = false ;
37296 PyObject * obj0 = 0 ;
37297 PyObject * obj1 = 0 ;
37298 char * kwnames[] = {
37299 (char *) "self",(char *) "prefix", NULL
37300 };
37301
37302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37304 if (!SWIG_IsOK(res1)) {
37305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37306 }
37307 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37308 {
37309 arg2 = wxString_in_helper(obj1);
37310 if (arg2 == NULL) SWIG_fail;
37311 temp2 = true;
37312 }
37313 {
37314 PyThreadState* __tstate = wxPyBeginAllowThreads();
37315 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37316 wxPyEndAllowThreads(__tstate);
37317 if (PyErr_Occurred()) SWIG_fail;
37318 }
37319 resultobj = SWIG_Py_Void();
37320 {
37321 if (temp2)
37322 delete arg2;
37323 }
37324 return resultobj;
37325 fail:
37326 {
37327 if (temp2)
37328 delete arg2;
37329 }
37330 return NULL;
37331 }
37332
37333
37334 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37335 PyObject *resultobj = 0;
37336 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37337 wxString result;
37338 void *argp1 = 0 ;
37339 int res1 = 0 ;
37340 PyObject *swig_obj[1] ;
37341
37342 if (!args) SWIG_fail;
37343 swig_obj[0] = args;
37344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37345 if (!SWIG_IsOK(res1)) {
37346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37347 }
37348 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37349 {
37350 PyThreadState* __tstate = wxPyBeginAllowThreads();
37351 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37352 wxPyEndAllowThreads(__tstate);
37353 if (PyErr_Occurred()) SWIG_fail;
37354 }
37355 {
37356 #if wxUSE_UNICODE
37357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37358 #else
37359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37360 #endif
37361 }
37362 return resultobj;
37363 fail:
37364 return NULL;
37365 }
37366
37367
37368 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37369 PyObject *obj;
37370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37371 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37372 return SWIG_Py_Void();
37373 }
37374
37375 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37376 PyObject *resultobj = 0;
37377 wxEventType arg1 ;
37378 wxPowerEvent *result = 0 ;
37379 int val1 ;
37380 int ecode1 = 0 ;
37381 PyObject * obj0 = 0 ;
37382 char * kwnames[] = {
37383 (char *) "evtType", NULL
37384 };
37385
37386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37387 ecode1 = SWIG_AsVal_int(obj0, &val1);
37388 if (!SWIG_IsOK(ecode1)) {
37389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37390 }
37391 arg1 = static_cast< wxEventType >(val1);
37392 {
37393 PyThreadState* __tstate = wxPyBeginAllowThreads();
37394 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37395 wxPyEndAllowThreads(__tstate);
37396 if (PyErr_Occurred()) SWIG_fail;
37397 }
37398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37399 return resultobj;
37400 fail:
37401 return NULL;
37402 }
37403
37404
37405 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37406 PyObject *resultobj = 0;
37407 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37408 void *argp1 = 0 ;
37409 int res1 = 0 ;
37410 PyObject *swig_obj[1] ;
37411
37412 if (!args) SWIG_fail;
37413 swig_obj[0] = args;
37414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37415 if (!SWIG_IsOK(res1)) {
37416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37417 }
37418 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37419 {
37420 PyThreadState* __tstate = wxPyBeginAllowThreads();
37421 (arg1)->Veto();
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 resultobj = SWIG_Py_Void();
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37433 PyObject *resultobj = 0;
37434 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37435 bool result;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 PyObject *swig_obj[1] ;
37439
37440 if (!args) SWIG_fail;
37441 swig_obj[0] = args;
37442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37443 if (!SWIG_IsOK(res1)) {
37444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37445 }
37446 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37447 {
37448 PyThreadState* __tstate = wxPyBeginAllowThreads();
37449 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 {
37454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37455 }
37456 return resultobj;
37457 fail:
37458 return NULL;
37459 }
37460
37461
37462 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37463 PyObject *obj;
37464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37465 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37466 return SWIG_Py_Void();
37467 }
37468
37469 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37470 return SWIG_Python_InitShadowInstance(args);
37471 }
37472
37473 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37474 PyObject *resultobj = 0;
37475 wxPowerType result;
37476
37477 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37478 {
37479 PyThreadState* __tstate = wxPyBeginAllowThreads();
37480 result = (wxPowerType)wxGetPowerType();
37481 wxPyEndAllowThreads(__tstate);
37482 if (PyErr_Occurred()) SWIG_fail;
37483 }
37484 resultobj = SWIG_From_int(static_cast< int >(result));
37485 return resultobj;
37486 fail:
37487 return NULL;
37488 }
37489
37490
37491 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37492 PyObject *resultobj = 0;
37493 wxBatteryState result;
37494
37495 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37496 {
37497 PyThreadState* __tstate = wxPyBeginAllowThreads();
37498 result = (wxBatteryState)wxGetBatteryState();
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 resultobj = SWIG_From_int(static_cast< int >(result));
37503 return resultobj;
37504 fail:
37505 return NULL;
37506 }
37507
37508
37509 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37510 PyObject *resultobj = 0;
37511 wxAboutDialogInfo *result = 0 ;
37512
37513 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37514 {
37515 PyThreadState* __tstate = wxPyBeginAllowThreads();
37516 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37528 PyObject *resultobj = 0;
37529 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37530 void *argp1 = 0 ;
37531 int res1 = 0 ;
37532 PyObject *swig_obj[1] ;
37533
37534 if (!args) SWIG_fail;
37535 swig_obj[0] = args;
37536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37537 if (!SWIG_IsOK(res1)) {
37538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37539 }
37540 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 delete arg1;
37544
37545 wxPyEndAllowThreads(__tstate);
37546 if (PyErr_Occurred()) SWIG_fail;
37547 }
37548 resultobj = SWIG_Py_Void();
37549 return resultobj;
37550 fail:
37551 return NULL;
37552 }
37553
37554
37555 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37556 PyObject *resultobj = 0;
37557 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37558 wxString *arg2 = 0 ;
37559 void *argp1 = 0 ;
37560 int res1 = 0 ;
37561 bool temp2 = false ;
37562 PyObject * obj0 = 0 ;
37563 PyObject * obj1 = 0 ;
37564 char * kwnames[] = {
37565 (char *) "self",(char *) "name", NULL
37566 };
37567
37568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37570 if (!SWIG_IsOK(res1)) {
37571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37572 }
37573 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37574 {
37575 arg2 = wxString_in_helper(obj1);
37576 if (arg2 == NULL) SWIG_fail;
37577 temp2 = true;
37578 }
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 (arg1)->SetName((wxString const &)*arg2);
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 resultobj = SWIG_Py_Void();
37586 {
37587 if (temp2)
37588 delete arg2;
37589 }
37590 return resultobj;
37591 fail:
37592 {
37593 if (temp2)
37594 delete arg2;
37595 }
37596 return NULL;
37597 }
37598
37599
37600 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37601 PyObject *resultobj = 0;
37602 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37603 wxString result;
37604 void *argp1 = 0 ;
37605 int res1 = 0 ;
37606 PyObject *swig_obj[1] ;
37607
37608 if (!args) SWIG_fail;
37609 swig_obj[0] = args;
37610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37611 if (!SWIG_IsOK(res1)) {
37612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37613 }
37614 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37615 {
37616 PyThreadState* __tstate = wxPyBeginAllowThreads();
37617 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 {
37622 #if wxUSE_UNICODE
37623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37624 #else
37625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37626 #endif
37627 }
37628 return resultobj;
37629 fail:
37630 return NULL;
37631 }
37632
37633
37634 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37635 PyObject *resultobj = 0;
37636 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37637 wxString *arg2 = 0 ;
37638 void *argp1 = 0 ;
37639 int res1 = 0 ;
37640 bool temp2 = false ;
37641 PyObject * obj0 = 0 ;
37642 PyObject * obj1 = 0 ;
37643 char * kwnames[] = {
37644 (char *) "self",(char *) "version", NULL
37645 };
37646
37647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37649 if (!SWIG_IsOK(res1)) {
37650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37651 }
37652 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37653 {
37654 arg2 = wxString_in_helper(obj1);
37655 if (arg2 == NULL) SWIG_fail;
37656 temp2 = true;
37657 }
37658 {
37659 PyThreadState* __tstate = wxPyBeginAllowThreads();
37660 (arg1)->SetVersion((wxString const &)*arg2);
37661 wxPyEndAllowThreads(__tstate);
37662 if (PyErr_Occurred()) SWIG_fail;
37663 }
37664 resultobj = SWIG_Py_Void();
37665 {
37666 if (temp2)
37667 delete arg2;
37668 }
37669 return resultobj;
37670 fail:
37671 {
37672 if (temp2)
37673 delete arg2;
37674 }
37675 return NULL;
37676 }
37677
37678
37679 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37680 PyObject *resultobj = 0;
37681 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37682 bool result;
37683 void *argp1 = 0 ;
37684 int res1 = 0 ;
37685 PyObject *swig_obj[1] ;
37686
37687 if (!args) SWIG_fail;
37688 swig_obj[0] = args;
37689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37690 if (!SWIG_IsOK(res1)) {
37691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37692 }
37693 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37694 {
37695 PyThreadState* __tstate = wxPyBeginAllowThreads();
37696 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37697 wxPyEndAllowThreads(__tstate);
37698 if (PyErr_Occurred()) SWIG_fail;
37699 }
37700 {
37701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37702 }
37703 return resultobj;
37704 fail:
37705 return NULL;
37706 }
37707
37708
37709 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37710 PyObject *resultobj = 0;
37711 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37712 wxString result;
37713 void *argp1 = 0 ;
37714 int res1 = 0 ;
37715 PyObject *swig_obj[1] ;
37716
37717 if (!args) SWIG_fail;
37718 swig_obj[0] = args;
37719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37720 if (!SWIG_IsOK(res1)) {
37721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37722 }
37723 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 {
37731 #if wxUSE_UNICODE
37732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37733 #else
37734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37735 #endif
37736 }
37737 return resultobj;
37738 fail:
37739 return NULL;
37740 }
37741
37742
37743 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37744 PyObject *resultobj = 0;
37745 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37746 wxString *arg2 = 0 ;
37747 void *argp1 = 0 ;
37748 int res1 = 0 ;
37749 bool temp2 = false ;
37750 PyObject * obj0 = 0 ;
37751 PyObject * obj1 = 0 ;
37752 char * kwnames[] = {
37753 (char *) "self",(char *) "desc", NULL
37754 };
37755
37756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37758 if (!SWIG_IsOK(res1)) {
37759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37760 }
37761 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37762 {
37763 arg2 = wxString_in_helper(obj1);
37764 if (arg2 == NULL) SWIG_fail;
37765 temp2 = true;
37766 }
37767 {
37768 PyThreadState* __tstate = wxPyBeginAllowThreads();
37769 (arg1)->SetDescription((wxString const &)*arg2);
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 resultobj = SWIG_Py_Void();
37774 {
37775 if (temp2)
37776 delete arg2;
37777 }
37778 return resultobj;
37779 fail:
37780 {
37781 if (temp2)
37782 delete arg2;
37783 }
37784 return NULL;
37785 }
37786
37787
37788 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37789 PyObject *resultobj = 0;
37790 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37791 bool result;
37792 void *argp1 = 0 ;
37793 int res1 = 0 ;
37794 PyObject *swig_obj[1] ;
37795
37796 if (!args) SWIG_fail;
37797 swig_obj[0] = args;
37798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37799 if (!SWIG_IsOK(res1)) {
37800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37801 }
37802 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37803 {
37804 PyThreadState* __tstate = wxPyBeginAllowThreads();
37805 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37806 wxPyEndAllowThreads(__tstate);
37807 if (PyErr_Occurred()) SWIG_fail;
37808 }
37809 {
37810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37811 }
37812 return resultobj;
37813 fail:
37814 return NULL;
37815 }
37816
37817
37818 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37819 PyObject *resultobj = 0;
37820 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37821 wxString result;
37822 void *argp1 = 0 ;
37823 int res1 = 0 ;
37824 PyObject *swig_obj[1] ;
37825
37826 if (!args) SWIG_fail;
37827 swig_obj[0] = args;
37828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37829 if (!SWIG_IsOK(res1)) {
37830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37831 }
37832 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37833 {
37834 PyThreadState* __tstate = wxPyBeginAllowThreads();
37835 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37836 wxPyEndAllowThreads(__tstate);
37837 if (PyErr_Occurred()) SWIG_fail;
37838 }
37839 {
37840 #if wxUSE_UNICODE
37841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37842 #else
37843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37844 #endif
37845 }
37846 return resultobj;
37847 fail:
37848 return NULL;
37849 }
37850
37851
37852 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37853 PyObject *resultobj = 0;
37854 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37855 wxString *arg2 = 0 ;
37856 void *argp1 = 0 ;
37857 int res1 = 0 ;
37858 bool temp2 = false ;
37859 PyObject * obj0 = 0 ;
37860 PyObject * obj1 = 0 ;
37861 char * kwnames[] = {
37862 (char *) "self",(char *) "copyright", NULL
37863 };
37864
37865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37867 if (!SWIG_IsOK(res1)) {
37868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37869 }
37870 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37871 {
37872 arg2 = wxString_in_helper(obj1);
37873 if (arg2 == NULL) SWIG_fail;
37874 temp2 = true;
37875 }
37876 {
37877 PyThreadState* __tstate = wxPyBeginAllowThreads();
37878 (arg1)->SetCopyright((wxString const &)*arg2);
37879 wxPyEndAllowThreads(__tstate);
37880 if (PyErr_Occurred()) SWIG_fail;
37881 }
37882 resultobj = SWIG_Py_Void();
37883 {
37884 if (temp2)
37885 delete arg2;
37886 }
37887 return resultobj;
37888 fail:
37889 {
37890 if (temp2)
37891 delete arg2;
37892 }
37893 return NULL;
37894 }
37895
37896
37897 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37898 PyObject *resultobj = 0;
37899 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37900 bool result;
37901 void *argp1 = 0 ;
37902 int res1 = 0 ;
37903 PyObject *swig_obj[1] ;
37904
37905 if (!args) SWIG_fail;
37906 swig_obj[0] = args;
37907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37908 if (!SWIG_IsOK(res1)) {
37909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37910 }
37911 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37912 {
37913 PyThreadState* __tstate = wxPyBeginAllowThreads();
37914 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37915 wxPyEndAllowThreads(__tstate);
37916 if (PyErr_Occurred()) SWIG_fail;
37917 }
37918 {
37919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37920 }
37921 return resultobj;
37922 fail:
37923 return NULL;
37924 }
37925
37926
37927 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37928 PyObject *resultobj = 0;
37929 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37930 wxString result;
37931 void *argp1 = 0 ;
37932 int res1 = 0 ;
37933 PyObject *swig_obj[1] ;
37934
37935 if (!args) SWIG_fail;
37936 swig_obj[0] = args;
37937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37938 if (!SWIG_IsOK(res1)) {
37939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37940 }
37941 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37942 {
37943 PyThreadState* __tstate = wxPyBeginAllowThreads();
37944 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 {
37949 #if wxUSE_UNICODE
37950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37951 #else
37952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37953 #endif
37954 }
37955 return resultobj;
37956 fail:
37957 return NULL;
37958 }
37959
37960
37961 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37962 PyObject *resultobj = 0;
37963 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37964 wxString *arg2 = 0 ;
37965 void *argp1 = 0 ;
37966 int res1 = 0 ;
37967 bool temp2 = false ;
37968 PyObject * obj0 = 0 ;
37969 PyObject * obj1 = 0 ;
37970 char * kwnames[] = {
37971 (char *) "self",(char *) "licence", NULL
37972 };
37973
37974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37976 if (!SWIG_IsOK(res1)) {
37977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37978 }
37979 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37980 {
37981 arg2 = wxString_in_helper(obj1);
37982 if (arg2 == NULL) SWIG_fail;
37983 temp2 = true;
37984 }
37985 {
37986 PyThreadState* __tstate = wxPyBeginAllowThreads();
37987 (arg1)->SetLicence((wxString const &)*arg2);
37988 wxPyEndAllowThreads(__tstate);
37989 if (PyErr_Occurred()) SWIG_fail;
37990 }
37991 resultobj = SWIG_Py_Void();
37992 {
37993 if (temp2)
37994 delete arg2;
37995 }
37996 return resultobj;
37997 fail:
37998 {
37999 if (temp2)
38000 delete arg2;
38001 }
38002 return NULL;
38003 }
38004
38005
38006 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38007 PyObject *resultobj = 0;
38008 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38009 wxString *arg2 = 0 ;
38010 void *argp1 = 0 ;
38011 int res1 = 0 ;
38012 bool temp2 = false ;
38013 PyObject * obj0 = 0 ;
38014 PyObject * obj1 = 0 ;
38015 char * kwnames[] = {
38016 (char *) "self",(char *) "licence", NULL
38017 };
38018
38019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38021 if (!SWIG_IsOK(res1)) {
38022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38023 }
38024 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38025 {
38026 arg2 = wxString_in_helper(obj1);
38027 if (arg2 == NULL) SWIG_fail;
38028 temp2 = true;
38029 }
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 (arg1)->SetLicense((wxString const &)*arg2);
38033 wxPyEndAllowThreads(__tstate);
38034 if (PyErr_Occurred()) SWIG_fail;
38035 }
38036 resultobj = SWIG_Py_Void();
38037 {
38038 if (temp2)
38039 delete arg2;
38040 }
38041 return resultobj;
38042 fail:
38043 {
38044 if (temp2)
38045 delete arg2;
38046 }
38047 return NULL;
38048 }
38049
38050
38051 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38052 PyObject *resultobj = 0;
38053 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38054 bool result;
38055 void *argp1 = 0 ;
38056 int res1 = 0 ;
38057 PyObject *swig_obj[1] ;
38058
38059 if (!args) SWIG_fail;
38060 swig_obj[0] = args;
38061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38062 if (!SWIG_IsOK(res1)) {
38063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38064 }
38065 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38066 {
38067 PyThreadState* __tstate = wxPyBeginAllowThreads();
38068 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38069 wxPyEndAllowThreads(__tstate);
38070 if (PyErr_Occurred()) SWIG_fail;
38071 }
38072 {
38073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38074 }
38075 return resultobj;
38076 fail:
38077 return NULL;
38078 }
38079
38080
38081 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38082 PyObject *resultobj = 0;
38083 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38084 wxString result;
38085 void *argp1 = 0 ;
38086 int res1 = 0 ;
38087 PyObject *swig_obj[1] ;
38088
38089 if (!args) SWIG_fail;
38090 swig_obj[0] = args;
38091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38092 if (!SWIG_IsOK(res1)) {
38093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38094 }
38095 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38096 {
38097 PyThreadState* __tstate = wxPyBeginAllowThreads();
38098 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38099 wxPyEndAllowThreads(__tstate);
38100 if (PyErr_Occurred()) SWIG_fail;
38101 }
38102 {
38103 #if wxUSE_UNICODE
38104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38105 #else
38106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38107 #endif
38108 }
38109 return resultobj;
38110 fail:
38111 return NULL;
38112 }
38113
38114
38115 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38116 PyObject *resultobj = 0;
38117 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38118 wxIcon *arg2 = 0 ;
38119 void *argp1 = 0 ;
38120 int res1 = 0 ;
38121 void *argp2 = 0 ;
38122 int res2 = 0 ;
38123 PyObject * obj0 = 0 ;
38124 PyObject * obj1 = 0 ;
38125 char * kwnames[] = {
38126 (char *) "self",(char *) "icon", NULL
38127 };
38128
38129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38131 if (!SWIG_IsOK(res1)) {
38132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38133 }
38134 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38136 if (!SWIG_IsOK(res2)) {
38137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38138 }
38139 if (!argp2) {
38140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38141 }
38142 arg2 = reinterpret_cast< wxIcon * >(argp2);
38143 {
38144 PyThreadState* __tstate = wxPyBeginAllowThreads();
38145 (arg1)->SetIcon((wxIcon const &)*arg2);
38146 wxPyEndAllowThreads(__tstate);
38147 if (PyErr_Occurred()) SWIG_fail;
38148 }
38149 resultobj = SWIG_Py_Void();
38150 return resultobj;
38151 fail:
38152 return NULL;
38153 }
38154
38155
38156 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38157 PyObject *resultobj = 0;
38158 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38159 bool result;
38160 void *argp1 = 0 ;
38161 int res1 = 0 ;
38162 PyObject *swig_obj[1] ;
38163
38164 if (!args) SWIG_fail;
38165 swig_obj[0] = args;
38166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38167 if (!SWIG_IsOK(res1)) {
38168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38169 }
38170 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38171 {
38172 PyThreadState* __tstate = wxPyBeginAllowThreads();
38173 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38174 wxPyEndAllowThreads(__tstate);
38175 if (PyErr_Occurred()) SWIG_fail;
38176 }
38177 {
38178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38179 }
38180 return resultobj;
38181 fail:
38182 return NULL;
38183 }
38184
38185
38186 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38187 PyObject *resultobj = 0;
38188 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38189 wxIcon result;
38190 void *argp1 = 0 ;
38191 int res1 = 0 ;
38192 PyObject *swig_obj[1] ;
38193
38194 if (!args) SWIG_fail;
38195 swig_obj[0] = args;
38196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38197 if (!SWIG_IsOK(res1)) {
38198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38199 }
38200 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38201 {
38202 PyThreadState* __tstate = wxPyBeginAllowThreads();
38203 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38204 wxPyEndAllowThreads(__tstate);
38205 if (PyErr_Occurred()) SWIG_fail;
38206 }
38207 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38208 return resultobj;
38209 fail:
38210 return NULL;
38211 }
38212
38213
38214 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38215 PyObject *resultobj = 0;
38216 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38217 wxString *arg2 = 0 ;
38218 wxString const &arg3_defvalue = wxEmptyString ;
38219 wxString *arg3 = (wxString *) &arg3_defvalue ;
38220 void *argp1 = 0 ;
38221 int res1 = 0 ;
38222 bool temp2 = false ;
38223 bool temp3 = false ;
38224 PyObject * obj0 = 0 ;
38225 PyObject * obj1 = 0 ;
38226 PyObject * obj2 = 0 ;
38227 char * kwnames[] = {
38228 (char *) "self",(char *) "url",(char *) "desc", NULL
38229 };
38230
38231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38233 if (!SWIG_IsOK(res1)) {
38234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38235 }
38236 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38237 {
38238 arg2 = wxString_in_helper(obj1);
38239 if (arg2 == NULL) SWIG_fail;
38240 temp2 = true;
38241 }
38242 if (obj2) {
38243 {
38244 arg3 = wxString_in_helper(obj2);
38245 if (arg3 == NULL) SWIG_fail;
38246 temp3 = true;
38247 }
38248 }
38249 {
38250 PyThreadState* __tstate = wxPyBeginAllowThreads();
38251 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38252 wxPyEndAllowThreads(__tstate);
38253 if (PyErr_Occurred()) SWIG_fail;
38254 }
38255 resultobj = SWIG_Py_Void();
38256 {
38257 if (temp2)
38258 delete arg2;
38259 }
38260 {
38261 if (temp3)
38262 delete arg3;
38263 }
38264 return resultobj;
38265 fail:
38266 {
38267 if (temp2)
38268 delete arg2;
38269 }
38270 {
38271 if (temp3)
38272 delete arg3;
38273 }
38274 return NULL;
38275 }
38276
38277
38278 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38279 PyObject *resultobj = 0;
38280 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38281 wxString result;
38282 void *argp1 = 0 ;
38283 int res1 = 0 ;
38284 PyObject *swig_obj[1] ;
38285
38286 if (!args) SWIG_fail;
38287 swig_obj[0] = args;
38288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38289 if (!SWIG_IsOK(res1)) {
38290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38291 }
38292 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38293 {
38294 PyThreadState* __tstate = wxPyBeginAllowThreads();
38295 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38296 wxPyEndAllowThreads(__tstate);
38297 if (PyErr_Occurred()) SWIG_fail;
38298 }
38299 {
38300 #if wxUSE_UNICODE
38301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38302 #else
38303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38304 #endif
38305 }
38306 return resultobj;
38307 fail:
38308 return NULL;
38309 }
38310
38311
38312 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38313 PyObject *resultobj = 0;
38314 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38315 wxString result;
38316 void *argp1 = 0 ;
38317 int res1 = 0 ;
38318 PyObject *swig_obj[1] ;
38319
38320 if (!args) SWIG_fail;
38321 swig_obj[0] = args;
38322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38323 if (!SWIG_IsOK(res1)) {
38324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38325 }
38326 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38327 {
38328 PyThreadState* __tstate = wxPyBeginAllowThreads();
38329 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38330 wxPyEndAllowThreads(__tstate);
38331 if (PyErr_Occurred()) SWIG_fail;
38332 }
38333 {
38334 #if wxUSE_UNICODE
38335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38336 #else
38337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38338 #endif
38339 }
38340 return resultobj;
38341 fail:
38342 return NULL;
38343 }
38344
38345
38346 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38347 PyObject *resultobj = 0;
38348 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38349 bool result;
38350 void *argp1 = 0 ;
38351 int res1 = 0 ;
38352 PyObject *swig_obj[1] ;
38353
38354 if (!args) SWIG_fail;
38355 swig_obj[0] = args;
38356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38357 if (!SWIG_IsOK(res1)) {
38358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38359 }
38360 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38361 {
38362 PyThreadState* __tstate = wxPyBeginAllowThreads();
38363 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38364 wxPyEndAllowThreads(__tstate);
38365 if (PyErr_Occurred()) SWIG_fail;
38366 }
38367 {
38368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38369 }
38370 return resultobj;
38371 fail:
38372 return NULL;
38373 }
38374
38375
38376 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38377 PyObject *resultobj = 0;
38378 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38379 wxArrayString *arg2 = 0 ;
38380 void *argp1 = 0 ;
38381 int res1 = 0 ;
38382 bool temp2 = false ;
38383 PyObject * obj0 = 0 ;
38384 PyObject * obj1 = 0 ;
38385 char * kwnames[] = {
38386 (char *) "self",(char *) "developers", NULL
38387 };
38388
38389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38391 if (!SWIG_IsOK(res1)) {
38392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38393 }
38394 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38395 {
38396 if (! PySequence_Check(obj1)) {
38397 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38398 SWIG_fail;
38399 }
38400 arg2 = new wxArrayString;
38401 temp2 = true;
38402 int i, len=PySequence_Length(obj1);
38403 for (i=0; i<len; i++) {
38404 PyObject* item = PySequence_GetItem(obj1, i);
38405 wxString* s = wxString_in_helper(item);
38406 if (PyErr_Occurred()) SWIG_fail;
38407 arg2->Add(*s);
38408 delete s;
38409 Py_DECREF(item);
38410 }
38411 }
38412 {
38413 PyThreadState* __tstate = wxPyBeginAllowThreads();
38414 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38415 wxPyEndAllowThreads(__tstate);
38416 if (PyErr_Occurred()) SWIG_fail;
38417 }
38418 resultobj = SWIG_Py_Void();
38419 {
38420 if (temp2) delete arg2;
38421 }
38422 return resultobj;
38423 fail:
38424 {
38425 if (temp2) delete arg2;
38426 }
38427 return NULL;
38428 }
38429
38430
38431 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38432 PyObject *resultobj = 0;
38433 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38434 wxString *arg2 = 0 ;
38435 void *argp1 = 0 ;
38436 int res1 = 0 ;
38437 bool temp2 = false ;
38438 PyObject * obj0 = 0 ;
38439 PyObject * obj1 = 0 ;
38440 char * kwnames[] = {
38441 (char *) "self",(char *) "developer", NULL
38442 };
38443
38444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38446 if (!SWIG_IsOK(res1)) {
38447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38448 }
38449 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38450 {
38451 arg2 = wxString_in_helper(obj1);
38452 if (arg2 == NULL) SWIG_fail;
38453 temp2 = true;
38454 }
38455 {
38456 PyThreadState* __tstate = wxPyBeginAllowThreads();
38457 (arg1)->AddDeveloper((wxString const &)*arg2);
38458 wxPyEndAllowThreads(__tstate);
38459 if (PyErr_Occurred()) SWIG_fail;
38460 }
38461 resultobj = SWIG_Py_Void();
38462 {
38463 if (temp2)
38464 delete arg2;
38465 }
38466 return resultobj;
38467 fail:
38468 {
38469 if (temp2)
38470 delete arg2;
38471 }
38472 return NULL;
38473 }
38474
38475
38476 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38477 PyObject *resultobj = 0;
38478 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38479 bool result;
38480 void *argp1 = 0 ;
38481 int res1 = 0 ;
38482 PyObject *swig_obj[1] ;
38483
38484 if (!args) SWIG_fail;
38485 swig_obj[0] = args;
38486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38487 if (!SWIG_IsOK(res1)) {
38488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38489 }
38490 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38491 {
38492 PyThreadState* __tstate = wxPyBeginAllowThreads();
38493 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38494 wxPyEndAllowThreads(__tstate);
38495 if (PyErr_Occurred()) SWIG_fail;
38496 }
38497 {
38498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38499 }
38500 return resultobj;
38501 fail:
38502 return NULL;
38503 }
38504
38505
38506 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38507 PyObject *resultobj = 0;
38508 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38509 wxArrayString *result = 0 ;
38510 void *argp1 = 0 ;
38511 int res1 = 0 ;
38512 PyObject *swig_obj[1] ;
38513
38514 if (!args) SWIG_fail;
38515 swig_obj[0] = args;
38516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38517 if (!SWIG_IsOK(res1)) {
38518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38519 }
38520 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38521 {
38522 PyThreadState* __tstate = wxPyBeginAllowThreads();
38523 {
38524 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38525 result = (wxArrayString *) &_result_ref;
38526 }
38527 wxPyEndAllowThreads(__tstate);
38528 if (PyErr_Occurred()) SWIG_fail;
38529 }
38530 {
38531 resultobj = wxArrayString2PyList_helper(*result);
38532 }
38533 return resultobj;
38534 fail:
38535 return NULL;
38536 }
38537
38538
38539 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38540 PyObject *resultobj = 0;
38541 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38542 wxArrayString *arg2 = 0 ;
38543 void *argp1 = 0 ;
38544 int res1 = 0 ;
38545 bool temp2 = false ;
38546 PyObject * obj0 = 0 ;
38547 PyObject * obj1 = 0 ;
38548 char * kwnames[] = {
38549 (char *) "self",(char *) "docwriters", NULL
38550 };
38551
38552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38554 if (!SWIG_IsOK(res1)) {
38555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38556 }
38557 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38558 {
38559 if (! PySequence_Check(obj1)) {
38560 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38561 SWIG_fail;
38562 }
38563 arg2 = new wxArrayString;
38564 temp2 = true;
38565 int i, len=PySequence_Length(obj1);
38566 for (i=0; i<len; i++) {
38567 PyObject* item = PySequence_GetItem(obj1, i);
38568 wxString* s = wxString_in_helper(item);
38569 if (PyErr_Occurred()) SWIG_fail;
38570 arg2->Add(*s);
38571 delete s;
38572 Py_DECREF(item);
38573 }
38574 }
38575 {
38576 PyThreadState* __tstate = wxPyBeginAllowThreads();
38577 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38578 wxPyEndAllowThreads(__tstate);
38579 if (PyErr_Occurred()) SWIG_fail;
38580 }
38581 resultobj = SWIG_Py_Void();
38582 {
38583 if (temp2) delete arg2;
38584 }
38585 return resultobj;
38586 fail:
38587 {
38588 if (temp2) delete arg2;
38589 }
38590 return NULL;
38591 }
38592
38593
38594 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38595 PyObject *resultobj = 0;
38596 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38597 wxString *arg2 = 0 ;
38598 void *argp1 = 0 ;
38599 int res1 = 0 ;
38600 bool temp2 = false ;
38601 PyObject * obj0 = 0 ;
38602 PyObject * obj1 = 0 ;
38603 char * kwnames[] = {
38604 (char *) "self",(char *) "docwriter", NULL
38605 };
38606
38607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38609 if (!SWIG_IsOK(res1)) {
38610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38611 }
38612 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38613 {
38614 arg2 = wxString_in_helper(obj1);
38615 if (arg2 == NULL) SWIG_fail;
38616 temp2 = true;
38617 }
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 (arg1)->AddDocWriter((wxString const &)*arg2);
38621 wxPyEndAllowThreads(__tstate);
38622 if (PyErr_Occurred()) SWIG_fail;
38623 }
38624 resultobj = SWIG_Py_Void();
38625 {
38626 if (temp2)
38627 delete arg2;
38628 }
38629 return resultobj;
38630 fail:
38631 {
38632 if (temp2)
38633 delete arg2;
38634 }
38635 return NULL;
38636 }
38637
38638
38639 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38640 PyObject *resultobj = 0;
38641 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38642 bool result;
38643 void *argp1 = 0 ;
38644 int res1 = 0 ;
38645 PyObject *swig_obj[1] ;
38646
38647 if (!args) SWIG_fail;
38648 swig_obj[0] = args;
38649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38650 if (!SWIG_IsOK(res1)) {
38651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38652 }
38653 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38654 {
38655 PyThreadState* __tstate = wxPyBeginAllowThreads();
38656 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38657 wxPyEndAllowThreads(__tstate);
38658 if (PyErr_Occurred()) SWIG_fail;
38659 }
38660 {
38661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38662 }
38663 return resultobj;
38664 fail:
38665 return NULL;
38666 }
38667
38668
38669 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38670 PyObject *resultobj = 0;
38671 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38672 wxArrayString *result = 0 ;
38673 void *argp1 = 0 ;
38674 int res1 = 0 ;
38675 PyObject *swig_obj[1] ;
38676
38677 if (!args) SWIG_fail;
38678 swig_obj[0] = args;
38679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38680 if (!SWIG_IsOK(res1)) {
38681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38682 }
38683 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38684 {
38685 PyThreadState* __tstate = wxPyBeginAllowThreads();
38686 {
38687 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38688 result = (wxArrayString *) &_result_ref;
38689 }
38690 wxPyEndAllowThreads(__tstate);
38691 if (PyErr_Occurred()) SWIG_fail;
38692 }
38693 {
38694 resultobj = wxArrayString2PyList_helper(*result);
38695 }
38696 return resultobj;
38697 fail:
38698 return NULL;
38699 }
38700
38701
38702 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38703 PyObject *resultobj = 0;
38704 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38705 wxArrayString *arg2 = 0 ;
38706 void *argp1 = 0 ;
38707 int res1 = 0 ;
38708 bool temp2 = false ;
38709 PyObject * obj0 = 0 ;
38710 PyObject * obj1 = 0 ;
38711 char * kwnames[] = {
38712 (char *) "self",(char *) "artists", NULL
38713 };
38714
38715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38717 if (!SWIG_IsOK(res1)) {
38718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38719 }
38720 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38721 {
38722 if (! PySequence_Check(obj1)) {
38723 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38724 SWIG_fail;
38725 }
38726 arg2 = new wxArrayString;
38727 temp2 = true;
38728 int i, len=PySequence_Length(obj1);
38729 for (i=0; i<len; i++) {
38730 PyObject* item = PySequence_GetItem(obj1, i);
38731 wxString* s = wxString_in_helper(item);
38732 if (PyErr_Occurred()) SWIG_fail;
38733 arg2->Add(*s);
38734 delete s;
38735 Py_DECREF(item);
38736 }
38737 }
38738 {
38739 PyThreadState* __tstate = wxPyBeginAllowThreads();
38740 (arg1)->SetArtists((wxArrayString const &)*arg2);
38741 wxPyEndAllowThreads(__tstate);
38742 if (PyErr_Occurred()) SWIG_fail;
38743 }
38744 resultobj = SWIG_Py_Void();
38745 {
38746 if (temp2) delete arg2;
38747 }
38748 return resultobj;
38749 fail:
38750 {
38751 if (temp2) delete arg2;
38752 }
38753 return NULL;
38754 }
38755
38756
38757 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38758 PyObject *resultobj = 0;
38759 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38760 wxString *arg2 = 0 ;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 bool temp2 = false ;
38764 PyObject * obj0 = 0 ;
38765 PyObject * obj1 = 0 ;
38766 char * kwnames[] = {
38767 (char *) "self",(char *) "artist", NULL
38768 };
38769
38770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38772 if (!SWIG_IsOK(res1)) {
38773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38774 }
38775 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38776 {
38777 arg2 = wxString_in_helper(obj1);
38778 if (arg2 == NULL) SWIG_fail;
38779 temp2 = true;
38780 }
38781 {
38782 PyThreadState* __tstate = wxPyBeginAllowThreads();
38783 (arg1)->AddArtist((wxString const &)*arg2);
38784 wxPyEndAllowThreads(__tstate);
38785 if (PyErr_Occurred()) SWIG_fail;
38786 }
38787 resultobj = SWIG_Py_Void();
38788 {
38789 if (temp2)
38790 delete arg2;
38791 }
38792 return resultobj;
38793 fail:
38794 {
38795 if (temp2)
38796 delete arg2;
38797 }
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38803 PyObject *resultobj = 0;
38804 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38805 bool result;
38806 void *argp1 = 0 ;
38807 int res1 = 0 ;
38808 PyObject *swig_obj[1] ;
38809
38810 if (!args) SWIG_fail;
38811 swig_obj[0] = args;
38812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38813 if (!SWIG_IsOK(res1)) {
38814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38815 }
38816 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38817 {
38818 PyThreadState* __tstate = wxPyBeginAllowThreads();
38819 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38820 wxPyEndAllowThreads(__tstate);
38821 if (PyErr_Occurred()) SWIG_fail;
38822 }
38823 {
38824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38825 }
38826 return resultobj;
38827 fail:
38828 return NULL;
38829 }
38830
38831
38832 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38833 PyObject *resultobj = 0;
38834 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38835 wxArrayString *result = 0 ;
38836 void *argp1 = 0 ;
38837 int res1 = 0 ;
38838 PyObject *swig_obj[1] ;
38839
38840 if (!args) SWIG_fail;
38841 swig_obj[0] = args;
38842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38843 if (!SWIG_IsOK(res1)) {
38844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38845 }
38846 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38847 {
38848 PyThreadState* __tstate = wxPyBeginAllowThreads();
38849 {
38850 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38851 result = (wxArrayString *) &_result_ref;
38852 }
38853 wxPyEndAllowThreads(__tstate);
38854 if (PyErr_Occurred()) SWIG_fail;
38855 }
38856 {
38857 resultobj = wxArrayString2PyList_helper(*result);
38858 }
38859 return resultobj;
38860 fail:
38861 return NULL;
38862 }
38863
38864
38865 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38866 PyObject *resultobj = 0;
38867 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38868 wxArrayString *arg2 = 0 ;
38869 void *argp1 = 0 ;
38870 int res1 = 0 ;
38871 bool temp2 = false ;
38872 PyObject * obj0 = 0 ;
38873 PyObject * obj1 = 0 ;
38874 char * kwnames[] = {
38875 (char *) "self",(char *) "translators", NULL
38876 };
38877
38878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38880 if (!SWIG_IsOK(res1)) {
38881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38882 }
38883 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38884 {
38885 if (! PySequence_Check(obj1)) {
38886 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38887 SWIG_fail;
38888 }
38889 arg2 = new wxArrayString;
38890 temp2 = true;
38891 int i, len=PySequence_Length(obj1);
38892 for (i=0; i<len; i++) {
38893 PyObject* item = PySequence_GetItem(obj1, i);
38894 wxString* s = wxString_in_helper(item);
38895 if (PyErr_Occurred()) SWIG_fail;
38896 arg2->Add(*s);
38897 delete s;
38898 Py_DECREF(item);
38899 }
38900 }
38901 {
38902 PyThreadState* __tstate = wxPyBeginAllowThreads();
38903 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38904 wxPyEndAllowThreads(__tstate);
38905 if (PyErr_Occurred()) SWIG_fail;
38906 }
38907 resultobj = SWIG_Py_Void();
38908 {
38909 if (temp2) delete arg2;
38910 }
38911 return resultobj;
38912 fail:
38913 {
38914 if (temp2) delete arg2;
38915 }
38916 return NULL;
38917 }
38918
38919
38920 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38921 PyObject *resultobj = 0;
38922 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38923 wxString *arg2 = 0 ;
38924 void *argp1 = 0 ;
38925 int res1 = 0 ;
38926 bool temp2 = false ;
38927 PyObject * obj0 = 0 ;
38928 PyObject * obj1 = 0 ;
38929 char * kwnames[] = {
38930 (char *) "self",(char *) "translator", NULL
38931 };
38932
38933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38935 if (!SWIG_IsOK(res1)) {
38936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38937 }
38938 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38939 {
38940 arg2 = wxString_in_helper(obj1);
38941 if (arg2 == NULL) SWIG_fail;
38942 temp2 = true;
38943 }
38944 {
38945 PyThreadState* __tstate = wxPyBeginAllowThreads();
38946 (arg1)->AddTranslator((wxString const &)*arg2);
38947 wxPyEndAllowThreads(__tstate);
38948 if (PyErr_Occurred()) SWIG_fail;
38949 }
38950 resultobj = SWIG_Py_Void();
38951 {
38952 if (temp2)
38953 delete arg2;
38954 }
38955 return resultobj;
38956 fail:
38957 {
38958 if (temp2)
38959 delete arg2;
38960 }
38961 return NULL;
38962 }
38963
38964
38965 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38966 PyObject *resultobj = 0;
38967 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38968 bool result;
38969 void *argp1 = 0 ;
38970 int res1 = 0 ;
38971 PyObject *swig_obj[1] ;
38972
38973 if (!args) SWIG_fail;
38974 swig_obj[0] = args;
38975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38976 if (!SWIG_IsOK(res1)) {
38977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38978 }
38979 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38980 {
38981 PyThreadState* __tstate = wxPyBeginAllowThreads();
38982 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38983 wxPyEndAllowThreads(__tstate);
38984 if (PyErr_Occurred()) SWIG_fail;
38985 }
38986 {
38987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38988 }
38989 return resultobj;
38990 fail:
38991 return NULL;
38992 }
38993
38994
38995 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38996 PyObject *resultobj = 0;
38997 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38998 wxArrayString *result = 0 ;
38999 void *argp1 = 0 ;
39000 int res1 = 0 ;
39001 PyObject *swig_obj[1] ;
39002
39003 if (!args) SWIG_fail;
39004 swig_obj[0] = args;
39005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39006 if (!SWIG_IsOK(res1)) {
39007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39008 }
39009 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39010 {
39011 PyThreadState* __tstate = wxPyBeginAllowThreads();
39012 {
39013 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39014 result = (wxArrayString *) &_result_ref;
39015 }
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 {
39020 resultobj = wxArrayString2PyList_helper(*result);
39021 }
39022 return resultobj;
39023 fail:
39024 return NULL;
39025 }
39026
39027
39028 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39029 PyObject *resultobj = 0;
39030 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39031 bool result;
39032 void *argp1 = 0 ;
39033 int res1 = 0 ;
39034 PyObject *swig_obj[1] ;
39035
39036 if (!args) SWIG_fail;
39037 swig_obj[0] = args;
39038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39039 if (!SWIG_IsOK(res1)) {
39040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39041 }
39042 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39043 {
39044 PyThreadState* __tstate = wxPyBeginAllowThreads();
39045 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39046 wxPyEndAllowThreads(__tstate);
39047 if (PyErr_Occurred()) SWIG_fail;
39048 }
39049 {
39050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39051 }
39052 return resultobj;
39053 fail:
39054 return NULL;
39055 }
39056
39057
39058 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39059 PyObject *resultobj = 0;
39060 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39061 wxString result;
39062 void *argp1 = 0 ;
39063 int res1 = 0 ;
39064 PyObject *swig_obj[1] ;
39065
39066 if (!args) SWIG_fail;
39067 swig_obj[0] = args;
39068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39069 if (!SWIG_IsOK(res1)) {
39070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39071 }
39072 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39073 {
39074 PyThreadState* __tstate = wxPyBeginAllowThreads();
39075 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39076 wxPyEndAllowThreads(__tstate);
39077 if (PyErr_Occurred()) SWIG_fail;
39078 }
39079 {
39080 #if wxUSE_UNICODE
39081 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39082 #else
39083 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39084 #endif
39085 }
39086 return resultobj;
39087 fail:
39088 return NULL;
39089 }
39090
39091
39092 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39093 PyObject *obj;
39094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39095 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39096 return SWIG_Py_Void();
39097 }
39098
39099 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39100 return SWIG_Python_InitShadowInstance(args);
39101 }
39102
39103 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39104 PyObject *resultobj = 0;
39105 wxAboutDialogInfo *arg1 = 0 ;
39106 void *argp1 = 0 ;
39107 int res1 = 0 ;
39108 PyObject * obj0 = 0 ;
39109 char * kwnames[] = {
39110 (char *) "info", NULL
39111 };
39112
39113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39114 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39115 if (!SWIG_IsOK(res1)) {
39116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39117 }
39118 if (!argp1) {
39119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39120 }
39121 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39122 {
39123 PyThreadState* __tstate = wxPyBeginAllowThreads();
39124 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39125 wxPyEndAllowThreads(__tstate);
39126 if (PyErr_Occurred()) SWIG_fail;
39127 }
39128 resultobj = SWIG_Py_Void();
39129 return resultobj;
39130 fail:
39131 return NULL;
39132 }
39133
39134
39135 static PyMethodDef SwigMethods[] = {
39136 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39137 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39138 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39139 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39140 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39141 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39142 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39143 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39144 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39145 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39146 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39147 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39148 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39149 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39151 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39152 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39153 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39154 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39155 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39156 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39157 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39158 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39159 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39160 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39161 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39162 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39163 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39164 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39165 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39166 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39167 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39168 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39169 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39170 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39171 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39172 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39173 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39174 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39175 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39176 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39178 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39179 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39180 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39181 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39182 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39183 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39184 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39185 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39186 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39187 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39188 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39189 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39196 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39197 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39198 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39199 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39200 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39201 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39202 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39203 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39204 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39205 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39206 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39207 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39208 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39209 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39210 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39211 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39215 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39216 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39217 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39218 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39219 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39220 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39221 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39222 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39223 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39224 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39225 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39226 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39227 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39228 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39236 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39238 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39239 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39240 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39241 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39242 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39243 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39244 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39245 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39246 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39247 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39248 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39250 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39251 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39252 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39253 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39256 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39257 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39258 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39259 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39260 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39261 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39262 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39263 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39264 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39265 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39266 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39267 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39268 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39271 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39273 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39274 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39276 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39277 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39278 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39279 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39280 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39281 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39282 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39283 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39284 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39285 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39287 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39288 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39289 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39290 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39291 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39292 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39293 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39294 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39295 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39296 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39297 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39298 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39299 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39302 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39305 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39306 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39307 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39310 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39311 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39312 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39313 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39314 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39315 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39317 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39318 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39319 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39320 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39323 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39324 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39326 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39327 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39328 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39329 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39330 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39331 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39332 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39333 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39334 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39335 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39336 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39337 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39338 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39339 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39340 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39341 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39342 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39346 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39347 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39348 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39349 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39350 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39351 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39352 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39354 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39355 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39357 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39358 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39362 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39363 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39365 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39367 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39368 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39369 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39370 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39371 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39372 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39373 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39374 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39375 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39376 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39377 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39378 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39379 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39380 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39382 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39383 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39384 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39385 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39386 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39387 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39388 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39389 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39390 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39391 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39393 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39394 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39395 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39396 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39397 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39398 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39399 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39403 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39404 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39406 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39407 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39409 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39410 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39411 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39412 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39413 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39414 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39415 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39416 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39417 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39418 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39419 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39420 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39421 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39422 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39423 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39426 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39427 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39428 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39429 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39430 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39431 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39432 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39433 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39434 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39435 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39436 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39437 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39438 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39439 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39440 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39441 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39442 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39443 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39446 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39447 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39450 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39456 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39457 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39458 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39459 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39460 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39461 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39462 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39464 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39465 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39467 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39468 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39469 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39470 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39472 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39473 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39474 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39475 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39476 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39477 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39478 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39479 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39480 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39481 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39482 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39483 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39484 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39485 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39487 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39488 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39489 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39490 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39491 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39492 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39493 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39494 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39495 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39498 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39499 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39500 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39501 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39502 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39503 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39504 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39505 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39506 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39507 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39509 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39510 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39511 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39512 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39513 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39514 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39515 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39516 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39517 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39518 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39519 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39520 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39521 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39522 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39523 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39524 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39525 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39526 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39527 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39528 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39529 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39530 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39531 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39532 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39533 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39534 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39535 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39536 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39537 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39538 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39539 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39540 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39541 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39542 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39543 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39544 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39545 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39546 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39547 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39548 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39551 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39552 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39553 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39554 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39555 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39556 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39559 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39560 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39561 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39562 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39563 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39564 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39565 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39566 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39567 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39570 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39571 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39572 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39575 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39576 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39577 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39578 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39579 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39580 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39581 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39582 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39583 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39584 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39585 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39586 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39587 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39588 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39589 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39590 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39591 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39592 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39593 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39594 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39595 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39596 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39597 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39598 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39599 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39600 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39601 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39603 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39605 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39606 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39608 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39610 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39615 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39619 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39620 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39621 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39622 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39623 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39625 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39627 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39628 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39632 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39633 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39634 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39635 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39636 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39638 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39639 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39641 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39642 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39643 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39644 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39645 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39665 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39667 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39669 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39671 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39672 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39676 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39677 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39679 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39680 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39681 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39683 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39684 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39685 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39687 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39688 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39689 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39690 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39693 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39704 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39708 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39709 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39710 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39711 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39717 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39718 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39723 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39747 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39748 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39749 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39750 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39751 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39763 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39764 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39790 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39791 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39792 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39793 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39806 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39807 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39808 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39809 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39810 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39811 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39813 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39815 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39817 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39819 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39821 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39823 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39825 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39829 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39830 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39834 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39845 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39846 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39847 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39851 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39852 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39853 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39854 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39855 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39856 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39858 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39859 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39861 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39863 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39865 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39867 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39869 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39874 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39875 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39876 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39877 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39878 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39881 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39885 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39893 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39894 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39895 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39896 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39897 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39898 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39901 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39902 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39903 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39905 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39906 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39908 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39909 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39910 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39912 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39913 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39915 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39917 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39918 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39919 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39920 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39921 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39922 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39923 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39925 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39926 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39929 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39930 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39931 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39933 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39934 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39935 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39937 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39938 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39940 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39941 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39944 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39945 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39947 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39948 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39949 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39950 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39953 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39954 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39955 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39956 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39957 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39958 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39959 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39960 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39962 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39963 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39964 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39965 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39967 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39969 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39970 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39971 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39972 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39973 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39975 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39976 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39977 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39978 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39979 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39980 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39983 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39984 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39987 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39988 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
39992 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
39994 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
39995 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
39996 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
39997 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
39998 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
39999 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40003 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40004 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40005 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40007 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40008 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40009 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40010 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40012 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40014 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40016 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40017 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40018 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40019 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40020 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40021 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40022 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40023 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40024 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40027 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40028 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40029 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40031 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40032 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40033 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40034 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40035 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40036 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40037 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40038 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40039 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40040 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40042 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40043 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40044 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40045 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40048 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40049 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40050 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40051 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40052 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40053 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40054 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40055 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40056 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40057 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40059 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40060 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40061 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40062 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40063 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40064 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40065 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40066 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40067 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40069 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40070 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40071 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40072 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40073 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40074 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40075 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40076 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40077 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40078 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40079 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40080 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40081 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40082 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40083 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40084 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40085 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40086 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40088 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40089 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40091 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40092 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40093 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40094 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40095 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40096 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40097 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40098 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40099 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40100 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40101 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40102 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40103 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40105 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40106 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40107 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40108 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40109 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40110 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40111 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40112 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40113 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40114 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40115 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40116 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40117 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40118 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40119 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40120 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40121 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40122 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40123 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40124 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40125 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40126 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40127 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40128 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40129 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40130 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40131 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40132 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40133 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40134 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40135 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40136 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40137 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40138 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40139 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40140 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40141 { NULL, NULL, 0, NULL }
40142 };
40143
40144
40145 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40146
40147 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40148 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40149 }
40150 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40151 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40152 }
40153 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40154 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40155 }
40156 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40157 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40158 }
40159 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40160 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40161 }
40162 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40163 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40164 }
40165 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40166 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40167 }
40168 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40169 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40170 }
40171 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40172 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40173 }
40174 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40175 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40176 }
40177 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40178 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40179 }
40180 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40181 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40182 }
40183 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40184 return (void *)((wxEvent *) ((wxPyEvent *) x));
40185 }
40186 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40187 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40188 }
40189 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40190 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40191 }
40192 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40193 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40194 }
40195 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40196 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40197 }
40198 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40199 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40200 }
40201 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40202 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40203 }
40204 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40205 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40206 }
40207 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40208 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40209 }
40210 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40211 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40212 }
40213 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40214 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40215 }
40216 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40217 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40218 }
40219 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40220 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40221 }
40222 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40223 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40224 }
40225 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40226 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40227 }
40228 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40229 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40230 }
40231 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40232 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40233 }
40234 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40235 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40236 }
40237 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40238 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40239 }
40240 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40241 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40242 }
40243 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40244 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40245 }
40246 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40247 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40248 }
40249 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40250 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40251 }
40252 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40253 return (void *)((wxEvent *) ((wxShowEvent *) x));
40254 }
40255 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40256 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40257 }
40258 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40259 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40260 }
40261 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40262 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40263 }
40264 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40265 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40266 }
40267 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40268 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40269 }
40270 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40271 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40272 }
40273 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40274 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40275 }
40276 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40277 return (void *)((wxConfigBase *) ((wxConfig *) x));
40278 }
40279 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40280 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40281 }
40282 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40283 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40284 }
40285 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40286 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40287 }
40288 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40289 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40290 }
40291 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40292 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40293 }
40294 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40295 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40296 }
40297 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40298 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40299 }
40300 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40301 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40302 }
40303 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40304 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40305 }
40306 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40307 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40308 }
40309 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40310 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40311 }
40312 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40313 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40314 }
40315 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40316 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40317 }
40318 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40319 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40320 }
40321 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40322 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40323 }
40324 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40325 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40326 }
40327 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40328 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40329 }
40330 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40331 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40332 }
40333 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40334 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40335 }
40336 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40337 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40338 }
40339 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40340 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40341 }
40342 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40343 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40344 }
40345 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40346 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40347 }
40348 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40349 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40350 }
40351 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40352 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40353 }
40354 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40355 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40356 }
40357 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40358 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40359 }
40360 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40361 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40362 }
40363 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40364 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40365 }
40366 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40367 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40368 }
40369 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40370 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40371 }
40372 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40373 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40374 }
40375 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40376 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40377 }
40378 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40379 return (void *)((wxObject *) ((wxSizerItem *) x));
40380 }
40381 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40382 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40383 }
40384 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40385 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40386 }
40387 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40388 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40389 }
40390 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40391 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40392 }
40393 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40394 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40395 }
40396 static void *_p_wxSizerTo_p_wxObject(void *x) {
40397 return (void *)((wxObject *) ((wxSizer *) x));
40398 }
40399 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40400 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40401 }
40402 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40403 return (void *)((wxObject *) ((wxFileHistory *) x));
40404 }
40405 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40406 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40407 }
40408 static void *_p_wxEventTo_p_wxObject(void *x) {
40409 return (void *)((wxObject *) ((wxEvent *) x));
40410 }
40411 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40412 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40413 }
40414 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40415 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40416 }
40417 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40418 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40419 }
40420 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40421 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40422 }
40423 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40424 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40425 }
40426 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40427 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40428 }
40429 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40430 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40431 }
40432 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40433 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40434 }
40435 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40436 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40437 }
40438 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40439 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40440 }
40441 static void *_p_wxControlTo_p_wxObject(void *x) {
40442 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40443 }
40444 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40445 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40446 }
40447 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40448 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40449 }
40450 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40451 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40452 }
40453 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40454 return (void *)((wxObject *) ((wxFSFile *) x));
40455 }
40456 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40457 return (void *)((wxObject *) ((wxClipboard *) x));
40458 }
40459 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40460 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40461 }
40462 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40463 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40464 }
40465 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40466 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40467 }
40468 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40469 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40470 }
40471 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40472 return (void *)((wxObject *) ((wxToolTip *) x));
40473 }
40474 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40475 return (void *)((wxObject *) ((wxMenuItem *) x));
40476 }
40477 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40478 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40479 }
40480 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40481 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40482 }
40483 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40485 }
40486 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40487 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40488 }
40489 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40490 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40491 }
40492 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40493 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40494 }
40495 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40496 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40497 }
40498 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40499 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40500 }
40501 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40502 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40503 }
40504 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40505 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40506 }
40507 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40508 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40509 }
40510 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40511 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40512 }
40513 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40514 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40515 }
40516 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40517 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40518 }
40519 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40520 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40521 }
40522 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40523 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40524 }
40525 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40526 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40527 }
40528 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40529 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40530 }
40531 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40532 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40533 }
40534 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40535 return (void *)((wxObject *) ((wxImageHandler *) x));
40536 }
40537 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40538 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40539 }
40540 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40541 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40542 }
40543 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40544 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40545 }
40546 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40547 return (void *)((wxObject *) ((wxEvtHandler *) x));
40548 }
40549 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40550 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40551 }
40552 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40553 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40554 }
40555 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40556 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40557 }
40558 static void *_p_wxImageTo_p_wxObject(void *x) {
40559 return (void *)((wxObject *) ((wxImage *) x));
40560 }
40561 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40562 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40563 }
40564 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40565 return (void *)((wxObject *) ((wxSystemOptions *) x));
40566 }
40567 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40568 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40569 }
40570 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40571 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40572 }
40573 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40574 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40575 }
40576 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40577 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40578 }
40579 static void *_p_wxWindowTo_p_wxObject(void *x) {
40580 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40581 }
40582 static void *_p_wxMenuTo_p_wxObject(void *x) {
40583 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40584 }
40585 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40586 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40587 }
40588 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40589 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40590 }
40591 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40592 return (void *)((wxObject *) ((wxFileSystem *) x));
40593 }
40594 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40595 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40596 }
40597 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40598 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40599 }
40600 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40601 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40602 }
40603 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40604 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40605 }
40606 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40607 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40608 }
40609 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40610 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40611 }
40612 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40613 return (void *)((wxObject *) ((wxBusyInfo *) x));
40614 }
40615 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40616 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40617 }
40618 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40619 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40620 }
40621 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40622 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40623 }
40624 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40625 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40626 }
40627 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40628 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40629 }
40630 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40631 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40632 }
40633 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40634 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40635 }
40636 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40637 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40638 }
40639 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40640 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40641 }
40642 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40643 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40644 }
40645 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40646 return (void *)((wxLog *) ((wxLogBuffer *) x));
40647 }
40648 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40649 return (void *)((wxLog *) ((wxLogStderr *) x));
40650 }
40651 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40652 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40653 }
40654 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40655 return (void *)((wxLog *) ((wxLogWindow *) x));
40656 }
40657 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40658 return (void *)((wxLog *) ((wxLogChain *) x));
40659 }
40660 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40661 return (void *)((wxLog *) ((wxLogGui *) x));
40662 }
40663 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40664 return (void *)((wxLog *) ((wxPyLog *) x));
40665 }
40666 static void *_p_wxControlTo_p_wxWindow(void *x) {
40667 return (void *)((wxWindow *) ((wxControl *) x));
40668 }
40669 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40670 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40671 }
40672 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40673 return (void *)((wxWindow *) ((wxMenuBar *) x));
40674 }
40675 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40676 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40677 }
40678 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40679 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40680 }
40681 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40682 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};
40683 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40684 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40685 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40686 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40687 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40688 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40689 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40690 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40691 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40692 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40693 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40694 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40695 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40696 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40697 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40698 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40699 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40700 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40701 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40702 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40703 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40704 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40705 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40706 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40707 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40708 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40709 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40710 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40711 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40712 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40713 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40714 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40715 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40716 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40717 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40718 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40719 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40720 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40721 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40722 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40723 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40724 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40725 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40726 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40727 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40728 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40729 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40730 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40731 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40732 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40733 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40734 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40735 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40736 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40737 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40738 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40739 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40740 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40741 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40742 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40743 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40754 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40761 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40762 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40763 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40764 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40765 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40766 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40767 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40768 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40769 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40770 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40771 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40772 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40773 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40779 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40786 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40787 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40788 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40789 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40790 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40791 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40792 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40793 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40794 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40795 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40796 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40797 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40798 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40799 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40800 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40801 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40802 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40803 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40804 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40805 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40806 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40809 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40810 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40811 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40812 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40813 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40814 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40818 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40819 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40820 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40821 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40822 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40823 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40824 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40825 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40826 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40827 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40828 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40829 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40830 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40831 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40832 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40833 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40834 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40835 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40836 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40837 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40838 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40839 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40840 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40841 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40842 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40843 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40850 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40851 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40852 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40853 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40854 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40855
40856 static swig_type_info *swig_type_initial[] = {
40857 &_swigt__p_char,
40858 &_swigt__p_form_ops_t,
40859 &_swigt__p_int,
40860 &_swigt__p_unsigned_char,
40861 &_swigt__p_unsigned_int,
40862 &_swigt__p_unsigned_long,
40863 &_swigt__p_void,
40864 &_swigt__p_wxANIHandler,
40865 &_swigt__p_wxAboutDialogInfo,
40866 &_swigt__p_wxAcceleratorTable,
40867 &_swigt__p_wxActivateEvent,
40868 &_swigt__p_wxArrayString,
40869 &_swigt__p_wxBMPHandler,
40870 &_swigt__p_wxBitmap,
40871 &_swigt__p_wxBitmapDataObject,
40872 &_swigt__p_wxBoxSizer,
40873 &_swigt__p_wxBusyCursor,
40874 &_swigt__p_wxBusyInfo,
40875 &_swigt__p_wxCURHandler,
40876 &_swigt__p_wxCaret,
40877 &_swigt__p_wxChar,
40878 &_swigt__p_wxChildFocusEvent,
40879 &_swigt__p_wxClipboard,
40880 &_swigt__p_wxClipboardLocker,
40881 &_swigt__p_wxClipboardTextEvent,
40882 &_swigt__p_wxCloseEvent,
40883 &_swigt__p_wxColour,
40884 &_swigt__p_wxCommandEvent,
40885 &_swigt__p_wxConfig,
40886 &_swigt__p_wxConfigBase,
40887 &_swigt__p_wxConfigPathChanger,
40888 &_swigt__p_wxContextMenuEvent,
40889 &_swigt__p_wxControl,
40890 &_swigt__p_wxControlWithItems,
40891 &_swigt__p_wxCursor,
40892 &_swigt__p_wxCustomDataObject,
40893 &_swigt__p_wxDC,
40894 &_swigt__p_wxDataFormat,
40895 &_swigt__p_wxDataObject,
40896 &_swigt__p_wxDataObjectComposite,
40897 &_swigt__p_wxDataObjectSimple,
40898 &_swigt__p_wxDateEvent,
40899 &_swigt__p_wxDateSpan,
40900 &_swigt__p_wxDateTime,
40901 &_swigt__p_wxDateTime__TimeZone,
40902 &_swigt__p_wxDisplay,
40903 &_swigt__p_wxDisplayChangedEvent,
40904 &_swigt__p_wxDropFilesEvent,
40905 &_swigt__p_wxDuplexMode,
40906 &_swigt__p_wxEraseEvent,
40907 &_swigt__p_wxEvent,
40908 &_swigt__p_wxEvtHandler,
40909 &_swigt__p_wxFSFile,
40910 &_swigt__p_wxFileConfig,
40911 &_swigt__p_wxFileDataObject,
40912 &_swigt__p_wxFileHistory,
40913 &_swigt__p_wxFileSystem,
40914 &_swigt__p_wxFileType,
40915 &_swigt__p_wxFileTypeInfo,
40916 &_swigt__p_wxFlexGridSizer,
40917 &_swigt__p_wxFocusEvent,
40918 &_swigt__p_wxFont,
40919 &_swigt__p_wxFrame,
40920 &_swigt__p_wxGBSizerItem,
40921 &_swigt__p_wxGIFHandler,
40922 &_swigt__p_wxGridBagSizer,
40923 &_swigt__p_wxGridSizer,
40924 &_swigt__p_wxICOHandler,
40925 &_swigt__p_wxIcon,
40926 &_swigt__p_wxIconizeEvent,
40927 &_swigt__p_wxIdleEvent,
40928 &_swigt__p_wxImage,
40929 &_swigt__p_wxImageHandler,
40930 &_swigt__p_wxIndividualLayoutConstraint,
40931 &_swigt__p_wxInitDialogEvent,
40932 &_swigt__p_wxJPEGHandler,
40933 &_swigt__p_wxJoystick,
40934 &_swigt__p_wxJoystickEvent,
40935 &_swigt__p_wxKeyEvent,
40936 &_swigt__p_wxKillError,
40937 &_swigt__p_wxLayoutConstraints,
40938 &_swigt__p_wxLog,
40939 &_swigt__p_wxLogBuffer,
40940 &_swigt__p_wxLogChain,
40941 &_swigt__p_wxLogGui,
40942 &_swigt__p_wxLogNull,
40943 &_swigt__p_wxLogStderr,
40944 &_swigt__p_wxLogTextCtrl,
40945 &_swigt__p_wxLogWindow,
40946 &_swigt__p_wxMaximizeEvent,
40947 &_swigt__p_wxMenu,
40948 &_swigt__p_wxMenuBar,
40949 &_swigt__p_wxMenuEvent,
40950 &_swigt__p_wxMenuItem,
40951 &_swigt__p_wxMetafileDataObject,
40952 &_swigt__p_wxMimeTypesManager,
40953 &_swigt__p_wxMouseCaptureChangedEvent,
40954 &_swigt__p_wxMouseCaptureLostEvent,
40955 &_swigt__p_wxMouseEvent,
40956 &_swigt__p_wxMouseState,
40957 &_swigt__p_wxMoveEvent,
40958 &_swigt__p_wxMutexGuiLocker,
40959 &_swigt__p_wxNavigationKeyEvent,
40960 &_swigt__p_wxNcPaintEvent,
40961 &_swigt__p_wxNotifyEvent,
40962 &_swigt__p_wxObject,
40963 &_swigt__p_wxOutputStream,
40964 &_swigt__p_wxPCXHandler,
40965 &_swigt__p_wxPNGHandler,
40966 &_swigt__p_wxPNMHandler,
40967 &_swigt__p_wxPaintEvent,
40968 &_swigt__p_wxPaletteChangedEvent,
40969 &_swigt__p_wxPaperSize,
40970 &_swigt__p_wxPlatformInfo,
40971 &_swigt__p_wxPoint,
40972 &_swigt__p_wxPowerEvent,
40973 &_swigt__p_wxProcessEvent,
40974 &_swigt__p_wxPyApp,
40975 &_swigt__p_wxPyArtProvider,
40976 &_swigt__p_wxPyBitmapDataObject,
40977 &_swigt__p_wxPyCommandEvent,
40978 &_swigt__p_wxPyDataObjectSimple,
40979 &_swigt__p_wxPyDropSource,
40980 &_swigt__p_wxPyDropTarget,
40981 &_swigt__p_wxPyEvent,
40982 &_swigt__p_wxPyFileDropTarget,
40983 &_swigt__p_wxPyImageHandler,
40984 &_swigt__p_wxPyLog,
40985 &_swigt__p_wxPyProcess,
40986 &_swigt__p_wxPySizer,
40987 &_swigt__p_wxPyTextDataObject,
40988 &_swigt__p_wxPyTextDropTarget,
40989 &_swigt__p_wxPyTimer,
40990 &_swigt__p_wxPyTipProvider,
40991 &_swigt__p_wxPyValidator,
40992 &_swigt__p_wxQueryNewPaletteEvent,
40993 &_swigt__p_wxRect,
40994 &_swigt__p_wxScrollEvent,
40995 &_swigt__p_wxScrollWinEvent,
40996 &_swigt__p_wxSetCursorEvent,
40997 &_swigt__p_wxShowEvent,
40998 &_swigt__p_wxSingleInstanceChecker,
40999 &_swigt__p_wxSize,
41000 &_swigt__p_wxSizeEvent,
41001 &_swigt__p_wxSizer,
41002 &_swigt__p_wxSizerItem,
41003 &_swigt__p_wxSound,
41004 &_swigt__p_wxStandardPaths,
41005 &_swigt__p_wxStaticBoxSizer,
41006 &_swigt__p_wxStdDialogButtonSizer,
41007 &_swigt__p_wxStopWatch,
41008 &_swigt__p_wxString,
41009 &_swigt__p_wxSysColourChangedEvent,
41010 &_swigt__p_wxSystemOptions,
41011 &_swigt__p_wxSystemSettings,
41012 &_swigt__p_wxTGAHandler,
41013 &_swigt__p_wxTIFFHandler,
41014 &_swigt__p_wxTextCtrl,
41015 &_swigt__p_wxTextDataObject,
41016 &_swigt__p_wxTimeSpan,
41017 &_swigt__p_wxTimer,
41018 &_swigt__p_wxTimerEvent,
41019 &_swigt__p_wxTimerRunner,
41020 &_swigt__p_wxTipProvider,
41021 &_swigt__p_wxToolTip,
41022 &_swigt__p_wxURLDataObject,
41023 &_swigt__p_wxUpdateUIEvent,
41024 &_swigt__p_wxValidator,
41025 &_swigt__p_wxVideoMode,
41026 &_swigt__p_wxWindow,
41027 &_swigt__p_wxWindowCreateEvent,
41028 &_swigt__p_wxWindowDestroyEvent,
41029 &_swigt__p_wxWindowDisabler,
41030 &_swigt__p_wxXPMHandler,
41031 };
41032
41033 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41034 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41035 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41036 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41037 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41038 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41039 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41040 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41041 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41042 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41043 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}};
41044 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41045 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41046 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41047 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41048 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41052 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}};
41053 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41054 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41055 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41058 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}};
41059 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41060 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}};
41061 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41073 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41104 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}};
41105 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41111 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}};
41112 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41123 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}};
41124 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41178 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}};
41179 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41196 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}};
41197 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41201 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}};
41202 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41205 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}};
41206 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41207
41208 static swig_cast_info *swig_cast_initial[] = {
41209 _swigc__p_char,
41210 _swigc__p_form_ops_t,
41211 _swigc__p_int,
41212 _swigc__p_unsigned_char,
41213 _swigc__p_unsigned_int,
41214 _swigc__p_unsigned_long,
41215 _swigc__p_void,
41216 _swigc__p_wxANIHandler,
41217 _swigc__p_wxAboutDialogInfo,
41218 _swigc__p_wxAcceleratorTable,
41219 _swigc__p_wxActivateEvent,
41220 _swigc__p_wxArrayString,
41221 _swigc__p_wxBMPHandler,
41222 _swigc__p_wxBitmap,
41223 _swigc__p_wxBitmapDataObject,
41224 _swigc__p_wxBoxSizer,
41225 _swigc__p_wxBusyCursor,
41226 _swigc__p_wxBusyInfo,
41227 _swigc__p_wxCURHandler,
41228 _swigc__p_wxCaret,
41229 _swigc__p_wxChar,
41230 _swigc__p_wxChildFocusEvent,
41231 _swigc__p_wxClipboard,
41232 _swigc__p_wxClipboardLocker,
41233 _swigc__p_wxClipboardTextEvent,
41234 _swigc__p_wxCloseEvent,
41235 _swigc__p_wxColour,
41236 _swigc__p_wxCommandEvent,
41237 _swigc__p_wxConfig,
41238 _swigc__p_wxConfigBase,
41239 _swigc__p_wxConfigPathChanger,
41240 _swigc__p_wxContextMenuEvent,
41241 _swigc__p_wxControl,
41242 _swigc__p_wxControlWithItems,
41243 _swigc__p_wxCursor,
41244 _swigc__p_wxCustomDataObject,
41245 _swigc__p_wxDC,
41246 _swigc__p_wxDataFormat,
41247 _swigc__p_wxDataObject,
41248 _swigc__p_wxDataObjectComposite,
41249 _swigc__p_wxDataObjectSimple,
41250 _swigc__p_wxDateEvent,
41251 _swigc__p_wxDateSpan,
41252 _swigc__p_wxDateTime,
41253 _swigc__p_wxDateTime__TimeZone,
41254 _swigc__p_wxDisplay,
41255 _swigc__p_wxDisplayChangedEvent,
41256 _swigc__p_wxDropFilesEvent,
41257 _swigc__p_wxDuplexMode,
41258 _swigc__p_wxEraseEvent,
41259 _swigc__p_wxEvent,
41260 _swigc__p_wxEvtHandler,
41261 _swigc__p_wxFSFile,
41262 _swigc__p_wxFileConfig,
41263 _swigc__p_wxFileDataObject,
41264 _swigc__p_wxFileHistory,
41265 _swigc__p_wxFileSystem,
41266 _swigc__p_wxFileType,
41267 _swigc__p_wxFileTypeInfo,
41268 _swigc__p_wxFlexGridSizer,
41269 _swigc__p_wxFocusEvent,
41270 _swigc__p_wxFont,
41271 _swigc__p_wxFrame,
41272 _swigc__p_wxGBSizerItem,
41273 _swigc__p_wxGIFHandler,
41274 _swigc__p_wxGridBagSizer,
41275 _swigc__p_wxGridSizer,
41276 _swigc__p_wxICOHandler,
41277 _swigc__p_wxIcon,
41278 _swigc__p_wxIconizeEvent,
41279 _swigc__p_wxIdleEvent,
41280 _swigc__p_wxImage,
41281 _swigc__p_wxImageHandler,
41282 _swigc__p_wxIndividualLayoutConstraint,
41283 _swigc__p_wxInitDialogEvent,
41284 _swigc__p_wxJPEGHandler,
41285 _swigc__p_wxJoystick,
41286 _swigc__p_wxJoystickEvent,
41287 _swigc__p_wxKeyEvent,
41288 _swigc__p_wxKillError,
41289 _swigc__p_wxLayoutConstraints,
41290 _swigc__p_wxLog,
41291 _swigc__p_wxLogBuffer,
41292 _swigc__p_wxLogChain,
41293 _swigc__p_wxLogGui,
41294 _swigc__p_wxLogNull,
41295 _swigc__p_wxLogStderr,
41296 _swigc__p_wxLogTextCtrl,
41297 _swigc__p_wxLogWindow,
41298 _swigc__p_wxMaximizeEvent,
41299 _swigc__p_wxMenu,
41300 _swigc__p_wxMenuBar,
41301 _swigc__p_wxMenuEvent,
41302 _swigc__p_wxMenuItem,
41303 _swigc__p_wxMetafileDataObject,
41304 _swigc__p_wxMimeTypesManager,
41305 _swigc__p_wxMouseCaptureChangedEvent,
41306 _swigc__p_wxMouseCaptureLostEvent,
41307 _swigc__p_wxMouseEvent,
41308 _swigc__p_wxMouseState,
41309 _swigc__p_wxMoveEvent,
41310 _swigc__p_wxMutexGuiLocker,
41311 _swigc__p_wxNavigationKeyEvent,
41312 _swigc__p_wxNcPaintEvent,
41313 _swigc__p_wxNotifyEvent,
41314 _swigc__p_wxObject,
41315 _swigc__p_wxOutputStream,
41316 _swigc__p_wxPCXHandler,
41317 _swigc__p_wxPNGHandler,
41318 _swigc__p_wxPNMHandler,
41319 _swigc__p_wxPaintEvent,
41320 _swigc__p_wxPaletteChangedEvent,
41321 _swigc__p_wxPaperSize,
41322 _swigc__p_wxPlatformInfo,
41323 _swigc__p_wxPoint,
41324 _swigc__p_wxPowerEvent,
41325 _swigc__p_wxProcessEvent,
41326 _swigc__p_wxPyApp,
41327 _swigc__p_wxPyArtProvider,
41328 _swigc__p_wxPyBitmapDataObject,
41329 _swigc__p_wxPyCommandEvent,
41330 _swigc__p_wxPyDataObjectSimple,
41331 _swigc__p_wxPyDropSource,
41332 _swigc__p_wxPyDropTarget,
41333 _swigc__p_wxPyEvent,
41334 _swigc__p_wxPyFileDropTarget,
41335 _swigc__p_wxPyImageHandler,
41336 _swigc__p_wxPyLog,
41337 _swigc__p_wxPyProcess,
41338 _swigc__p_wxPySizer,
41339 _swigc__p_wxPyTextDataObject,
41340 _swigc__p_wxPyTextDropTarget,
41341 _swigc__p_wxPyTimer,
41342 _swigc__p_wxPyTipProvider,
41343 _swigc__p_wxPyValidator,
41344 _swigc__p_wxQueryNewPaletteEvent,
41345 _swigc__p_wxRect,
41346 _swigc__p_wxScrollEvent,
41347 _swigc__p_wxScrollWinEvent,
41348 _swigc__p_wxSetCursorEvent,
41349 _swigc__p_wxShowEvent,
41350 _swigc__p_wxSingleInstanceChecker,
41351 _swigc__p_wxSize,
41352 _swigc__p_wxSizeEvent,
41353 _swigc__p_wxSizer,
41354 _swigc__p_wxSizerItem,
41355 _swigc__p_wxSound,
41356 _swigc__p_wxStandardPaths,
41357 _swigc__p_wxStaticBoxSizer,
41358 _swigc__p_wxStdDialogButtonSizer,
41359 _swigc__p_wxStopWatch,
41360 _swigc__p_wxString,
41361 _swigc__p_wxSysColourChangedEvent,
41362 _swigc__p_wxSystemOptions,
41363 _swigc__p_wxSystemSettings,
41364 _swigc__p_wxTGAHandler,
41365 _swigc__p_wxTIFFHandler,
41366 _swigc__p_wxTextCtrl,
41367 _swigc__p_wxTextDataObject,
41368 _swigc__p_wxTimeSpan,
41369 _swigc__p_wxTimer,
41370 _swigc__p_wxTimerEvent,
41371 _swigc__p_wxTimerRunner,
41372 _swigc__p_wxTipProvider,
41373 _swigc__p_wxToolTip,
41374 _swigc__p_wxURLDataObject,
41375 _swigc__p_wxUpdateUIEvent,
41376 _swigc__p_wxValidator,
41377 _swigc__p_wxVideoMode,
41378 _swigc__p_wxWindow,
41379 _swigc__p_wxWindowCreateEvent,
41380 _swigc__p_wxWindowDestroyEvent,
41381 _swigc__p_wxWindowDisabler,
41382 _swigc__p_wxXPMHandler,
41383 };
41384
41385
41386 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41387
41388 static swig_const_info swig_const_table[] = {
41389 {0, 0, 0, 0.0, 0, 0}};
41390
41391 #ifdef __cplusplus
41392 }
41393 #endif
41394 /* -----------------------------------------------------------------------------
41395 * Type initialization:
41396 * This problem is tough by the requirement that no dynamic
41397 * memory is used. Also, since swig_type_info structures store pointers to
41398 * swig_cast_info structures and swig_cast_info structures store pointers back
41399 * to swig_type_info structures, we need some lookup code at initialization.
41400 * The idea is that swig generates all the structures that are needed.
41401 * The runtime then collects these partially filled structures.
41402 * The SWIG_InitializeModule function takes these initial arrays out of
41403 * swig_module, and does all the lookup, filling in the swig_module.types
41404 * array with the correct data and linking the correct swig_cast_info
41405 * structures together.
41406 *
41407 * The generated swig_type_info structures are assigned staticly to an initial
41408 * array. We just loop though that array, and handle each type individually.
41409 * First we lookup if this type has been already loaded, and if so, use the
41410 * loaded structure instead of the generated one. Then we have to fill in the
41411 * cast linked list. The cast data is initially stored in something like a
41412 * two-dimensional array. Each row corresponds to a type (there are the same
41413 * number of rows as there are in the swig_type_initial array). Each entry in
41414 * a column is one of the swig_cast_info structures for that type.
41415 * The cast_initial array is actually an array of arrays, because each row has
41416 * a variable number of columns. So to actually build the cast linked list,
41417 * we find the array of casts associated with the type, and loop through it
41418 * adding the casts to the list. The one last trick we need to do is making
41419 * sure the type pointer in the swig_cast_info struct is correct.
41420 *
41421 * First off, we lookup the cast->type name to see if it is already loaded.
41422 * There are three cases to handle:
41423 * 1) If the cast->type has already been loaded AND the type we are adding
41424 * casting info to has not been loaded (it is in this module), THEN we
41425 * replace the cast->type pointer with the type pointer that has already
41426 * been loaded.
41427 * 2) If BOTH types (the one we are adding casting info to, and the
41428 * cast->type) are loaded, THEN the cast info has already been loaded by
41429 * the previous module so we just ignore it.
41430 * 3) Finally, if cast->type has not already been loaded, then we add that
41431 * swig_cast_info to the linked list (because the cast->type) pointer will
41432 * be correct.
41433 * ----------------------------------------------------------------------------- */
41434
41435 #ifdef __cplusplus
41436 extern "C" {
41437 #if 0
41438 } /* c-mode */
41439 #endif
41440 #endif
41441
41442 #if 0
41443 #define SWIGRUNTIME_DEBUG
41444 #endif
41445
41446 SWIGRUNTIME void
41447 SWIG_InitializeModule(void *clientdata) {
41448 size_t i;
41449 swig_module_info *module_head;
41450 static int init_run = 0;
41451
41452 clientdata = clientdata;
41453
41454 if (init_run) return;
41455 init_run = 1;
41456
41457 /* Initialize the swig_module */
41458 swig_module.type_initial = swig_type_initial;
41459 swig_module.cast_initial = swig_cast_initial;
41460
41461 /* Try and load any already created modules */
41462 module_head = SWIG_GetModule(clientdata);
41463 if (module_head) {
41464 swig_module.next = module_head->next;
41465 module_head->next = &swig_module;
41466 } else {
41467 /* This is the first module loaded */
41468 swig_module.next = &swig_module;
41469 SWIG_SetModule(clientdata, &swig_module);
41470 }
41471
41472 /* Now work on filling in swig_module.types */
41473 #ifdef SWIGRUNTIME_DEBUG
41474 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41475 #endif
41476 for (i = 0; i < swig_module.size; ++i) {
41477 swig_type_info *type = 0;
41478 swig_type_info *ret;
41479 swig_cast_info *cast;
41480
41481 #ifdef SWIGRUNTIME_DEBUG
41482 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41483 #endif
41484
41485 /* if there is another module already loaded */
41486 if (swig_module.next != &swig_module) {
41487 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41488 }
41489 if (type) {
41490 /* Overwrite clientdata field */
41491 #ifdef SWIGRUNTIME_DEBUG
41492 printf("SWIG_InitializeModule: found type %s\n", type->name);
41493 #endif
41494 if (swig_module.type_initial[i]->clientdata) {
41495 type->clientdata = swig_module.type_initial[i]->clientdata;
41496 #ifdef SWIGRUNTIME_DEBUG
41497 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41498 #endif
41499 }
41500 } else {
41501 type = swig_module.type_initial[i];
41502 }
41503
41504 /* Insert casting types */
41505 cast = swig_module.cast_initial[i];
41506 while (cast->type) {
41507 /* Don't need to add information already in the list */
41508 ret = 0;
41509 #ifdef SWIGRUNTIME_DEBUG
41510 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41511 #endif
41512 if (swig_module.next != &swig_module) {
41513 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41514 #ifdef SWIGRUNTIME_DEBUG
41515 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41516 #endif
41517 }
41518 if (ret) {
41519 if (type == swig_module.type_initial[i]) {
41520 #ifdef SWIGRUNTIME_DEBUG
41521 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41522 #endif
41523 cast->type = ret;
41524 ret = 0;
41525 } else {
41526 /* Check for casting already in the list */
41527 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41528 #ifdef SWIGRUNTIME_DEBUG
41529 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41530 #endif
41531 if (!ocast) ret = 0;
41532 }
41533 }
41534
41535 if (!ret) {
41536 #ifdef SWIGRUNTIME_DEBUG
41537 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41538 #endif
41539 if (type->cast) {
41540 type->cast->prev = cast;
41541 cast->next = type->cast;
41542 }
41543 type->cast = cast;
41544 }
41545 cast++;
41546 }
41547 /* Set entry in modules->types array equal to the type */
41548 swig_module.types[i] = type;
41549 }
41550 swig_module.types[i] = 0;
41551
41552 #ifdef SWIGRUNTIME_DEBUG
41553 printf("**** SWIG_InitializeModule: Cast List ******\n");
41554 for (i = 0; i < swig_module.size; ++i) {
41555 int j = 0;
41556 swig_cast_info *cast = swig_module.cast_initial[i];
41557 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41558 while (cast->type) {
41559 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41560 cast++;
41561 ++j;
41562 }
41563 printf("---- Total casts: %d\n",j);
41564 }
41565 printf("**** SWIG_InitializeModule: Cast List ******\n");
41566 #endif
41567 }
41568
41569 /* This function will propagate the clientdata field of type to
41570 * any new swig_type_info structures that have been added into the list
41571 * of equivalent types. It is like calling
41572 * SWIG_TypeClientData(type, clientdata) a second time.
41573 */
41574 SWIGRUNTIME void
41575 SWIG_PropagateClientData(void) {
41576 size_t i;
41577 swig_cast_info *equiv;
41578 static int init_run = 0;
41579
41580 if (init_run) return;
41581 init_run = 1;
41582
41583 for (i = 0; i < swig_module.size; i++) {
41584 if (swig_module.types[i]->clientdata) {
41585 equiv = swig_module.types[i]->cast;
41586 while (equiv) {
41587 if (!equiv->converter) {
41588 if (equiv->type && !equiv->type->clientdata)
41589 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41590 }
41591 equiv = equiv->next;
41592 }
41593 }
41594 }
41595 }
41596
41597 #ifdef __cplusplus
41598 #if 0
41599 {
41600 /* c-mode */
41601 #endif
41602 }
41603 #endif
41604
41605
41606
41607 #ifdef __cplusplus
41608 extern "C" {
41609 #endif
41610
41611 /* Python-specific SWIG API */
41612 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41613 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41614 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41615
41616 /* -----------------------------------------------------------------------------
41617 * global variable support code.
41618 * ----------------------------------------------------------------------------- */
41619
41620 typedef struct swig_globalvar {
41621 char *name; /* Name of global variable */
41622 PyObject *(*get_attr)(void); /* Return the current value */
41623 int (*set_attr)(PyObject *); /* Set the value */
41624 struct swig_globalvar *next;
41625 } swig_globalvar;
41626
41627 typedef struct swig_varlinkobject {
41628 PyObject_HEAD
41629 swig_globalvar *vars;
41630 } swig_varlinkobject;
41631
41632 SWIGINTERN PyObject *
41633 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41634 return PyString_FromString("<Swig global variables>");
41635 }
41636
41637 SWIGINTERN PyObject *
41638 swig_varlink_str(swig_varlinkobject *v) {
41639 PyObject *str = PyString_FromString("(");
41640 swig_globalvar *var;
41641 for (var = v->vars; var; var=var->next) {
41642 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41643 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41644 }
41645 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41646 return str;
41647 }
41648
41649 SWIGINTERN int
41650 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41651 PyObject *str = swig_varlink_str(v);
41652 fprintf(fp,"Swig global variables ");
41653 fprintf(fp,"%s\n", PyString_AsString(str));
41654 Py_DECREF(str);
41655 return 0;
41656 }
41657
41658 SWIGINTERN void
41659 swig_varlink_dealloc(swig_varlinkobject *v) {
41660 swig_globalvar *var = v->vars;
41661 while (var) {
41662 swig_globalvar *n = var->next;
41663 free(var->name);
41664 free(var);
41665 var = n;
41666 }
41667 }
41668
41669 SWIGINTERN PyObject *
41670 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41671 PyObject *res = NULL;
41672 swig_globalvar *var = v->vars;
41673 while (var) {
41674 if (strcmp(var->name,n) == 0) {
41675 res = (*var->get_attr)();
41676 break;
41677 }
41678 var = var->next;
41679 }
41680 if (res == NULL && !PyErr_Occurred()) {
41681 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41682 }
41683 return res;
41684 }
41685
41686 SWIGINTERN int
41687 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41688 int res = 1;
41689 swig_globalvar *var = v->vars;
41690 while (var) {
41691 if (strcmp(var->name,n) == 0) {
41692 res = (*var->set_attr)(p);
41693 break;
41694 }
41695 var = var->next;
41696 }
41697 if (res == 1 && !PyErr_Occurred()) {
41698 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41699 }
41700 return res;
41701 }
41702
41703 SWIGINTERN PyTypeObject*
41704 swig_varlink_type(void) {
41705 static char varlink__doc__[] = "Swig var link object";
41706 static PyTypeObject varlink_type;
41707 static int type_init = 0;
41708 if (!type_init) {
41709 const PyTypeObject tmp
41710 = {
41711 PyObject_HEAD_INIT(NULL)
41712 0, /* Number of items in variable part (ob_size) */
41713 (char *)"swigvarlink", /* Type name (tp_name) */
41714 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41715 0, /* Itemsize (tp_itemsize) */
41716 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41717 (printfunc) swig_varlink_print, /* Print (tp_print) */
41718 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41719 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41720 0, /* tp_compare */
41721 (reprfunc) swig_varlink_repr, /* tp_repr */
41722 0, /* tp_as_number */
41723 0, /* tp_as_sequence */
41724 0, /* tp_as_mapping */
41725 0, /* tp_hash */
41726 0, /* tp_call */
41727 (reprfunc)swig_varlink_str, /* tp_str */
41728 0, /* tp_getattro */
41729 0, /* tp_setattro */
41730 0, /* tp_as_buffer */
41731 0, /* tp_flags */
41732 varlink__doc__, /* tp_doc */
41733 0, /* tp_traverse */
41734 0, /* tp_clear */
41735 0, /* tp_richcompare */
41736 0, /* tp_weaklistoffset */
41737 #if PY_VERSION_HEX >= 0x02020000
41738 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41739 #endif
41740 #if PY_VERSION_HEX >= 0x02030000
41741 0, /* tp_del */
41742 #endif
41743 #ifdef COUNT_ALLOCS
41744 0,0,0,0 /* tp_alloc -> tp_next */
41745 #endif
41746 };
41747 varlink_type = tmp;
41748 varlink_type.ob_type = &PyType_Type;
41749 type_init = 1;
41750 }
41751 return &varlink_type;
41752 }
41753
41754 /* Create a variable linking object for use later */
41755 SWIGINTERN PyObject *
41756 SWIG_Python_newvarlink(void) {
41757 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41758 if (result) {
41759 result->vars = 0;
41760 }
41761 return ((PyObject*) result);
41762 }
41763
41764 SWIGINTERN void
41765 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41766 swig_varlinkobject *v = (swig_varlinkobject *) p;
41767 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41768 if (gv) {
41769 size_t size = strlen(name)+1;
41770 gv->name = (char *)malloc(size);
41771 if (gv->name) {
41772 strncpy(gv->name,name,size);
41773 gv->get_attr = get_attr;
41774 gv->set_attr = set_attr;
41775 gv->next = v->vars;
41776 }
41777 }
41778 v->vars = gv;
41779 }
41780
41781 SWIGINTERN PyObject *
41782 SWIG_globals() {
41783 static PyObject *_SWIG_globals = 0;
41784 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41785 return _SWIG_globals;
41786 }
41787
41788 /* -----------------------------------------------------------------------------
41789 * constants/methods manipulation
41790 * ----------------------------------------------------------------------------- */
41791
41792 /* Install Constants */
41793 SWIGINTERN void
41794 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41795 PyObject *obj = 0;
41796 size_t i;
41797 for (i = 0; constants[i].type; ++i) {
41798 switch(constants[i].type) {
41799 case SWIG_PY_POINTER:
41800 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41801 break;
41802 case SWIG_PY_BINARY:
41803 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41804 break;
41805 default:
41806 obj = 0;
41807 break;
41808 }
41809 if (obj) {
41810 PyDict_SetItemString(d, constants[i].name, obj);
41811 Py_DECREF(obj);
41812 }
41813 }
41814 }
41815
41816 /* -----------------------------------------------------------------------------*/
41817 /* Fix SwigMethods to carry the callback ptrs when needed */
41818 /* -----------------------------------------------------------------------------*/
41819
41820 SWIGINTERN void
41821 SWIG_Python_FixMethods(PyMethodDef *methods,
41822 swig_const_info *const_table,
41823 swig_type_info **types,
41824 swig_type_info **types_initial) {
41825 size_t i;
41826 for (i = 0; methods[i].ml_name; ++i) {
41827 const char *c = methods[i].ml_doc;
41828 if (c && (c = strstr(c, "swig_ptr: "))) {
41829 int j;
41830 swig_const_info *ci = 0;
41831 const char *name = c + 10;
41832 for (j = 0; const_table[j].type; ++j) {
41833 if (strncmp(const_table[j].name, name,
41834 strlen(const_table[j].name)) == 0) {
41835 ci = &(const_table[j]);
41836 break;
41837 }
41838 }
41839 if (ci) {
41840 size_t shift = (ci->ptype) - types;
41841 swig_type_info *ty = types_initial[shift];
41842 size_t ldoc = (c - methods[i].ml_doc);
41843 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41844 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41845 if (ndoc) {
41846 char *buff = ndoc;
41847 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41848 if (ptr) {
41849 strncpy(buff, methods[i].ml_doc, ldoc);
41850 buff += ldoc;
41851 strncpy(buff, "swig_ptr: ", 10);
41852 buff += 10;
41853 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41854 methods[i].ml_doc = ndoc;
41855 }
41856 }
41857 }
41858 }
41859 }
41860 }
41861
41862 #ifdef __cplusplus
41863 }
41864 #endif
41865
41866 /* -----------------------------------------------------------------------------*
41867 * Partial Init method
41868 * -----------------------------------------------------------------------------*/
41869
41870 #ifdef __cplusplus
41871 extern "C"
41872 #endif
41873 SWIGEXPORT void SWIG_init(void) {
41874 PyObject *m, *d;
41875
41876 /* Fix SwigMethods to carry the callback ptrs when needed */
41877 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41878
41879 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41880 d = PyModule_GetDict(m);
41881
41882 SWIG_InitializeModule(0);
41883 SWIG_InstallConstants(d,swig_const_table);
41884
41885
41886 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41887 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41888 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41889 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41890 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41891 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41892 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41893 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41894 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41895 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41896 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41897 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41898 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41899 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41900 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41901 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41902 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41903 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41904 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41905 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41906 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41907 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41908 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41909 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41910 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41911 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41912 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41913 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41914 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41915 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41916 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41917 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41918 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41919 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41920 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41921 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41922 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41923 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41924 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41925 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41926 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41927 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41928 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41929 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41930 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41931 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41932 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41933 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41934 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41935 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41936 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41937 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41938 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41939 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41940 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41941 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41942 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41943 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41944 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41945 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41946 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41947 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41948 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41949 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41950 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41951 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41952 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41953 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41954 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41955 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41956 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41957 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41958 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41959 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41960 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41961 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41962 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41963 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41964 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41965 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41966 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41967 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41968 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41969 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41970 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41971 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41972 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41973 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41974 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41975 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41976 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41977 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41978 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41979 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41980 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41981 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41982 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41983 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41984 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41985 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41986 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41987 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41988 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
41989 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
41990 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
41991 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
41992 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
41993 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
41994 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
41995 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
41996 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
41997 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
41998 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
41999 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42000 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42001 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42002 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42003 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42004 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42005 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42006 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42007 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42008 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42009 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42010 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42011 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42012 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42013 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42014 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42015 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42016 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42017 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42018 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42019 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42020 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42021 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42022 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42023 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42024 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42025 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42026 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42027 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42028 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42029 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42030 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42031 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42032 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42033 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42034
42035 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42036
42037 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42038 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42039 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42040 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42041 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42042 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42043 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42044 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42045 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42046 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42047 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42048 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42049 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42050 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42051 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42052 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42053 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42054 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42055 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42056 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42057 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42058 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42059 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42060 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42061 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42062 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42063 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42064 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42065 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42066 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42067 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42068 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42069 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42070 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42071 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42072 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42073 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42074 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42075 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42076 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42077 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42078 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42079 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42080 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42081 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42082 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42083 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42084 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42085 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42086 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42087 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42088 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42089 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42090
42091 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42092
42093 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42094 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42095 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42096 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42097 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42098 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42099 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42100 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42101 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42102 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42103 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42104 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42105 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42106 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42107 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42108 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42109 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42110 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42111 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42112 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42113 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42114 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42115 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42117 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42118 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42119 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42120 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42121 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42122 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42125 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42126 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42127 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42128 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42129 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42130 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42131 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42132 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42133 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42134 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42135 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42169
42170 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42171
42172 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42173 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42174 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42175 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42176 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42177 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42178 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42179 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42180 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42181 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42182 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42183 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42184 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42185 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42186 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42187 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42188 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42189 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42190 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42191 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42192 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42193 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42194 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42195 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42196 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42197 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42198 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42199 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42200 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42201 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42202 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42203 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42204 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42205 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42206 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42207 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42208 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42209 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42210 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42211 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42212 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42213 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42214 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42215 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42216 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42217 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42218 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42219 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42220 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42221 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42222 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42223 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42224 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42225 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42226 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42227 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42228 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42229 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42230 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42231 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42232 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42233 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42234 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42235 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42236 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42237 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42238 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42239 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42240 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42241 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42242 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42243 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42244 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42245 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42246 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42247 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42248 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42249 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42250 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42251 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42252 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42253 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42254 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42255 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42256 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42257 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42258 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42259 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42260 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42261 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42262 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42263 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42264 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42265 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42266 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42267 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42268 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42269 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42270 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42271 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42272 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42273 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42274 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42275 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42276 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42277 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42278 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42279 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42280 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42281 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42282 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42283 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42284 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42285 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42286 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42287 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42288 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42289 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42290 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42291 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42292 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42293 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42294 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42295 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42296 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42297 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42298 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42299 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42300 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42301 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42302 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42303 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42304 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42305 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42306 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42307 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42308 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42309 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42310 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42311 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42312 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42313 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42314 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42315 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42316 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42317 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42318 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42319 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42320 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42321 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42322 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42323 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42324 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42325 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42326 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42327 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42328 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42329 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42330 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42331 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42332 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42333 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42334 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42335 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42336 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42337 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42338 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42339 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42340 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42341 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42342 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42343 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42344 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42345 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42346 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42347 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42348 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42349 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42350 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42351 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42352 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42353 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42354 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42355 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42356 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42357 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42358 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42359 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42360 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42361 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42362 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42363 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42364 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42365 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42366 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42367 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42368 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42369 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42370 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42371 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42372 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42373 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42374 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42375
42376 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42377 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42378 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42379 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42380
42381 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42382 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42383 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42384 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42385 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42386 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42387 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42388 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42389 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42390 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42391 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42392 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42393 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42394 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42395 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42396 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42397 }
42398
wxWidgets (Impactor)